@babylonjs/lite-compat 1.30.0-preview → 1.31.1-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,11 +3,14 @@ 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';
9
10
  import { LineMaterial } from '@babylonjs/lite';
11
+ import { MaxTintMagnitude } from '@babylonjs/lite';
10
12
  import { Mesh as Mesh_2 } from '@babylonjs/lite';
13
+ import { MinTemperatureKelvin } from '@babylonjs/lite';
11
14
  import { PhysicsMassProperties } from '@babylonjs/lite';
12
15
  import { PhysicsShape as PhysicsShape_2 } from '@babylonjs/lite';
13
16
  import { PhysicsShapeParameters } from '@babylonjs/lite';
@@ -15,8 +18,10 @@ import { PhysicsWorld } from '@babylonjs/lite';
15
18
  import { RenderCanvas } from '@babylonjs/lite';
16
19
  import { SceneNode } from '@babylonjs/lite';
17
20
  import { SheenProps } from '@babylonjs/lite';
21
+ import { StorageBuffer as StorageBuffer_2 } from '@babylonjs/lite';
18
22
  import { Texture2D } from '@babylonjs/lite';
19
23
  import { Texture2DArray } from '@babylonjs/lite';
24
+ import { UniformBuffer as UniformBuffer_2 } from '@babylonjs/lite';
20
25
 
21
26
  /** Base class for an asset-loading task. Subclasses implement {@link runAsync}. */
22
27
  export declare abstract class AbstractAssetTask {
@@ -215,6 +220,11 @@ export declare abstract class AbstractEngine {
215
220
  * scoped API cannot reproduce the engine-wide state without a pipeline-owner lifecycle policy.
216
221
  */
217
222
  setAlphaToCoverage(_enable: boolean): never;
223
+ /**
224
+ * Babylon.js `engine.isOcclusionQueryVisible(query)` — Lite does not expose
225
+ * occlusion-query allocation, render-pass encoding, or asynchronous result state.
226
+ */
227
+ isOcclusionQueryVisible(_query: unknown): never;
218
228
  /**
219
229
  * Babylon.js `engine.updateTextureArrayLayerFromImageSource(texture, source, layer, invertY, premultiplyAlpha)`
220
230
  * — the engine extension that uploads a decoded image source into one layer of a 2D array
@@ -236,6 +246,7 @@ export declare abstract class AbstractEngine {
236
246
  * visibility, and shadow-receipt. Concrete meshes derive from this.
237
247
  */
238
248
  export declare class AbstractMesh extends TransformNode {
239
249
  private _material;
250
+ private _meshBlendingTag;
240
251
  protected _visible: boolean;
241
252
  constructor(name: string, lite: Mesh_2, scene?: Scene);
242
253
  getClassName(): string;
243
254
  get material(): CompatMaterial | null;
@@ -246,6 +257,8 @@ export declare class AbstractMesh extends TransformNode {
246
257
  private _material;
247
258
  set isPickable(value: boolean);
248
259
  get receiveShadows(): boolean;
249
260
  set receiveShadows(value: boolean);
261
+ get meshBlendingTag(): number;
262
+ set meshBlendingTag(value: number);
250
263
  protected _onEffectiveEnabledStateChanged(enabled: boolean): void;
251
264
  /**
252
265
  * Babylon.js `mesh.getBoundingInfo()` — the mesh's AABB. `minimum`/`maximum`
253
266
  * are the local-space bounds; the returned `BoundingInfo`'s world members
@@ -605,9 +618,8 @@ export declare class Angle {
605
618
  }
606
619
 
607
620
  /**
608
- * Babylon.js `Animatable` — a running animation on a target, driven per-frame on
609
- * the CPU by evaluating each `Animation`'s keyframes and writing the result onto
610
- * the target's (dotted) property path.
621
+ * Babylon.js `Animatable` facade. Supported direct-animation tracks delegate to a
622
+ * native Lite property group; unsupported tracks retain the compat CPU evaluator.
611
623
  */
612
624
  declare class Animatable_2 {
613
625
  private readonly _target;
@@ -615,16 +627,26 @@ declare class Animatable_2 {
615
627
  private readonly _from;
616
628
  private readonly _to;
617
629
  private readonly _loop;
618
- masterFrame: number;
619
- speedRatio: number;
630
+ masterFrame: number;
620
631
  private _speedRatio;
621
632
  private _paused;
622
633
  private _stopped;
623
- constructor(_target: unknown, _animations: Animation_2[], _from: number, _to: number, _loop: boolean, speedRatio: number);
624
634
  goToFrame(frame: number): void;
635
+ private readonly _nativeManager;
636
+ private readonly _fallbackAnimations;
637
+ private readonly _fallbackFrames;
638
+ private readonly _fallbackElapsedFrames;
639
+ private readonly _fallbackRepeatCounts;
640
+ private readonly _completedFallbackAnimations;
641
+ constructor(target: unknown, animations: Animation_2[], from: number, to: number, loop: boolean, speedRatio: number);
625
642
  get speedRatio(): number;
643
+ set speedRatio(value: number);
626
644
  goToFrame(frame: number): void;
627
645
  pause(): void;
628
646
  restart(): void;
629
647
  stop(): void;
630
648
  get animationStarted(): boolean;
631
- private _apply;
649
+ private _applyFallback;
650
+ private _advanceFallback;
651
+ private _resetFallbackAnimation;
652
+ private _attachLite;
653
+ private _detachLite;
632
654
  }
633
655
  export { Animatable_2 as Animatable }
634
656
 
@@ -639,16 +661,29 @@ declare class Animation_2 {
639
661
  static readonly ANIMATIONTYPE_QUATERNION: 2;
640
662
  static readonly ANIMATIONTYPE_MATRIX: 3;
641
663
  static readonly ANIMATIONTYPE_COLOR3: 4;
664
+ static readonly ANIMATIONTYPE_VECTOR2: 5;
665
+ static readonly ANIMATIONTYPE_COLOR4: 6;
642
666
  static readonly ANIMATIONLOOPMODE_RELATIVE: 0;
643
667
  static readonly ANIMATIONLOOPMODE_CYCLE: 1;
644
668
  static readonly ANIMATIONLOOPMODE_CONSTANT: 2;
645
669
  private _keys;
670
+ private _easingFunction;
646
671
  constructor(name: string, targetProperty: string, framePerSecond: number, dataType?: number, loopMode?: number);
647
672
  setKeys(keys: IAnimationKey[]): void;
648
673
  getKeys(): IAnimationKey[];
649
674
  getHighestFrame(): number;
650
- /** Linearly evaluate the animated value at `frame` (clamped to the key range). */
651
- evaluate(frame: number): number | number[];
675
+ /**
676
+ * Assigns the easing function used to transform each non-STEP segment's normalized progress.
677
+ * @param easingFunction - A Babylon.js-shaped easing object, or `null` to restore linear progress.
678
+ */
679
+ setEasingFunction(easingFunction: IEasingFunction | null): void;
680
+ /**
681
+ * Gets the easing function currently assigned to this animation.
682
+ * @returns The assigned easing object, or `null` when interpolation uses linear progress.
683
+ */
684
+ getEasingFunction(): IEasingFunction | null;
685
+ /** Evaluate the animated value at `frame`, clamped to the key range. */
686
+ evaluate(frame: number): AnimationValue;
652
687
  /** Babylon.js helper: build a one-shot float animation between two values. */
653
688
  static CreateAndStartAnimation(name: string, _target: unknown, targetProperty: string, framePerSecond: number, totalFrame: number, from: number, to: number): Animation_2;
654
689
  }
@@ -757,6 +792,8 @@ export declare const AnimationTypes: {
757
792
  readonly ANIMATIONTYPE_COLOR4: 6;
758
793
  };
759
794
 
795
+ export declare type AnimationValue = number | number[] | IAnimationVectorValue;
796
+
760
797
  export declare interface AppendOptions extends ISceneLoaderOptions {
761
798
  }
762
799
 
@@ -979,7 +1016,7 @@ export declare class AxisScaleGizmo extends GizmoBase {
979
1016
  private _attached;
980
1017
  }
981
1018
 
982
1019
  export declare class BackEase extends EasingFunction {
983
- private readonly amplitude;
1020
+ amplitude: number;
984
1021
  constructor(amplitude?: number);
985
1022
  easeInCore(gradient: number): number;
986
1023
  }
@@ -1015,6 +1052,18 @@ export declare interface Behavior<T> {
1015
1052
  detach(): void;
1016
1053
  }
1017
1054
 
1055
+ /**
1056
+ * Babylon.js-compatible cubic Bezier easing class.
1057
+ */
1058
+ export declare class BezierCurveEase extends EasingFunction {
1059
+ x1: number;
1060
+ y1: number;
1061
+ x2: number;
1062
+ y2: number;
1063
+ constructor(x1?: number, y1?: number, x2?: number, y2?: number);
1064
+ easeInCore(gradient: number): number;
1065
+ }
1066
+
1018
1067
  export declare const BlackAndWhitePostProcess: new () => never;
1019
1068
 
1020
1069
  export declare const BloomEffect: new () => never;
@@ -1034,8 +1083,8 @@ export declare class Bone {
1034
1083
  }
1035
1084
 
1036
1085
  export declare class BounceEase extends EasingFunction {
1037
- private readonly bounces;
1038
- private readonly bounciness;
1086
+ bounces: number;
1087
+ bounciness: number;
1039
1088
  constructor(bounces?: number, bounciness?: number);
1040
1089
  easeInCore(gradient: number): number;
1041
1090
  }
@@ -1344,6 +1393,12 @@ export declare class Color3 {
1344
1393
  static Lerp(start: Color3, end: Color3, amount: number): Color3;
1345
1394
  }
1346
1395
 
1396
+ declare interface Color3Like {
1397
+ readonly r: number;
1398
+ readonly g: number;
1399
+ readonly b: number;
1400
+ }
1401
+
1347
1402
  export declare class Color4 {
1348
1403
  r: number;
1349
1404
  g: number;
@@ -1361,6 +1416,10 @@ export declare class Color4 {
1361
1416
  static FromInts(r: number, g: number, b: number, a: number): Color4;
1362
1417
  }
1363
1418
 
1419
+ declare interface Color4Like extends Color3Like {
1420
+ readonly a: number;
1421
+ }
1422
+
1364
1423
  /** An RGBA color bound to a [0, 1] position (Babylon.js `ColorGradient`). */
1365
1424
  export declare class ColorGradient {
1366
1425
  gradient: number;
@@ -1377,9 +1436,66 @@ export declare function CompleteGreasedLineColorTable(..._args: unknown[]): neve
1377
1436
 
1378
1437
  export declare function CompleteGreasedLineWidthTable(..._args: unknown[]): never;
1379
1438
 
1439
+ export declare interface ComputeBindingLocation {
1440
+ group: number;
1441
+ binding: number;
1442
+ }
1443
+
1444
+ export declare type ComputeBindingMapping = Record<string, ComputeBindingLocation>;
1445
+
1446
+ declare type ComputeEffect = ComputeShader_2;
1447
+
1380
1448
  /** Babylon.js `ComputeOverlayCssTransform` — HTML overlay interaction is unsupported by the compat layer. */
1381
1449
  export declare function ComputeOverlayCssTransform(): never;
1382
1450
 
1451
+ /** Babylon.js ComputeShader adapted to Lite's public buffer-backed compute graph. */
1452
+ export declare class ComputeShader {
1453
+ private readonly _engine;
1454
+ private readonly _shaderPath;
1455
+ static readonly Parse: typeof ComputeShaderParse;
1456
+ readonly uniqueId: number;
1457
+ name: string;
1458
+ fastMode: boolean;
1459
+ onCompiled: ((effect: ComputeEffect) => void) | null;
1460
+ onError: ((effect: ComputeEffect, errors: string) => void) | null;
1461
+ readonly gpuTimeInFrame: undefined;
1462
+ triggerContextRebuild: boolean;
1463
+ private readonly _source;
1464
+ private readonly _bindings;
1465
+ private _shader;
1466
+ private _bindingSet;
1467
+ private _bindingsDirty;
1468
+ private _shaderDirty;
1469
+ private _compiled;
1470
+ constructor(name: string, _engine: AbstractEngine, _shaderPath: IComputeShaderPath | string, options?: Partial<IComputeShaderOptions>);
1471
+ private readonly _options;
1472
+ get options(): IComputeShaderOptions;
1473
+ get shaderPath(): string | IComputeShaderPath;
1474
+ getClassName(): string;
1475
+ setTexture(_name: string, _texture: BaseTexture, _bindSampler?: boolean): never;
1476
+ setInternalTexture(_name: string, _texture: unknown): never;
1477
+ setStorageTexture(_name: string, _texture: BaseTexture): never;
1478
+ setExternalTexture(_name: string, _texture: unknown): never;
1479
+ setVideoTexture(_name: string, _texture: unknown): false;
1480
+ setUniformBuffer(name: string, buffer: UniformBuffer | UniformBuffer_2): void;
1481
+ setStorageBuffer(name: string, buffer: StorageBuffer | StorageBuffer_2): void;
1482
+ setTextureSampler(_name: string, _sampler: unknown): never;
1483
+ isReady(): boolean;
1484
+ dispatch(x: number, y?: number, z?: number): boolean;
1485
+ dispatchIndirect(buffer: StorageBuffer | StorageBuffer_2, offset?: number): boolean;
1486
+ dispatchWhenReady(x: number, y?: number, z?: number, delay?: number): Promise<void>;
1487
+ serialize(): Record<string, unknown>;
1488
+ private _createGraph;
1489
+ private _createShader;
1490
+ private _createBindingSet;
1491
+ private _submit;
1492
+ private _invalidateBindings;
1493
+ }
1494
+
1495
+ export declare function ComputeShaderParse(source: Record<string, unknown>, scene: {
1496
+ getEngine(): AbstractEngine;
1497
+ }, _rootUrl: string): ComputeShader;
1498
+
1383
1499
  /** Base class for action conditions. */
1384
1500
  export declare abstract class Condition {
1385
1501
  abstract isValid(): boolean;
@@ -1412,6 +1528,14 @@ export declare const Constants: {
1412
1528
  readonly TEXTURE_TRILINEAR_SAMPLINGMODE: 3;
1413
1529
  readonly TEXTUREFORMAT_RGBA: 5;
1414
1530
  readonly TEXTURETYPE_UNSIGNED_BYTE: 0;
1531
+ readonly BUFFER_CREATIONFLAG_READ: 1;
1532
+ readonly BUFFER_CREATIONFLAG_WRITE: 2;
1533
+ readonly BUFFER_CREATIONFLAG_READWRITE: 3;
1534
+ readonly BUFFER_CREATIONFLAG_UNIFORM: 4;
1535
+ readonly BUFFER_CREATIONFLAG_VERTEX: 8;
1536
+ readonly BUFFER_CREATIONFLAG_INDEX: 16;
1537
+ readonly BUFFER_CREATIONFLAG_STORAGE: 32;
1538
+ readonly BUFFER_CREATIONFLAG_INDIRECT: 64;
1415
1539
  };
1416
1540
 
1417
1541
  /** Babylon.js `CreateAudioBusAsync`. */
@@ -1429,6 +1553,8 @@ export declare function CreateCylinder(name: string, options: CylinderOptions, s
1429
1553
  /** Babylon.js `CreateDashedLines(name, options, scene)` (linesBuilder). */
1430
1554
  export declare function CreateDashedLines(name: string, options: DashedLinesBuilderOptions, scene?: Scene | null): LinesMesh;
1431
1555
 
1556
+ export declare function CreateDefaultMeshBlendRadiusDefinitions(): MeshBlendRadiusDefinitions;
1557
+
1432
1558
  /** Babylon.js `CreateDisc(name, options, scene)` (discBuilder). */
1433
1559
  export declare function CreateDisc(name: string, options: object, scene: Scene): Mesh;
1434
1560
 
@@ -1627,6 +1753,8 @@ declare interface DashedLinesBuilderOptions {
1627
1753
  material?: unknown;
1628
1754
  }
1629
1755
 
1756
+ export declare type DataArray = number[] | ArrayBufferLike | ArrayBufferView;
1757
+
1630
1758
  declare interface DefaultEnvironmentOptions {
1631
1759
  createSkybox?: boolean;
1632
1760
  createGround?: boolean;
@@ -1671,6 +1799,29 @@ export declare class DistanceConstraint extends PhysicsConstraint {
1671
1799
  constructor(maxDistance: number, scene: Scene);
1672
1800
  }
1673
1801
 
1802
+ export declare class DitheredTileFadeMaterialPlugin extends MaterialPluginBase {
1803
+ static readonly Name = "DitheredTileFade";
1674
1804
  constructor(material: DitheredTileFadeSupportedMaterial);
1805
+ static GetOrCreate(_material: DitheredTileFadeSupportedMaterial): DitheredTileFadeMaterialPlugin;
1806
+ get isEnabled(): boolean;
1807
+ set isEnabled(_value: boolean);
1808
+ setFadeBounds(_mesh: DitheredTileFadeMesh, _lowerBound: number, _upperBound: number): void;
1809
+ setFadeLowerBound(_mesh: DitheredTileFadeMesh, _lowerBound: number): void;
1810
+ setFadeUpperBound(_mesh: DitheredTileFadeMesh, _upperBound: number): void;
1811
+ getFadeBoundsToRef(_mesh: DitheredTileFadeMesh, _result: IDitheredTileFadeBounds): boolean;
1812
+ resetFade(_mesh: DitheredTileFadeMesh): void;
1813
+ setThinInstanceFadeBounds(_mesh: Mesh, _index: number, _lowerBound: number, _upperBound: number, _refresh?: boolean): void;
1814
+ setThinInstanceFadeBoundsBuffer(_mesh: Mesh, _bounds: Float32Array): void;
1815
+ commitThinInstanceFadeBounds(_mesh: Mesh): void;
1816
+ resetThinInstanceFade(_mesh: Mesh, _index: number, _refresh?: boolean): void;
1817
+ reset(): void;
1818
+ copyToMaterial(_material: DitheredTileFadeSupportedMaterial): DitheredTileFadeMaterialPlugin;
1819
+ getClassName(): string;
1820
+ }
1821
+
1822
+ export declare type DitheredTileFadeMesh = Mesh | InstancedMesh;
1823
+
1824
+ export declare type DitheredTileFadeSupportedMaterial = StandardMaterial | PBRMaterial;
1825
+
1675
1826
  /** Babylon.js drag move payload. */
1676
1827
  declare type DragEvent_2 = {
1677
1828
  delta: Vector3;
@@ -1719,7 +1870,7 @@ export declare class DynamicTexture extends BaseTexture {
1719
1870
  whenReadyAsync(): Promise<void>;
1720
1871
  }
1721
1872
 
1722
- export declare abstract class EasingFunction {
1873
+ export declare abstract class EasingFunction implements IEasingFunction {
1723
1874
  static readonly EASINGMODE_EASEIN = 0;
1724
1875
  static readonly EASINGMODE_EASEOUT = 1;
1725
1876
  static readonly EASINGMODE_EASEINOUT = 2;
@@ -1732,10 +1883,10 @@ export declare abstract class EasingFunction {
1732
1883
  }
1733
1884
 
1734
1885
  /**
1735
- * Babylon.js-compatible easing functions (pure, no Babylon Lite dependency).
1886
+ * Babylon.js-compatible easing functions over Babylon Lite's functional curves.
1736
1887
  *
1737
- * These mirror Babylon.js's `EasingFunction` hierarchy and easing modes for use
1738
- * with property animations. They are fully unit-testable.
1888
+ * These retain Babylon.js's class hierarchy and easing modes for porting while
1889
+ * delegating curve math to tree-shakable native Lite functions.
1739
1890
  */
1740
1891
  export declare const EASINGMODE_EASEIN = 0;
1741
1892
 
@@ -1752,8 +1903,8 @@ export declare class EffectLayer {
1752
1903
  }
1753
1904
 
1754
1905
  export declare class ElasticEase extends EasingFunction {
1755
- private readonly oscillations;
1756
- private readonly springiness;
1906
+ oscillations: number;
1907
+ springiness: number;
1757
1908
  constructor(oscillations?: number, springiness?: number);
1758
1909
  easeInCore(gradient: number): number;
1759
1910
  }
@@ -1778,7 +1929,7 @@ export declare class ExecuteCodeAction extends Action {
1778
1929
  }
1779
1930
 
1780
1931
  export declare class ExponentialEase extends EasingFunction {
1781
- private readonly exponent;
1932
+ exponent: number;
1782
1933
  constructor(exponent?: number);
1783
1934
  easeInCore(gradient: number): number;
1784
1935
  }
@@ -1796,8 +1947,128 @@ export declare class FadeInOutBehavior {
1796
1947
  constructor();
1797
1948
  }
1798
1949
 
1950
+ export declare class FBXConstraintBehavior {
1951
+ readonly constraint: FBXConstraintData;
1952
+ readonly name: string;
1953
+ attachedNode: TransformNode | null;
1954
+ enabled: boolean;
1955
+ constructor(constraint: FBXConstraintData, _options: FBXConstraintBehaviorOptions);
1956
+ init(): void;
1957
+ attach(_target: TransformNode): void;
1958
+ detach(): void;
1959
+ captureBase(): void;
1960
+ restoreBase(): void;
1961
+ dependencyNodes(): Array<Node_2 | null>;
1962
+ evaluate(): void;
1963
+ }
1964
+
1965
+ export declare interface FBXConstraintBehaviorOptions {
1966
+ root: TransformNode;
1967
+ targets: FBXConstraintBehaviorTarget[];
1968
+ upNode: TransformNode | null;
1969
+ sceneUp: Vector3;
1970
+ }
1971
+
1972
+ export declare interface FBXConstraintBehaviorTarget {
1973
+ node: TransformNode;
1974
+ weight: number;
1975
+ offset: Matrix;
1976
+ }
1977
+
1978
+ declare type FBXConstraintBoolean3 = [boolean, boolean, boolean];
1979
+
1980
+ export declare interface FBXConstraintData {
1981
+ id: number;
1982
+ name: string;
1983
+ type: FBXConstraintType;
1984
+ typeName: string;
1985
+ nodeId?: number;
1986
+ targets: FBXConstraintTarget[];
1987
+ weight: number;
1988
+ active: boolean;
1989
+ affectTranslation: FBXConstraintBoolean3;
1990
+ affectRotation: FBXConstraintBoolean3;
1991
+ affectScale: FBXConstraintBoolean3;
1992
+ offsetTranslation: FBXConstraintVector3;
1993
+ offsetRotation: FBXConstraintVector3;
1994
+ offsetScale: FBXConstraintVector3;
1995
+ aimVector: FBXConstraintVector3;
1996
+ upVector: FBXConstraintVector3;
1997
+ worldUpVector: FBXConstraintVector3;
1998
+ worldUpType: number;
1999
+ worldUpNodeId?: number;
2000
+ ikFirstJointId?: number;
2001
+ ikEndJointId?: number;
2002
+ ikEffectorId?: number;
2003
+ ikPoleVector: FBXConstraintVector3;
2004
+ }
2005
+
2006
+ export declare class FBXConstraintSolver {
2007
+ private constructor();
2008
+ static Get(_scene: Scene): FBXConstraintSolver | undefined;
2009
+ static GetOrCreate(_scene: Scene): FBXConstraintSolver;
2010
+ get constraints(): readonly FBXConstraintBehavior[];
2011
+ get cyclicConstraints(): readonly FBXConstraintBehavior[];
2012
+ register(_behavior: FBXConstraintBehavior): void;
2013
+ unregister(_behavior: FBXConstraintBehavior): void;
2014
+ invalidateOrder(): void;
2015
+ beginFrame(): void;
2016
+ solve(): void;
2017
+ }
2018
+
2019
+ export declare interface FBXConstraintTarget {
2020
+ modelId: number;
2021
+ weight: number;
2022
+ offsetTranslation: FBXConstraintVector3;
2023
+ offsetRotation: FBXConstraintVector3;
2024
+ offsetScale: FBXConstraintVector3;
2025
+ }
2026
+
2027
+ export declare type FBXConstraintType = "aim" | "parent" | "position" | "rotation" | "scale" | "singleChainIK" | "unknown";
2028
+
2029
+ declare type FBXConstraintVector3 = [number, number, number];
2030
+
1799
2031
  export declare class FBXFileLoader {
1800
- constructor();
2032
+ constructor(_options?: Partial<FBXFileLoaderOptions>);
2033
+ }
2034
+
2035
+ export declare const FBXFileLoaderMetadata: {
2036
+ readonly name: "fbx";
2037
+ readonly extensions: {
2038
+ readonly ".fbx": {
2039
+ readonly isBinary: true;
2040
+ };
2041
+ };
2042
+ };
2043
+
2044
+ export declare interface FBXFileLoaderOptions {
2045
+ preset?: "compatible" | "full";
2046
+ normalMapCoordinateSystem?: FBXNormalMapCoordinateSystem;
2047
+ materials?: "auto" | "standard" | "pbr";
2048
+ unitScale?: "preserve" | "meters" | number;
2049
+ shareGeometry?: boolean;
2050
+ onWarning?: (warning: FBXLoaderWarning) => void;
2051
+ nurbsSubdivision?: number;
2052
+ curves?: "lines" | "skip";
2053
+ constraints?: "apply" | "metadata";
2054
+ rebaseAnimations?: boolean;
2055
+ attachCamerasAndLights?: boolean;
2056
+ }
2057
+
2058
+ export declare interface FBXLoaderWarning {
2059
+ source: "scene" | "model" | "geometry" | "skin" | "rig" | "animation" | "blendShape" | "camera" | "light";
2060
+ message: string;
2061
+ objectName?: string;
2062
+ details?: unknown;
2063
+ }
2064
+
2065
+ export declare type FBXNormalMapCoordinateSystem = "y-up" | "y-down";
2066
+
2067
+ declare type FloatArray = number[] | Float32Array;
2068
+
2069
+ export declare enum FlowGraphValidationSeverity {
2070
+ Error = 0,
2071
+ Warning = 1
1801
2072
  }
1802
2073
 
1803
2074
  export declare class FluidRenderer {
@@ -1851,6 +2122,10 @@ export declare class FollowCamera extends TargetCamera {
1851
2122
  private _follow;
1852
2123
  }
1853
2124
 
2125
+ export declare class FrameGraphMeshBlendingTask {
2126
+ constructor(..._args: unknown[]);
2127
+ }
2128
+
1854
2129
  /** Frames an `ArcRotateCamera` on a target by setting its radius (no zoom tween). */
1855
2130
  export declare class FramingBehavior implements Behavior<ArcRotateCamera> {
1856
2131
  readonly name = "Framing";
@@ -1933,6 +2208,7 @@ export declare class GaussianSplattingMesh extends TransformNode {
1933
2208
  /**
1934
2209
 
1935
2210
  export declare class GaussianSplattingStream {
1936
2211
  constructor(..._args: unknown[]);
2212
+ get minimumResidentSplats(): never;
1937
2213
  }
1938
2214
 
1939
2215
  /** Babylon.js `GaussianSplattingStreamDebugLodSource` — LOD debug source selector (shape-only stub for type parity). */
@@ -2001,7 +2277,7 @@ export declare function GetPointsCount(..._args: unknown[]): never;
2001
2277
  */
2002
2278
  export declare function GetSupportedSimultaneousLights(scene: Scene, maxSimultaneousLights: number): number;
2003
2279
 
2004
- export declare function GetWhiteBalanceMatrix(_temperatureKelvin: number, _tint: number): Float32Array | number[];
2280
+ export declare function GetWhiteBalanceMatrix(temperatureKelvin: number, tint: number): Float32Array;
2005
2281
 
2006
2282
  /** Shared base for compat gizmos (Babylon.js `Gizmo`). */
2007
2283
  declare abstract class GizmoBase {
2008
2284
  protected constructor(layer: UtilityLayerRenderer);
@@ -2051,7 +2327,82 @@ export declare namespace GLTF1 {
2051
2327
 
2052
2328
  export declare namespace GLTF2 {
2053
2329
  export {
2054
- OpenPBRMaterialLoadingAdapter
2330
+ OpenPBRMaterialLoadingAdapter,
2331
+ ParseDebugLogTemplate,
2332
+ getMappingForFullOperationName,
2333
+ getMappingForDeclaration,
2334
+ getNoOpMappingForDeclaration,
2335
+ addNewInteractivityFlowGraphMapping,
2336
+ getAllSupportedNativeNodeTypes,
2337
+ HasDefaultInteractivityFlowInput,
2338
+ NormalizeInteractivityEventDataConfiguration,
2339
+ GetInteractivityOperationRegistry,
2340
+ GetInteractivityObjectReference,
2341
+ _NormalizeKHRInteractivityRuntimeValue,
2342
+ _CreateKHRInteractivityRuntimeValueSnapshot,
2343
+ CloneKHRInteractivityGraph,
2344
+ CreateEffectiveKHRInteractivityGraph,
2345
+ CreateKHRInteractivityGraphModel,
2346
+ CreateKHRInteractivityDocument,
2347
+ _CaptureKHRInteractivityRuntimeInputDefaults,
2348
+ CreateKHRInteractivityExportPlan,
2349
+ InitializeInteractivityNodeState,
2350
+ GetInteractivityNodeState,
2351
+ SetInteractivityNodeState,
2352
+ KHRInteractivitySignature,
2353
+ IKHRInteractivityNode,
2354
+ IKHRInteractivityGraph,
2355
+ IKHRInteractivityDeclaration,
2356
+ IKHRInteractivityType,
2357
+ IKHRInteractivityVariable,
2358
+ IKHRInteractivityEvent,
2359
+ IKHRInteractivityOutputSocketReference,
2360
+ IKHRInteractivityOutputFlow,
2361
+ IKHRInteractivityConfiguration,
2362
+ IGLTF,
2363
+ ISerializedFlowGraphConnection,
2364
+ ISerializedFlowGraphBlock,
2365
+ ISerializedFlowGraphContext,
2366
+ ISerializedFlowGraph,
2367
+ IGLTFToFlowGraphMappingObject,
2368
+ IGLTFToFlowGraphMapping,
2369
+ IKHRInteractivityOperationRegistryEntry,
2370
+ IDebugLogTemplateParseResult,
2371
+ KHRInteractivityFlowGraphType,
2372
+ IKHRInteractivityTypeMapping,
2373
+ gltfTypeToBabylonType,
2374
+ IFlowGraphEventReferenceBlockConfiguration,
2375
+ FlowGraphEventReferenceBlock,
2376
+ IFlowGraphGLTFDataProviderBlockConfiguration,
2377
+ FlowGraphGLTFDataProvider,
2378
+ FlowGraphObjectReferenceBlock,
2379
+ IFlowGraphUnsupportedInteractivitySocket,
2380
+ IFlowGraphUnsupportedInteractivityBlockConfiguration,
2381
+ FlowGraphUnsupportedInteractivityBlock,
2382
+ KHR_INTERACTIVITY_SPECIFICATION_COMMIT,
2383
+ KHRInteractivityDeclarationSupport,
2384
+ IKHRInteractivityDiagnostic,
2385
+ IKHRInteractivityDeclarationModel,
2386
+ IKHRInteractivityGraphModel,
2387
+ IKHRInteractivityInputDefaultProvenance,
2388
+ IKHRInteractivityConfigurationProvenance,
2389
+ IKHRInteractivityBlockProvenance,
2390
+ IKHRInteractivitySocketProvenance,
2391
+ IKHRInteractivityGraphProvenance,
2392
+ IKHRInteractivityDocument,
2393
+ KHRInteractivityExportClassification,
2394
+ IKHRInteractivityExportDiagnostic,
2395
+ IKHRInteractivityNodeExportAnalysis,
2396
+ IKHRInteractivityExportAnalysis,
2397
+ KhrInteractivityRootCollection,
2398
+ IKHRInteractivitySerializerContext,
2399
+ IKHRInteractivityExportProvider,
2400
+ IKHRInteractivityExportOptions,
2401
+ KHRInteractivityExportError,
2402
+ KHRInteractivityExportPlan,
2403
+ InteractivityEvent,
2404
+ InteractivityGraphToFlowGraphParser,
2405
+ InteractivityNodeState
2055
2406
  }
2056
2407
  }
2057
2408
 
@@ -2382,11 +2733,21 @@ export declare interface IAbstractSoundOptions extends Partial<IVolumeAudioOptio
2382
2733
 
2383
2734
  export declare interface IAnimationKey {
2384
2735
  frame: number;
2385
- value: number | number[];
2736
+ value: AnimationValue;
2386
2737
  /** Babylon.js per-key interpolation hint (`AnimationKeyInterpolation`). */
2387
2738
  interpolation?: number;
2388
2739
  }
2389
2740
 
2741
+ /** Structural vector/quaternion value accepted by Babylon.js animation keys. */
2742
+ export declare interface IAnimationVectorValue {
2743
+ readonly x: number;
2744
+ readonly y: number;
2745
+ readonly z?: number;
2746
+ readonly w?: number;
2747
+ clone(): IAnimationVectorValue;
2748
+ asArray(): number[];
2749
+ }
2750
+
2390
2751
  /** Babylon.js `IAudioAnalyzerOptions`. */
2391
2752
  export declare interface IAudioAnalyzerOptions {
2392
2753
  /** Build the analyzer immediately. Defaults to `false`. */
@@ -2440,6 +2801,20 @@ export declare interface ICharacterControllerCollisionEvent {
2440
2801
  impulsePosition: Vector3;
2441
2802
  }
2442
2803
 
2804
+ export declare interface IComputeShaderOptions {
2805
+ bindingsMapping: ComputeBindingMapping;
2806
+ defines?: string[];
2807
+ entryPoint?: string;
2808
+ processFinalCode?: ((code: string) => string) | null;
2809
+ useExplicitComputePipelineLayout?: boolean;
2810
+ }
2811
+
2812
+ export declare interface IComputeShaderPath {
2813
+ computeSource?: string;
2814
+ compute?: string;
2815
+ computeElement?: string;
2816
+ }
2817
+
2443
2818
  /** Babylon.js `ICreateTexture2DArrayFromImageUrlsOptions`. */
2444
2819
  export declare interface ICreateTexture2DArrayFromImageUrlsOptions extends IUploadImageToTexture2DArrayLayerOptions {
2445
2820
  /** Generate a full mip chain (true by default). */
@@ -2462,6 +2837,40 @@ export declare interface ICreateTexture2DArrayFromKTX2Options {
2462
2837
  invertY?: boolean;
2463
2838
  }
2464
2839
 
2840
+ export declare interface IDitheredTileFadeBounds {
2841
+ lowerBound: number;
2842
+ upperBound: number;
2843
+ }
2844
+
2845
+ /**
2846
+ * Contract implemented by Babylon.js easing functions.
2847
+ *
2848
+ * Custom easing objects only need to transform a normalized segment gradient.
2849
+ */
2850
+ export declare interface IEasingFunction {
2851
+ /**
2852
+ * Transform a segment-local gradient.
2853
+ * @param gradient - Linear progress through the current keyframe segment.
2854
+ * @returns The progress used for interpolation. Values are not clamped.
2855
+ */
2856
+ ease(gradient: number): number;
2857
+ }
2858
+
2859
+ export declare interface IFlowGraphValidationIssue {
2860
+ severity: FlowGraphValidationSeverity;
2861
+ message: string;
2862
+ block?: unknown;
2863
+ connectionName?: string;
2864
+ }
2865
+
2866
+ export declare interface IFlowGraphValidationResult {
2867
+ isValid: boolean;
2868
+ issues: IFlowGraphValidationIssue[];
2869
+ errorCount: number;
2870
+ warningCount: number;
2871
+ issuesByBlock: Map<string, IFlowGraphValidationIssue[]>;
2872
+ }
2873
+
2465
2874
  /** Babylon.js `IGaussianSplattingStreamingPart` — a streamed part of a GS compound mesh (shape-only stub for type parity). */
2466
2875
  export declare interface IGaussianSplattingStreamingPart {
2467
2876
  [key: string]: unknown;
@@ -2546,6 +2955,32 @@ declare type ImageSource = ImageBitmap | HTMLImageElement | HTMLCanvasElement |
2546
2955
  export declare interface IMainAudioBusOptions extends Partial<IVolumeAudioOptions> {
2547
2956
  }
2548
2957
 
2958
+ export declare interface IMeshBlendConfiguration {
2959
+ quality?: MeshBlendQuality;
2960
+ radiusClasses?: MeshBlendRadiusDefinitions;
2961
+ slopeFactor?: number;
2962
+ depthType?: MeshBlendDepthType;
2963
+ debugMode?: MeshBlendDebugMode;
2964
+ }
2965
+
2966
+ export declare interface IMeshBlendingPostProcessOptions extends IMeshBlendConfiguration {
2967
+ effectWrapper?: ThinMeshBlendingPostProcess;
2968
+ meshBlendTagTexture: unknown;
2969
+ depthTexture: unknown;
2970
+ baseColorTexture?: unknown;
2971
+ [key: string]: unknown;
2972
+ }
2973
+
2974
+ export declare interface IMeshBlendingTag {
2975
+ groupId: number;
2976
+ radiusClass: MeshBlendingRadiusClass;
2977
+ }
2978
+
2979
+ export declare interface IMeshBlendRadiusDefinition {
2980
+ worldRadius: number;
2981
+ minimumProjectedRadius: number;
2982
+ }
2983
+
2549
2984
  /** Babylon.js `ImportMeshAsync(source, scene, options?)` — imports an asset into the scene. */
2550
2985
  export declare function ImportMeshAsync(source: string, scene: Scene, options?: ImportMeshOptions): Promise<ImportResult>;
2551
2986
 
@@ -2754,6 +3189,10 @@ export declare interface IStreamingSoundPlayOptions {
2754
3189
  volume?: number;
2755
3190
  }
2756
3191
 
3192
+ export declare interface IThinMeshBlendingPostProcessOptions extends IMeshBlendConfiguration {
3193
+ [key: string]: unknown;
3194
+ }
3195
+
2757
3196
  /** Babylon.js `IUploadImageToTexture2DArrayLayerOptions`. */
2758
3197
  export declare interface IUploadImageToTexture2DArrayLayerOptions {
2759
3198
  /** Store the source with the Y axis inverted (false by default). */
@@ -2933,7 +3372,8 @@ export declare class MainAudioBus extends AbstractAudioBus {
2933
3372
  getClassName():
2934
3373
 
2935
3374
  /** Babylon.js `Material` — base class for all materials. */
2936
3375
  export declare abstract class Material {
2937
- name: string;
3376
+ name: string;
2938
3377
  /** Babylon.js plugin manager, created lazily by the first `MaterialPluginBase`. */
3378
+ pluginManager: MaterialPluginManager | undefined;
2939
3379
  /** Common transparency mode flag (Babylon.js `Material.transparencyMode`). */
2940
3380
  transparencyMode: number | null;
2941
3381
  /** Back-face culling toggle (Babylon.js `Material.backFaceCulling`). */
@@ -2965,6 +3405,75 @@ export declare class MaterialGreasedLineDefines {
2965
3405
  constructor(..._args: unknown[]);
2966
3406
  }
2967
3407
 
3408
+ /**
3409
+ * Babylon.js `MaterialPluginBase` adapter over Lite's opt-in material-plugin
3410
+ * bridge. Subclasses keep the Babylon.js override shape while Lite receives a
3411
+ * plain plugin descriptor.
3412
+ */
3413
+ export declare class MaterialPluginBase {
3414
+ private _name;
3415
+ private _priority;
3416
+ private _resolveIncludes;
3417
+ readonly markAllDefinesAsDirty: () => void;
3418
+ registerForExtraEvents: boolean;
3419
+ doNotSerialize: boolean;
3420
+ protected readonly _material: Material;
3421
+ protected readonly _pluginManager: MaterialPluginManager;
3422
+ protected readonly _pluginDefineNames?: MaterialPluginDefines;
2968
3423
  constructor(material: Material, name: string, priority: number, defines?: MaterialPluginDefines, addToPluginList?: boolean, enable?: boolean, resolveIncludes?: boolean);
3424
+ get name(): string;
3425
+ set name(value: string);
3426
+ get priority(): number;
3427
+ set priority(value: number);
3428
+ get resolveIncludes(): boolean;
3429
+ set resolveIncludes(value: boolean);
2969
3430
  protected _enable(enable: boolean): void;
2970
3431
  private _assertSupportedExecution;
3432
+ isCompatible(_shaderLanguage: ShaderLanguage): boolean;
3433
+ getCustomCode(_shaderType: string, _shaderLanguage?: ShaderLanguage): MaterialPluginCustomCode | null;
3434
+ isReadyForSubMesh(_defines: object, _scene: Scene, _engine: object, _subMesh: object): boolean;
3435
+ hardBindForSubMesh(_uniformBuffer: object, _scene: Scene, _engine: object, _subMesh: object): void;
3436
+ bindForSubMesh(_uniformBuffer: object, _scene: Scene, _engine: object, _subMesh: object): void;
3437
+ collectDefines(defines: Record<string, {
3438
+ type: string;
3439
+ default: unknown;
3440
+ }>): void;
3441
+ prepareDefinesBeforeAttributes(_defines: object, _scene: Scene, _mesh: AbstractMesh): void;
3442
+ prepareDefines(_defines: object, _scene: Scene, _mesh: AbstractMesh): void;
3443
+ hasTexture(_texture: BaseTexture): boolean;
3444
+ hasRenderTargetTextures(): boolean;
3445
+ fillRenderTargetTextures(_renderTargets: SmartArray<RenderTargetTexture>): void;
3446
+ getActiveTextures(_activeTextures: BaseTexture[]): void;
3447
+ getAnimatables(_animatables: object[]): void;
3448
+ addFallbacks(_defines: object, _fallbacks: object, currentRank: number): number;
3449
+ getSamplers(_samplers: string[]): void;
3450
+ getAttributes(_attributes: string[], _scene: Scene, _mesh: AbstractMesh): void;
3451
+ getUniformBuffersNames(_ubos: string[]): void;
3452
+ getUniforms(_shaderLanguage?: ShaderLanguage): {
3453
+ ubo?: Array<{
3454
+ name: string;
3455
+ size?: number;
3456
+ type?: string;
3457
+ arraySize?: number;
3458
+ }>;
3459
+ vertex?: string;
3460
+ fragment?: string;
3461
+ externalUniforms?: string[];
3462
+ };
3463
+ getClassName(): string;
3464
+ copyTo(plugin: MaterialPluginBase): void;
3465
+ serialize(): Record<string, unknown>;
3466
+ parse(source: Record<string, unknown>, _scene: Scene, _rootUrl: string): void;
3467
+ dispose(_forceDisposeTextures?: boolean): void;
3468
+ }
3469
+
3470
+ export declare type MaterialPluginCustomCode = Record<string, string>;
3471
+
3472
+ export declare type MaterialPluginDefines = Record<string, unknown>;
3473
+
3474
+ /** Babylon.js-shaped manager for the adapter-visible material plugin list. */
3475
+ export declare class MaterialPluginManager {
3476
+ private readonly _plugins;
3477
+ constructor(material: Material);
2971
3478
  getPlugin<T = MaterialPluginBase>(name: string): T | null;
3479
+ }
3480
+
2972
3481
  export declare class Matrix {
2973
3482
  readonly m: Float32Array;
2974
3483
  constructor();
@@ -3024,7 +3533,12 @@ export declare class Matrix {
3024
3533
  markAsUpdated(): this;
3025
3534
  }
3026
3535
 
3027
- export declare const MaxTintMagnitude = 150;
3536
+ declare interface MatrixLike {
3537
+ asArray(): ArrayLike<number>;
3538
+ readonly updateFlag?: number;
3539
+ }
3540
+
3541
+ export { MaxTintMagnitude }
3028
3542
 
3029
3543
  /** Babylon.js `Mesh` — a concrete renderable mesh with geometry. */
3030
3544
  export declare class Mesh extends AbstractMesh {
@@ -3097,6 +3611,47 @@ export declare class Mesh extends AbstractMesh {
3097
3611
  static MergeMeshes(meshes: (Mesh | null | undefined)[], disposeSource?: boolean, allow32BitsIndices?: boolean, meshSubclass?: Mesh, subdivideWithSubMeshes?: boolean, multiMultiMaterials?: boolean): Mesh | null;
3098
3612
  }
3099
3613
 
3614
+ export declare enum MeshBlendDebugMode {
3615
+ Off = 0,
3616
+ PackedTag = 1,
3617
+ CandidateDirectionDistance = 2,
3618
+ SeamFade = 3,
3619
+ RejectionReason = 4,
3620
+ StageWork = 5,
3621
+ Continuation = 6,
3622
+ TinyObject = 7,
3623
+ MultiTarget = 8,
3624
+ TargetColor = 9,
3625
+ ShadowAttenuation = 10,
3626
+ ColorInterpolation = 11,
3627
+ WorldPosition = 12
3628
+ }
3629
+
3630
+ export declare enum MeshBlendDepthType {
3631
+ View = 0,
3632
+ Screen = 1
3633
+ }
3634
+
3635
+ export declare class MeshBlendingPostProcess {
3636
+ constructor(..._args: unknown[]);
3637
+ }
3638
+
3639
+ export declare enum MeshBlendingRadiusClass {
3640
+ Small = 0,
3641
+ Medium = 1,
3642
+ Large = 2,
3643
+ ExtraLarge = 3
3644
+ }
3645
+
3646
+ export declare enum MeshBlendQuality {
3647
+ Low = 0,
3648
+ Medium = 1,
3649
+ High = 2,
3650
+ Cinematic = 3
3651
+ }
3652
+
3653
+ export declare type MeshBlendRadiusDefinitions = readonly [IMeshBlendRadiusDefinition, IMeshBlendRadiusDefinition, IMeshBlendRadiusDefinition, IMeshBlendRadiusDefinition];
3654
+
3100
3655
  /** Babylon.js `MeshBuilder` — factory namespace for primitive meshes. */
3101
3656
  export declare const MeshBuilder: {
3102
3657
  CreateBox(name: string, options: BoxOptions, scene: Scene): Mesh;
@@ -3161,7 +3716,7 @@ export declare class MeshoptCompression {
3161
3716
  static get Default(): MeshoptCompression;
3162
3717
  }
3163
3718
 
3164
- export declare const MinTemperatureKelvin: number;
3719
+ export { MinTemperatureKelvin }
3165
3720
 
3166
3721
  export declare class MirrorTexture {
3167
3722
  constructor();
@@ -3230,6 +3785,14 @@ declare abstract class Node_2 {
3230
3785
  * descendant nodes that are meshes (all descendants by default).
3231
3786
  */
3232
3787
  getChildMeshes(directDescendantsOnly?: boolean, predicate?: (node: Node_2) => boolean): Node_2[];
3788
+ /**
3789
+ * Babylon.js `node.getHierarchyBoundingVectors(includeDescendants?, predicate?)`
3790
+ * — world-space bounds spanning this mesh and eligible descendant meshes.
3791
+ */
3792
+ getHierarchyBoundingVectors(includeDescendants?: boolean, predicate?: ((mesh: AbstractMesh) => boolean) | null): {
3793
+ min: Vector3;
3794
+ max: Vector3;
3795
+ };
3233
3796
  isEnabled(checkAncestors?: boolean): boolean;
3234
3797
  setEnabled(value: boolean): void;
3235
3798
  isDisposed(): boolean;
3236
3799
  dispose(doNotRecurse?: boolean): void;
@@ -3308,6 +3871,10 @@ export declare class NodeParticleSystemSet {
3308
3871
  dispose(): void;
3309
3872
  }
3310
3873
 
3874
+ export declare class NodeRenderGraphMeshBlendingPostProcessBlock {
3875
+ constructor(..._args: unknown[]);
3876
+ }
3877
+
3311
3878
  /**
3312
3879
  * Babylon.js's `NullEngine` — a headless engine with no GPU device, used to run
3313
3880
  * scene logic (animations, observables, physics stepping, frame timing) without
@@ -3388,6 +3955,8 @@ export declare class OutlineRenderer {
3388
3955
  constructor();
3389
3956
  }
3390
3957
 
3958
+ export declare function PackMeshBlendingTag(groupId: number, radiusClass: MeshBlendingRadiusClass): number;
3959
+
3391
3960
  export declare class ParticleHelper {
3392
3961
  constructor();
3393
3962
  }
@@ -4154,6 +4723,15 @@ export declare class PostProcess {
4154
4723
  constructor();
4155
4724
  }
4156
4725
 
4726
+ /**
4727
+ * Babylon.js-compatible power easing class.
4728
+ */
4729
+ export declare class PowerEase extends EasingFunction {
4730
+ power: number;
4731
+ constructor(power?: number);
4732
+ easeInCore(gradient: number): number;
4733
+ }
4734
+
4157
4735
  /** Babylon.js `PrecisionDate` — high-resolution timestamp source. */
4158
4736
  export declare const PrecisionDate: {
4159
4737
  readonly Now: number;
@@ -4375,6 +4953,14 @@ export declare function RegisterAbstractEngineTextureLoaders(): void;
4375
4953
  */
4376
4954
  export declare function registerBuiltInLoaders(): void;
4377
4955
 
4956
+ export declare function RegisterComputeShader(): void;
4957
+
4958
+ /** Pure-build registration shim; compat wires the Lite array upload directly. */
4959
+ export declare function RegisterEnginesExtensionsEngineTexture2DArrayImageSource(): void;
4960
+
4961
+ /** WebGPU pure-build registration shim; Babylon Lite is WebGPU-only. */
4962
+ export declare function RegisterEnginesWebGPUExtensionsEngineTexture2DArrayImageSource(): void;
4963
+
4378
4964
  export declare function RegisterFluidRenderer(): void;
4379
4965
 
4380
4966
  export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
@@ -4382,6 +4968,8 @@ export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]):
4382
4968
  /** Babylon.js pure-module registration hook. */
4383
4969
  export declare function RegisterImageProcessingConfiguration(): void;
4384
4970
 
4971
+ export declare function RegisterMeshBlendingPostProcessBlock(): never;
4972
+
4385
4973
  export declare function RegisterOpenpbrMaterial(): void;
4386
4974
 
4387
4975
  export declare function RegisterUSDFileLoader(): never;
@@ -4463,8 +5051,8 @@ export declare class Scene extends AbstractScene {
4463
5051
  /** Babylon.js fog-mode c
4464
5052
  * Babylon.js `scene.animationGroups` / `scene.animatables`. Loaded glTF /
4465
5053
  * `.babylon` animation clips live on the Lite scene; `animationGroups` returns
4466
5054
  * BJS-shaped `AnimationGroup`s over them (so scenes can `goToFrame`/`pause`/`stop`
4467
- * to freeze a model at a deterministic frame). `animatables` surfaces the running
4468
- * CPU `Animatable`s started via `beginDirectAnimation`.
5055
+ * to freeze a model at a deterministic frame). `animatables` surfaces the
5056
+ * native-backed and fallback `Animatable`s started through the scene.
4469
5057
  */
4470
5058
  get animationGroups(): AnimationGroup[];
4471
5059
  /** Babylon.js `scene.getAnimationGroupByName(name)` — first loaded animation group with a matching name, else `null`. */
@@ -4486,8 +5074,9 @@ export declare class Scene extends AbstractScene {
4486
5074
  /** Babylon.js fog-mode c
4487
5075
  private readonly _pendingTextures;
4488
5076
  private readonly _pendingGroundBakes;
4489
5077
  private readonly _pendingMorphBuilds;
4490
- private readonly _runningAnimatables;
4491
- private readonly _animationGroupCache;
4492
5078
  private _ambientColor;
5079
+ private _materialPluginsRequested;
5080
+ private readonly _pendingMaterialPluginReconciliations;
5081
+ private readonly _runningAnimatables;
4493
5082
  private readonly _animationGroupCache;
4494
5083
  private _ambientColor;
4495
5084
  private _environmentIntensity;
4496
5085
  private _imageProcessingConfiguration;
4497
5086
  /** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
4498
5087
  readonly uniqueId: number;
@@ -4649,8 +5238,9 @@ export declare class Scene extends AbstractScene {
4649
5238
  /** Babylon.js fog-mode c
4650
5239
  disablePhysicsEngine(): void;
4651
5240
  /**
4652
5241
  * Babylon.js `scene.beginDirectAnimation(target, animations, from, to, loop, speedRatio?)`.
4653
- * Drives the given `Animation`s on the CPU each frame, writing onto the target's
4654
- * (dotted) property path. Returns an `Animatable` with `goToFrame`/`pause`/`stop`.
5242
+ * Delegates supported tracks to Babylon Lite property animation and retains
5243
+ * explicit compat evaluation only for unsupported tracks. Returns one facade
5244
+ * coordinating both subsets.
4655
5245
  */
4656
5246
  beginDirectAnimation(target: unknown, animations: Animation_2[], from: number, to: number, loop?: boolean, speedRatio?: number): Animatable_2;
4657
5247
  /**
4658
5248
  * Babylon.js `scene.beginAnimation(target, from, to, loop, speedRatio?)`. Runs
@@ -4763,6 +5353,15 @@ export declare class ShadowGenerator {
4763
5353
  private _removeCaster;
4764
5354
  private _scheduleCasterSync;
4765
5355
  private _flushCasterSync;
5356
+ /**
5357
+ * The Lite meshes handed to the native shadow task: every requested caster that carries GPU geometry.
5358
+ * The compat loader wraps a model's complete hierarchy as `Mesh`es, so `addShadowCaster(root, true)`
5359
+ * legitimately collects transform-only roots and intermediate nodes into `renderList`, exactly as
5360
+ * Babylon.js does. Those nodes must not reach the native state: the render task cannot build a
5361
+ * renderable for a mesh without `_gpu` (it would throw inside the frame, every frame), and directional
5362
+ * fitting would substitute default bounds for it, distorting the shadow volume.
5363
+ */
5364
+ private _liteCasterMeshes;
4766
5365
  /** Babylon.js `getShadowMap()` — returns a minimal render-list holder for parity. */
4767
5366
  getShadowMap(): {
4768
5367
  renderList: AbstractMesh[];
@@ -5010,7 +5609,9 @@ export declare class SpriteManager {
5010
5609
  disableDepthWrite: boolean;
5011
5610
  /** Babylon.js `manager.blendMode` (`Constants.ALPHA_*`). Mapped to a Lite billboard blend at build. */
5012
5611
  blendMode: number;
5013
5612
  private _atlas?;
5014
- constructor(name: string, url: string, capacity: number, cellSize: CellSize, scene: Scene, _epsilon?: number, samplingMode?: number);
5613
+ constructor(name: string, url: string, capacity: number, cellSize: CellSize, scene: Scene, _epsilon?: number, samplingMode?: number);
5614
+ /** Babylon.js `SpriteManager.isReady()` — an empty manager is ready without renderer preparation. */
5615
+ isReady(): boolean;
5015
5616
 
5016
5617
  export declare class SpriteMap {
5017
5618
  constructor();
@@ -5056,7 +5657,9 @@ export declare class SpriteRenderer {
5056
5657
  private _built;
5057
5658
  private readonly _indices;
5058
5659
  private _sprites;
5059
- constructor(engine: WebGPUEngine, capacity?: number, _epsilon?: number, _scene?: unknown);
5060
5660
  /**
5661
+ constructor(engine: WebGPUEngine, capacity?: number, _epsilon?: number, _scene?: unknown);
5662
+ /** Babylon.js `SpriteRenderer.isReady()` — the next render can build once its atlas is loaded. */
5663
+ isReady(): boolean;
5061
5664
  /**
5062
5665
  * Babylon.js `renderer.render(sprites, deltaTime, viewMatrix, projectionMatrix)`.
5063
5666
  * The matrices are owned by Babylon Lite's pixel-space sprite pass, so they are
5064
5667
  * accepted for API parity but not consumed. First call builds + registers the
@@ -5068,7 +5671,17 @@ export declare class SSAO2RenderingPipeline {
5068
5671
  constructor();
5069
5672
  }
5070
5673
 
5071
- export declare class StandardMaterial extends PushMaterial {
5072
5674
  constructor(name: string, scene?: Scene);
5675
+ export declare class StandardMaterial extends PushMaterial {
5073
5676
  /** Diffuse colour as the app set it. Kept apart from `_lite.diffuseColor`, which is forced to white
5677
+ * while the material is unlit (see `_syncDiffuse`). */
5678
+ private _diffuse;
5679
+ constructor(name: string, scene?: Scene);
5680
+ /**
5681
+ * Babylon.js shades an unlit StandardMaterial as `emissive + ambient`: the diffuse colour only scales
5682
+ * the accumulated light, and there is none. Lite's unlit path is `emissive × diffuse`, so the usual
5683
+ * "unlit colour" setup (black diffuse, colour in emissive) rendered black. Hand Lite a neutral white
5684
+ * diffuse while lighting is disabled and the app's own colour otherwise.
5685
+ */
5686
+ private _syncDiffuse;
5074
5687
  getClassName(): string;
5075
5688
  get diffuseColor(): Color3;
5076
5689
  set diffuseColor(value: Color3);
@@ -5178,6 +5791,18 @@ export declare class STLFileLoader {
5178
5791
  constructor();
5179
5792
  }
5180
5793
 
5794
+ /** Babylon.js-shaped wrapper over Lite's public opaque storage allocation. */
5795
+ export declare class StorageBuffer {
5796
+ private readonly _engine;
5181
5797
  private readonly _copyReadable;
5798
+ private readonly _copyWritable;
5799
+ constructor(_engine: WebGPUEngine, size: number, creationFlags?: number, label?: string);
5182
5800
  getBuffer(): StorageBuffer_2 | null;
5801
+ clear(byteOffset?: number, byteLength?: number): void;
5802
+ update(data: DataArray, byteOffset?: number, byteLength?: number): void;
5803
+ read(offset?: number, size?: number, buffer?: ArrayBufferView, noDelay?: boolean): Promise<ArrayBufferView>;
5804
+ dispose(): void;
5183
5805
  private _requireBuffer;
5806
+ private _assertCopyWritable;
5807
+ }
5808
+
5184
5809
  /** Babylon.js `StreamingSound` — a media-element-backed sound. */
5185
5810
  export declare class StreamingSound extends AbstractSound {
5186
5811
  private readonly _autoplay;
5187
5812
  private _loop;
@@ -5259,7 +5884,7 @@ export declare class TargetCamera extends Camera {
5259
5884
  constructor(name: string,
5260
5885
 
5261
5886
  declare type TaskState = "init" | "running" | "done" | "error";
5262
5887
 
5263
- export declare function TemperatureTintToXyz(_temperatureKelvin: number, _tint: number): Vector3;
5888
+ export declare function TemperatureTintToXyz(temperatureKelvin: number, tint: number): Vector3;
5264
5889
 
5265
5890
  export declare class Texture extends BaseTexture {
5266
5891
  private readonly _ready;
@@ -5325,6 +5950,10 @@ export declare class ThinFSR1UpscalePostProcess {
5325
5950
  constructor();
5326
5951
  }
5327
5952
 
5953
+ export declare class ThinMeshBlendingPostProcess {
5954
+ constructor(..._args: unknown[]);
5955
+ }
5956
+
5328
5957
  /**
5329
5958
  * Babylon.js `ThinSprite` — a lightweight pixel-space sprite drawn by a
5330
5959
  * {@link SpriteRenderer}. Position is in screen pixels (origin bottom-left, +Y
@@ -5421,6 +6050,83 @@ export declare class TransformNode extends Node_2 {
5421
6050
  physicsBody: PhysicsBody
5422
6051
 
5423
6052
  export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
5424
6053
 
6054
+ /** Minimum Babylon.js UniformBuffer surface needed to author compute bindings. */
6055
+ export declare class UniformBuffer {
6056
+ private readonly _engine;
6057
+ private readonly _data;
6058
+ private readonly _dynamic;
6059
+ private readonly _uniformLocations;
6060
+ private readonly _uniformSizes;
6061
+ private readonly _uniformArraySizes;
6062
+ private readonly _uniformNames;
6063
+ private _uniformLocationPointer;
6064
+ private _bufferData;
6065
+ private _buffer;
6066
+ private _needSync;
6067
+ private _name;
6068
+ constructor(_engine: AbstractEngine, data?: number[], dynamic?: boolean, name?: string, forceNoUniformBuffer?: boolean, _trackUBOsInFrame?: boolean);
6069
+ readonly updateMatrix3x3: (name: string, matrix: Float32Array) => void;
6070
+ readonly updateMatrix2x2: (name: string, matrix: Float32Array) => void;
6071
+ readonly updateFloat: (name: string, x: number, _suffix?: string) => void;
6072
+ readonly updateFloat2: (name: string, x: number, y: number, _suffix?: string) => void;
6073
+ readonly updateFloat3: (name: string, x: number, y: number, z: number, _suffix?: string) => void;
6074
+ readonly updateFloat4: (name: string, x: number, y: number, z: number, w: number, _suffix?: string) => void;
6075
+ readonly updateFloatArray: (name: string, array: Float32Array, _suffix?: string) => void;
6076
+ readonly updateArray: (name: string, array: number[]) => void;
6077
+ readonly updateIntArray: (name: string, array: Int32Array) => void;
6078
+ readonly updateUIntArray: (name: string, array: Uint32Array) => void;
6079
+ readonly updateMatrix: (name: string, matrix: MatrixLike) => void;
6080
+ readonly updateMatrices: (name: string, matrices: Float32Array) => void;
6081
+ readonly updateVector3: (name: string, vector: Vector3Like) => void;
6082
+ readonly updateVector4: (name: string, vector: Vector4Like) => void;
6083
+ readonly updateColor3: (name: string, color: Color3Like, suffix?: string) => void;
6084
+ readonly updateColor4: (name: string, color: Color3Like, alpha: number, suffix?: string) => void;
6085
+ readonly updateDirectColor4: (name: string, color: Color4Like, suffix?: string) => void;
6086
+ readonly updateInt: (name: string, x: number, _suffix?: string) => void;
6087
+ readonly updateInt2: (name: string, x: number, y: number, _suffix?: string) => void;
6088
+ readonly updateInt3: (name: string, x: number, y: number, z: number, _suffix?: string) => void;
6089
+ readonly updateInt4: (name: string, x: number, y: number, z: number, w: number, _suffix?: string) => void;
6090
+ readonly updateUInt: (name: string, x: number, _suffix?: string) => void;
6091
+ readonly updateUInt2: (name: string, x: number, y: number, _suffix?: string) => void;
6092
+ readonly updateUInt3: (name: string, x: number, y: number, z: number, _suffix?: string) => void;
6093
+ readonly updateUInt4: (name: string, x: number, y: number, z: number, w: number, _suffix?: string) => void;
6094
+ get useUbo(): boolean;
6095
+ get isSync(): boolean;
6096
+ isDynamic(): boolean;
6097
+ getData(): Float32Array;
6098
+ getBuffer(): UniformBuffer_2 | null;
6099
+ getUniformNames(): string[];
6100
+ addUniform(name: string, sizeOrData: number | number[], arraySize?: number): void;
6101
+ addMatrix(name: string, matrix: MatrixLike): void;
6102
+ addFloat2(name: string, x: number, y: number): void;
6103
+ addFloat3(name: string, x: number, y: number, z: number): void;
6104
+ addColor3(name: string, color: Color3Like): void;
6105
+ addColor4(name: string, color: Color3Like, alpha: number): void;
6106
+ addVector3(name: string, vector: Vector3Like): void;
6107
+ addMatrix3x3(name: string): void;
6108
+ addMatrix2x2(name: string): void;
6109
+ create(): void;
5425
6110
  get name(): string;
6111
+ set name(value: string);
6112
+ get currentEffect(): unknown | null;
6113
+ update(): void;
6114
+ updateUniform(uniformName: string, data: FloatArray, size: number): void;
6115
+ updateUniformArray(uniformName: string, data: FloatArray, size: number): void;
6116
+ setTexture(_name: string, _texture: BaseTexture | null): never;
6117
+ setTextureArray(_name: string, _textures: BaseTexture[]): never;
6118
+ bindTexture(_name: string, _texture: unknown | null): never;
6119
+ updateUniformDirectly(uniformName: string, data: FloatArray): void;
6120
+ bindToEffect(_effect: unknown, _name: string): never;
6121
+ bindUniformBuffer(): never;
6122
+ unbindEffect(): void;
6123
+ setDataBuffer(dataBuffer: UniformBuffer_2): boolean;
6124
+ has(name: string): boolean;
6125
+ dispose(): void;
6126
+ private _align;
6127
+ private _updateIntegerUniform;
6128
+ private _updateIntegerUniformArray;
6129
+ private _setInteger;
6130
+ }
6131
+
5426
6132
  /** Babylon.js `UninstallHtmlInCanvasPolyfill` — the HTML-in-canvas polyfill is unsupported by the compat layer. */
5427
6133
  export declare function UninstallHtmlInCanvasPolyfill(): never;
5428
6134
 
@@ -5429,6 +6135,8 @@ export declare class UniversalCamera extends FreeCamera {
5429
6135
  getClassName(): string;
5430
6136
  }
5431
6137
 
6138
+ export declare function UnpackMeshBlendingTag(tag: number): IMeshBlendingTag;
6139
+
5432
6140
  /** Throw a {@link LiteCompatError} for an unsupported API. */
5433
6141
  export declare function unsupported(api: string, detail?: string): never;
5434
6142
 
@@ -5502,6 +6210,10 @@ export declare class UtilityLayerRenderer {
5502
6210
  private _registered;
5503
6211
  constructor(scene: Scene);
5504
6212
  dispose(): void;
5505
6213
  }
5506
6214
 
6215
+ export declare function ValidateFlowGraph(_flowGraph: unknown): IFlowGraphValidationResult;
6216
+
6217
+ export declare function ValidateFlowGraphWithBlockList(_flowGraph: unknown, _allKnownBlocks: unknown[]): IFlowGraphValidationResult;
6218
+
5507
6219
  /** Compares `target[propertyPath]` against a value with an operator. */
5508
6220
  export declare class ValueCondition extends Condition {
5509
6221
  private readonly _target;
@@ -5623,6 +6335,12 @@ export declare class Vector3 {
5623
6335
  static TransformNormalToRef<T extends Vector3>(vector: Vector3, transformation: Matrix, result: T): T;
5624
6336
  }
5625
6337
 
6338
+ declare interface Vector3Like {
6339
+ readonly x: number;
6340
+ readonly y: number;
6341
+ readonly z: number;
6342
+ }
6343
+
5626
6344
  export declare class Vector4 {
5627
6345
  x: number;
5628
6346
  y: number;
@@ -5640,6 +6358,10 @@ export declare class Vector4 {
5640
6358
  static Zero(): Vector4;
5641
6359
  }
5642
6360
 
6361
+ declare interface Vector4Like extends Vector3Like {
6362
+ readonly w: number;
6363
+ }
6364
+
5643
6365
  /**
5644
6366
  * Babylon.js `VertexBuffer` — the per-attribute geometry buffer. Only the `kind`
5645
6367
  * string constants are surfaced (used with `mesh.getVerticesData` /