@babylonjs/lite-compat 1.37.0-preview → 1.37.2-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
@@ -5,7 +5,7 @@ import { AudioGraphHost } from '@babylonjs/lite';
5
5
  import { ClearCoatProps } from '@babylonjs/lite';
6
6
  import { ComputeShader as ComputeShader_2 } from '@babylonjs/lite';
7
7
  import { EngineContext } from '@babylonjs/lite';
8
- import { EngineOptions } from '@babylonjs/lite';
8
+ import { EngineOptions as EngineOptions_2 } from '@babylonjs/lite';
9
9
  import { IridescenceProps } from '@babylonjs/lite';
10
10
  import { LineMaterial } from '@babylonjs/lite';
11
11
  import { MaxTintMagnitude } from '@babylonjs/lite';
@@ -125,6 +125,7 @@ export declare abstract class AbstractEngine {
125
125
  protected readonly _scenes: Scene[];
126
126
  protected readonly _loopCallbacks: Array<() => void>;
127
127
  protected _initialized: boolean;
128
+ private _disposed;
128
129
  private _startupComplete;
129
130
  private _startPromise;
130
131
  /**
131
132
  * Babylon.js `engine.useReverseDepthBuffer`. Babylon Lite owns its depth
@@ -243,12 +244,19 @@ export declare abstract class AbstractEngine {
243
244
  private _ensureInitialized;
244
245
  }
245
246
 
247
+ /** Babylon.js `AbstractEngineOptions` subset accepted by the compat engine. */
248
+ export declare interface AbstractEngineOptions extends EngineOptions_2 {
249
+ antialias?: boolean;
250
+ adaptToDeviceRatio?: boolean;
251
+ useLargeWorldRendering?: boolean;
252
+ useReverseDepthBuffer?: boolean;
253
+ }
254
+
246
255
  /**
247
256
  * Babylon.js `AbstractMesh` — a renderable transform node with a material,
248
257
  * visibility, and shadow-receipt. Concrete meshes derive from this.
249
258
  */
250
- export declare class AbstractMesh extends TransformNode {
251
259
  private _material;
252
- private _meshBlendingTag;
260
+ export declare class AbstractMesh extends TransformNode {
253
261
  private _material;
254
262
  private _meshBlendingTag;
255
263
  protected _visible: boolean;
256
264
  constructor(name: string, lite: Mesh_2, scene?: Scene);
257
265
  getClassName(): string;
258
266
  get material(): CompatMaterial | null;
@@ -811,6 +819,7 @@ export declare class ArcRotateCamera extends Camera {
811
819
  constructor(name: stri
812
820
  set beta(value: number);
813
821
  get radius(): number;
814
822
  set radius(value: number);
823
+ /** Live, as in Babylon.js: `camera.target.x = …` and in-place vector math move the target. */
815
824
  get target(): Vector3;
816
825
  set target(value: Vector3);
817
826
  /** Babylon.js `setTarget` — point the arc-rotate camera at a world-space target. */
@@ -830,6 +839,21 @@ export declare class ArcRotateCamera extends Camera {
830
839
  constructor(name: stri
831
840
  set panningSensibility(value: number);
832
841
  attachControl(canvas: HTMLCanvasElement, noPreventDefault?: boolean): void;
833
842
 
843
+ /** Babylon.js `AreaLight` hierarchy node shared by rectangular area lights. */
844
+ export declare abstract class AreaLight extends Light {
845
+ protected constructor(name: string, scene?: Scene, dontAddToScene?: boolean);
846
+ abstract get position(): Vector3;
847
+ abstract set position(value: Vector3);
848
+ }
849
+
850
+ /** Babylon.js `AreaLightTextureTools` forwarding to Lite's native emission-image processor. */
851
+ export declare class AreaLightTextureTools {
834
852
  constructor(engine: AbstractEngine);
853
+ get shaderLanguage(): ShaderLanguage;
854
+ isReady(): boolean;
855
+ processAsync(source: BaseTexture): Promise<BaseTexture | null>;
856
+ dispose(): void;
857
+ }
858
+
835
859
  export declare class AssetContainer {
836
860
  private readonly _dispose;
837
861
  private _sceneDisposeObserver;
838
862
  private _disposed;
839
863
  constructor(lite: AssetContainer_2, dispose?: () => void, ownedMeshes?: readonly Mesh_2[]);
@@ -1708,6 +1732,11 @@ export declare class CubeTexture extends BaseTexture {
1708
1732
  gammaSpace: boolean;
1709
1733
  level: number;
1710
1734
  /** Fires when the cube map is "ready" (resolved on a microtask in this compat layer). */
1711
1735
  readonly onLoadObservable: Observable<CubeTexture>;
1736
+ /**
1737
+ * Babylon.js `CubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
1738
+ * texture as its `environmentTexture` turns its image-based lighting with it (see `Scene.environmentTexture`).
1739
+ */
1740
+ rotationY: number;
1712
1741
  private _ready;
1713
1742
  private readonly _readyPromise;
1714
1743
  constructor(url: string, _scene?: unknown, _extensions?: unknown, _noMipmap?: boolean, _files?: unknown, onLoad?: (() => void) | null, _onError?: unknown, _format?: unknown, _prefiltered?: boolean);
@@ -1785,17 +1814,57 @@ export declare class DefaultRenderingPipeline {
1785
1814
  constructor();
1786
1815
  }
1787
1816
 
1817
+ export declare function defaultValueParseFunction(_key: string, _serializationObject: any, _assetsContainer: AssetContainer, _scene: Scene): any;
1818
+
1788
1819
  export declare const DepthOfFieldEffect: new () => never;
1789
1820
 
1790
1821
  export declare class DepthRenderer {
1791
1822
  constructor();
1792
1823
  }
1793
1824
 
1825
+ export declare type DeviceInput<T extends DeviceType> = T extends DeviceType.Keyboard | DeviceType.Generic ? number : T extends DeviceType.Mouse | DeviceType.Touch ? Exclude<PointerInput, PointerInput.Move | PointerInput.MouseWheelX | PointerInput.MouseWheelY | PointerInput.MouseWheelZ> : T extends DeviceType.DualShock ? DualShockInput : T extends DeviceType.Xbox ? XboxInput : T extends DeviceType.Switch ? SwitchInput : T extends DeviceType.DualSense ? DualSenseInput : never;
1826
+
1827
+ export declare const enum DeviceInputEventType {
1828
+ PointerMove = 0,
1829
+ PointerDown = 1,
1830
+ PointerUp = 2
1831
+ }
1832
+
1794
1833
  /** Babylon.js `DeviceOrientationCamera` — device-orientation input is not available in Babylon Lite. */
1795
1834
  export declare class DeviceOrientationCamera {
1796
1835
  constructor();
1797
1836
  }
1798
1837
 
1838
+ export declare class DeviceSource<T extends DeviceType> {
1839
+ readonly deviceType: T;
1840
+ readonly deviceSlot: number;
1841
+ readonly onInputChangedObservable: Observable<DeviceSourceEvent<T>>;
1842
+ constructor(_deviceInputSystem: unknown, deviceType: T, deviceSlot?: number);
1843
+ getInput(_inputIndex: DeviceInput<T>): number;
1844
+ }
1845
+
1846
+ export declare type DeviceSourceEvent<T extends DeviceType> = T extends DeviceType.Keyboard ? IKeyboardEvent : T extends DeviceType.Mouse ? IWheelEvent | IPointerEvent : T extends DeviceType.Touch ? IPointerEvent : never;
1847
+
1848
+ export declare class DeviceSourceManager {
1849
+ readonly onDeviceConnectedObservable: Observable<DeviceSource<DeviceType>>;
1850
+ readonly onDeviceDisconnectedObservable: Observable<DeviceSource<DeviceType>>;
1851
+ constructor(_engine: AbstractEngine);
1852
+ getDeviceSource<T extends DeviceType>(_deviceType: T, _deviceSlot?: number): DeviceSource<T> | null;
1853
+ getDeviceSources<T extends DeviceType>(_deviceType: T): ReadonlyArray<DeviceSource<T>>;
1854
+ dispose(): void;
1855
+ }
1856
+
1857
+ export declare enum DeviceType {
1858
+ Generic = 0,
1859
+ Keyboard = 1,
1860
+ Mouse = 2,
1861
+ Touch = 3,
1862
+ DualShock = 4,
1863
+ Xbox = 5,
1864
+ Switch = 6,
1865
+ DualSense = 7
1866
+ }
1867
+
1799
1868
  export declare class DirectionalLight extends Light {
1800
1869
  constructor(name: string, direction: Vector3, scene?: Scene);
1801
1870
  getClassName(): string;
1802
1871
  get direction(): Vector3;
@@ -1849,6 +1918,56 @@ export { DragEvent_2 as DragEvent }
1849
1918
  /** Babylon.js drag start/end payload. */
1850
1919
  export declare type DragStartEndEvent = Pick<DragEvent_2, "dragPlanePoint" | "pointerId" | "pointerInfo">;
1851
1920
 
1921
+ export declare const enum DualSenseInput {
1922
+ Cross = 0,
1923
+ Circle = 1,
1924
+ Square = 2,
1925
+ Triangle = 3,
1926
+ L1 = 4,
1927
+ R1 = 5,
1928
+ L2 = 6,
1929
+ R2 = 7,
1930
+ Create = 8,
1931
+ Options = 9,
1932
+ L3 = 10,
1933
+ R3 = 11,
1934
+ DPadUp = 12,
1935
+ DPadDown = 13,
1936
+ DPadLeft = 14,
1937
+ DPadRight = 15,
1938
+ Home = 16,
1939
+ TouchPad = 17,
1940
+ LStickXAxis = 18,
1941
+ LStickYAxis = 19,
1942
+ RStickXAxis = 20,
1943
+ RStickYAxis = 21
1944
+ }
1945
+
1946
+ export declare const enum DualShockInput {
1947
+ Cross = 0,
1948
+ Circle = 1,
1949
+ Square = 2,
1950
+ Triangle = 3,
1951
+ L1 = 4,
1952
+ R1 = 5,
1953
+ L2 = 6,
1954
+ R2 = 7,
1955
+ Share = 8,
1956
+ Options = 9,
1957
+ L3 = 10,
1958
+ R3 = 11,
1959
+ DPadUp = 12,
1960
+ DPadDown = 13,
1961
+ DPadLeft = 14,
1962
+ DPadRight = 15,
1963
+ Home = 16,
1964
+ TouchPad = 17,
1965
+ LStickXAxis = 18,
1966
+ LStickYAxis = 19,
1967
+ RStickXAxis = 20,
1968
+ RStickYAxis = 21
1969
+ }
1970
+
1852
1971
  /**
1853
1972
  * Babylon.js `DynamicTexture` — a canvas-backed texture. Draw into
1854
1973
  * `getContext()`, then call `update()` to upload the canvas pixels to the GPU.
@@ -1976,11 +2095,22 @@ export declare class ElasticEase extends EasingFunction {
1976
2095
  * Lite WebGPU context; this class exists to mirror Babylon.js's name + hierarchy.
1977
2096
  */
1978
2097
  export declare class Engine extends ThinEngine {
2098
+ constructor(canvas: RenderCanvas, antialiasOrOptions?: boolean | EngineOptions, options?: EngineOptions, adaptToDeviceRatio?: boolean);
2099
+ }
2100
+
2101
+ /** Babylon.js `EngineOptions` subset accepted by the compat engine. */
2102
+ export declare interface EngineOptions extends AbstractEngineOptions {
1979
2103
  }
1980
2104
 
1981
2105
  /** Babylon.js-compatible scalar helpers and a small set of math constants. */
1982
2106
  export declare const Epsilon = 0.001;
1983
2107
 
2108
+ export declare class EventConstants {
2109
+ static DOM_DELTA_PIXEL: number;
2110
+ static DOM_DELTA_LINE: number;
2111
+ static DOM_DELTA_PAGE: number;
2112
+ }
2113
+
1984
2114
  /** Runs a user callback when triggered. */
1985
2115
  export declare class ExecuteCodeAction extends Action {
1986
2116
  private readonly _func;
@@ -2143,6 +2273,15 @@ export declare type FBXNormalMapCoordinateSystem = "y-up" | "y-down";
2143
2273
 
2144
2274
  declare type FloatArray = number[] | Float32Array;
2145
2275
 
2276
+ export declare interface FlowGraphContext {
2277
+ _getGlobalContextVariable<T>(name: string, defaultValue: T): T;
2278
+ _setGlobalContextVariable<T>(name: string, value: T): void;
2279
+ }
2280
+
2281
+ export declare interface FlowGraphPlayAnimationBlock {
2282
+ getClassName(): string;
2283
+ }
2284
+
2146
2285
  export declare enum FlowGraphValidationSeverity {
2147
2286
  Error = 0,
2148
2287
  Warning = 1
@@ -2425,6 +2564,10 @@ export declare class GaussianSplattingStream extends GaussianSplattingMesh {
2425
2564
  get debugLodSource(): never;
2426
2565
  set debugLodSource(_value: GaussianSplattingStreamDebugLodSource);
2427
2566
  evaluateOptimalLods(_camera?: unknown): never;
2567
+ getSourceRange(_fileId: number): Readonly<IGaussianSplattingStreamSourceRange> | null;
2568
+ isSplitPage(_fileId: number): boolean;
2569
+ cancelRangeLoads(_files: readonly number[], _keepSources?: readonly number[]): void;
2570
+ get rangeResidencyStats(): Readonly<IGaussianSplattingStreamRangeResidencyStats>;
2428
2571
  }
2429
2572
 
2430
2573
  export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
@@ -2592,6 +2735,8 @@ export declare namespace GLTF2 {
2592
2735
  IKHRInteractivityTypeMapping,
2593
2736
  gltfTypeToBabylonType,
2594
2737
  IFlowGraphEventReferenceBlockConfiguration,
2738
+ IFlowGraphDelayReferenceBlockConfiguration,
2739
+ FlowGraphDelayReferenceBlock,
2595
2740
  FlowGraphEventReferenceBlock,
2596
2741
  IFlowGraphGLTFDataProviderBlockConfiguration,
2597
2742
  FlowGraphGLTFDataProvider,
@@ -2880,6 +3025,11 @@ export declare class HDRCubeTexture extends BaseTexture {
2880
3025
  gammaSpace: boolean;
2881
3026
  level: number;
2882
3027
  /** Fires when the HDR environment is "ready" (resolved on a microtask). */
2883
3028
  readonly onLoadObservable: Observable<HDRCubeTexture>;
3029
+ /**
3030
+ * Babylon.js `HDRCubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
3031
+ * texture as its `environmentTexture` turns its image-based lighting with it (see `Scene.environmentTexture`).
3032
+ */
3033
+ rotationY: number;
2884
3034
  private _ready;
2885
3035
  private readonly _readyPromise;
2886
3036
  constructor(url: string, _sceneOrEngine?: unknown, size?: number, _noMipmap?: boolean, _generateHarmonics?: boolean, _gammaSpace?: boolean, _prefilterOnLoad?: boolean, onLoad?: (() => void) | null);
@@ -3091,6 +3241,14 @@ export declare interface IEasingFunction {
3091
3241
  ease(gradient: number): number;
3092
3242
  }
3093
3243
 
3244
+ export declare interface IFlowGraphAnimationObserverSet {
3245
+ block: FlowGraphPlayAnimationBlock;
3246
+ groupEnd: Observer<AnimationGroup>;
3247
+ animationEnd: Observer<any>;
3248
+ animationLoop: Observer<any>;
3249
+ groupLoop: Observer<AnimationGroup>;
3250
+ }
3251
+
3094
3252
  export declare interface IFlowGraphValidationIssue {
3095
3253
  severity: FlowGraphValidationSeverity;
3096
3254
  message: string;
@@ -3186,6 +3344,28 @@ export declare interface IGaussianSplattingStreamOptions {
3186
3344
  hostCompound?: GaussianSplattingMesh;
3187
3345
  decodeSh?: boolean;
3188
3346
  needsRotationScale?: boolean;
3347
+ rangeResidency?: boolean;
3348
+ rangePack?: (source: Readonly<IGaussianSplattingStreamSourceRange>, sourceData: SOGRootData) => IGaussianSplattingStreamRangePack | null;
3349
+ }
3350
+
3351
+ export declare interface IGaussianSplattingStreamRangePack {
3352
+ sogData: SOGRootData;
3353
+ subRootUrl: string;
3354
+ }
3355
+
3356
+ export declare interface IGaussianSplattingStreamRangeResidencyStats {
3357
+ enabled: boolean;
3358
+ pages: number;
3359
+ sourcePackLoads: number;
3360
+ sourcePackReuses: number;
3361
+ splitPackLoads: number;
3362
+ cachedSourceSplats: number;
3363
+ }
3364
+
3365
+ export declare interface IGaussianSplattingStreamSourceRange {
3366
+ file: number;
3367
+ offset: number;
3368
+ count: number;
3189
3369
  }
3190
3370
 
3191
3371
  /** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
@@ -3233,6 +3413,18 @@ export declare interface IInstallHtmlInCanvasPolyfillOptions {
3233
3413
  [key: string]: unknown;
3234
3414
  }
3235
3415
 
3416
+ export declare interface IKeyboardEvent extends IUIEvent {
3417
+ altKey: boolean;
3418
+ charCode?: number;
3419
+ code: string;
3420
+ ctrlKey: boolean;
3421
+ key: string;
3422
+ keyCode: number;
3423
+ metaKey: boolean;
3424
+ shiftKey: boolean;
3425
+ repeat?: boolean;
3426
+ }
3427
+
3236
3428
  /**
3237
3429
  * Minimal Babylon.js `ImageProcessingConfiguration` facade over Lite's image
3238
3430
  * processing state.
@@ -3288,6 +3480,33 @@ export declare interface IMeshBlendRadiusDefinition {
3288
3480
  minimumProjectedRadius: number;
3289
3481
  }
3290
3482
 
3483
+ export declare interface IMouseEvent extends IUIEvent {
3484
+ inputIndex: Exclude<PointerInput, PointerInput.Horizontal | PointerInput.Vertical>;
3485
+ altKey: boolean;
3486
+ button: number;
3487
+ buttons: number;
3488
+ clientX: number;
3489
+ clientY: number;
3490
+ ctrlKey: boolean;
3491
+ detail?: number;
3492
+ metaKey: boolean;
3493
+ movementX: number;
3494
+ movementY: number;
3495
+ mozMovementX?: number;
3496
+ mozMovementY?: number;
3497
+ msMovementX?: number;
3498
+ msMovementY?: number;
3499
+ offsetX: number;
3500
+ offsetY: number;
3501
+ pageX: number;
3502
+ pageY: number;
3503
+ shiftKey: boolean;
3504
+ webkitMovementX?: number;
3505
+ webkitMovementY?: number;
3506
+ x: number;
3507
+ y: number;
3508
+ }
3509
+
3291
3510
  /** Babylon.js `ImportMeshAsync(source, scene, options?)` — imports an asset into the scene. */
3292
3511
  export declare function ImportMeshAsync(source: string, scene: Scene, options?: ImportMeshOptions): Promise<ImportResult>;
3293
3512
 
@@ -3330,6 +3549,12 @@ export declare class InterpolatingBehavior {
3330
3549
  constructor();
3331
3550
  }
3332
3551
 
3552
+ export declare interface IPointerEvent extends IMouseEvent {
3553
+ inputIndex: Exclude<PointerInput, PointerInput.Horizontal | PointerInput.Vertical | PointerInput.MouseWheelX | PointerInput.MouseWheelY | PointerInput.MouseWheelZ>;
3554
+ pointerId: number;
3555
+ pointerType: string;
3556
+ }
3557
+
3333
3558
  /** Babylon.js raycast collision-filter options. */
3334
3559
  export declare interface IRaycastQuery {
3335
3560
  membership?: number;
@@ -3536,6 +3761,15 @@ export declare interface IThinMeshBlendingPostProcessOptions extends IMeshBlendC
3536
3761
  [key: string]: unknown;
3537
3762
  }
3538
3763
 
3764
+ export declare interface IUIEvent {
3765
+ inputIndex: number;
3766
+ currentTarget?: any;
3767
+ srcElement?: any;
3768
+ type: string;
3769
+ target: any;
3770
+ preventDefault: () => void;
3771
+ }
3772
+
3539
3773
  /** Babylon.js `IUploadImageToTexture2DArrayLayerOptions`. */
3540
3774
  export declare interface IUploadImageToTexture2DArrayLayerOptions {
3541
3775
  /** Store the source with the Y axis inverted (false by default). */
@@ -3564,6 +3798,15 @@ export declare interface IWebAudioEngineOptions extends IAudioEngineV2Options {
3564
3798
  disableIOSRingerSwitchWorkaround?: boolean;
3565
3799
  }
3566
3800
 
3801
+ export declare interface IWheelEvent extends IMouseEvent {
3802
+ inputIndex: PointerInput.MouseWheelX | PointerInput.MouseWheelY | PointerInput.MouseWheelZ;
3803
+ deltaMode: number;
3804
+ deltaX: number;
3805
+ deltaY: number;
3806
+ deltaZ: number;
3807
+ wheelDelta?: number;
3808
+ }
3809
+
3567
3810
  /**
3568
3811
  * Babylon.js `KHR_materials_variants` extension helpers. Mirrors the static
3569
3812
  * surface ported code calls (`SelectVariant` / `GetAvailableVariants` / `Reset`)
@@ -3586,7 +3829,7 @@ export declare class Layer {
3586
3829
  }
3587
3830
 
3588
3831
  /** Babylon.js `Light` — base class for all lights (derives from `Node`). */
3589
- export declare abstract class Light extends Node_2 {
3590
3832
  protected constructor(name: string, scene?: Scene);
3833
+ export declare abstract class Light extends Node_2 {
3591
3834
  protected constructor(name: string, scene?: Scene, dontAddToScene?: boolean);
3592
3835
  getClassName(): string;
3593
3836
  /**
3594
3837
  * Babylon.js `light.intensity`. While the light is disabled the Lite light
3595
3838
  * carries `0`, but the getter still returns the logical value the caller set.
@@ -3836,6 +4079,7 @@ export declare class Matrix {
3836
4079
  multiplyToRef(other: Matrix, result: Matrix): Matrix;
3837
4080
  transpose(): Matrix;
3838
4081
  determinant(): number;
4082
+ /** Babylon.js `invert`: inverts this matrix in place and returns it. */
3839
4083
  invert(): Matrix;
3840
4084
  invertToRef(result: Matrix): Matrix;
3841
4085
  getTranslation(): Vector3;
@@ -4289,6 +4533,14 @@ export declare class Observable<T> {
4289
4533
  cleanLastNotifiedState(): void;
4290
4534
  }
4291
4535
 
4536
+ export declare interface Observer<T> {
4537
+ callback: (eventData: T, eventState: unknown) => void;
4538
+ mask: number;
4539
+ scope: any;
4540
+ unregisterOnNextCall: boolean;
4541
+ remove(defer?: boolean): void;
4542
+ }
4543
+
4292
4544
  /**
4293
4545
  * Minimal Babylon.js-compatible `Observable`.
4294
4546
  *
@@ -5004,11 +5256,27 @@ export declare class PointerEventTypes {
5004
5256
  export declare class PointerInfo {
5005
5257
  type: number;
5006
5258
  event: PointerEvent | WheelEvent;
5007
- private readonly _pickInfo;
5008
- constructor(type: number, event: PointerEvent | WheelEvent, _pickInfo: PickingInfo | null);
5259
+ private _pickInfo;
5260
+ private _pick;
5261
+ constructor(type: number, event: PointerEvent | WheelEvent, _pickInfo: PickingInfo | null, _pick?: (() => PickingInfo) | null);
5262
+ /** Like Babylon.js lazy picking: without a precomputed pick, `_pick` runs on the first read only. */
5009
5263
  get pickInfo(): PickingInfo | null;
5010
5264
  }
5011
5265
 
5266
+ export declare enum PointerInput {
5267
+ Horizontal = 0,
5268
+ Vertical = 1,
5269
+ LeftClick = 2,
5270
+ MiddleClick = 3,
5271
+ RightClick = 4,
5272
+ BrowserBack = 5,
5273
+ BrowserForward = 6,
5274
+ MouseWheelX = 7,
5275
+ MouseWheelY = 8,
5276
+ MouseWheelZ = 9,
5277
+ Move = 12
5278
+ }
5279
+
5012
5280
  export declare class PointLight extends Light {
5013
5281
  constructor(name: string, position: Vector3, scene?: Scene);
5014
5282
  getClassName(): string;
5015
5283
  get range(): number;
@@ -5102,8 +5370,12 @@ export declare class PositionGizmo extends GizmoBase {
5102
5370
  private _attached;
5103
5371
  set updateGizmoRotationToMatchAttachedMesh(value: boolean);
5104
5372
  get attachedMesh(): AbstractMesh | null;
5105
5373
  set attachedMesh(value: AbstractMesh | null);
5106
- get attachedNode(): AbstractMesh | null;
5107
- set attachedNode(value: AbstractMesh | null);
5374
+ /**
5375
+ * Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
5376
+ * Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
5377
+ */
5378
+ get attachedNode(): Node_2 | null;
5379
+ set attachedNode(value: Node_2 | null);
5108
5380
  dispose(): void;
5109
5381
  }
5110
5382
 
@@ -5160,6 +5432,7 @@ export declare class Quaternion {
5160
5432
  constructor(x?: number, y?: number, z?: number, w?: number);
5161
5433
  set(x: number, y: number, z: number, w: number): this;
5162
5434
  copyFrom(source: Quaternion): this;
5435
+ /** Babylon.js `multiply`: the product `this · other` as a new quaternion. */
5163
5436
  multiply(other: Quaternion): Quaternion;
5164
5437
  length(): number;
5165
5438
  normalize(): this;
@@ -5329,9 +5602,22 @@ export declare class RecastJSPlugin {
5329
5602
  constructor();
5330
5603
  }
5331
5604
 
5332
- export declare class RectAreaLight {
5333
- constructor();
5334
- }
5605
+ /** Babylon.js `RectAreaLight` over Lite's native LTC-backed rectangular emitter. */
5606
+ export declare class RectAreaLight extends AreaLight {
5335
5607
  constructor(name: string, position: Vector3, width: number, height: number, scene?: Scene, dontAddToScene?: boolean);
5608
+ getClassName(): string;
5609
+ getTypeID(): number;
5610
+ get position(): Vector3;
5611
+ set position(value: Vector3);
5612
+ get width(): number;
5613
+ set width(value: number);
5614
+ get height(): number;
5615
+ set height(value: number);
5616
+ get diffuse(): Color3;
5617
+ set diffuse(value: Color3);
5618
+ get specular(): Color3;
5619
+ set specular(value: Color3);
5620
+ get emissionTexture(): BaseTexture | null;
5621
+ set emissionTexture(value: BaseTexture | null);
5336
5622
 
5337
5623
  export declare class ReflectionProbe {
5338
5624
  constructor();
@@ -5394,6 +5680,8 @@ export declare function RegisterSPLATFileLoader(): void;
5394
5680
 
5395
5681
  export declare function RegisterUSDFileLoader(): void;
5396
5682
 
5683
+ export declare function RemoveFlowGraphAnimationGroupObservers(_context: FlowGraphContext, _animationGroup: AnimationGroup): FlowGraphPlayAnimationBlock | undefined;
5684
+
5397
5685
  /** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
5398
5686
  export declare class RenderTargetTexture {
5399
5687
  constructor();
@@ -5461,8 +5749,12 @@ export declare class RotationGizmo extends GizmoBase {
5461
5749
  private _attached;
5462
5750
  set updateGizmoRotationToMatchAttachedMesh(value: boolean);
5463
5751
  get attachedMesh(): AbstractMesh | null;
5464
5752
  set attachedMesh(value: AbstractMesh | null);
5465
- get attachedNode(): AbstractMesh | null;
5466
- set attachedNode(value: AbstractMesh | null);
5753
+ /**
5754
+ * Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
5755
+ * Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
5756
+ */
5757
+ get attachedNode(): Node_2 | null;
5758
+ set attachedNode(value: Node_2 | null);
5467
5759
  dispose(): void;
5468
5760
  }
5469
5761
 
@@ -5491,8 +5783,12 @@ export declare class ScaleGizmo extends GizmoBase {
5491
5783
  private _attached;
5492
5784
  set updateGizmoRotationToMatchAttachedMesh(value: boolean);
5493
5785
  get attachedMesh(): AbstractMesh | null;
5494
5786
  set attachedMesh(value: AbstractMesh | null);
5495
- get attachedNode(): AbstractMesh | null;
5496
- set attachedNode(value: AbstractMesh | null);
5787
+ /**
5788
+ * Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
5789
+ * Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
5790
+ */
5791
+ get attachedNode(): Node_2 | null;
5792
+ set attachedNode(value: Node_2 | null);
5497
5793
  dispose(): void;
5498
5794
  }
5499
5795
 
@@ -5526,6 +5822,9 @@ export declare class Scene extends AbstractScene {
5526
5822
  /** Babylon.js fog-mode c
5527
5823
  private readonly _engine;
5528
5824
  private _activeCamera;
5529
5825
  cameraToUseForPointers: Camera | null;
5826
+ /** Babylon.js `scene.pointerX` / `pointerY`: the last pointer position in CSS pixels relative to the canvas. */
5827
+ pointerX: number;
5828
+ pointerY: number;
5530
5829
  private _defaultMaterial;
5531
5830
  private _fogMode;
5532
5831
  private _fogStart;
@@ -5533,6 +5832,8 @@ export declare class Scene extends AbstractScene {
5533
5832
  /** Babylon.js fog-mode c
5534
5833
  private _fogDensity;
5535
5834
  private _fogColor;
5536
5835
  private _started;
5537
5836
  private _envTexture;
5837
+ /** Environment lighting rotation last forwarded to Lite. */
5838
+ private _envRotation;
5538
5839
  private _brdfTexture;
5539
5840
  private _defaultEnvOptions;
5540
5841
  private readonly _shadowGenerators;
@@ -5622,6 +5923,13 @@ export declare class Scene extends AbstractScene {
5622
5923
  /** Babylon.js fog-mode c
5623
5924
  set clipPlane(value: Plane | null);
5624
5925
  get environmentTexture(): CubeTexture | HDRCubeTexture | null;
5625
5926
  set environmentTexture(value: CubeTexture | HDRCubeTexture | null);
5927
+ /**
5928
+ * Forward the environment texture's `rotationY` to the image-based lighting only. As in Babylon.js, a skybox keeps the
5929
+ * orientation it was created with (see {@link createDefaultSkybox}) and the `createDefaultEnvironment` background never
5930
+ * turns. Also runs every frame, so the texture needs no link back to the scenes that use it. A scene whose
5931
+ * environment is never rotated never calls Lite.
5932
+ */
5933
+ private _syncEnvironmentRotation;
5626
5934
  /**
5627
5935
  * Babylon.js `scene.environmentBRDFTexture` — the BRDF lookup used by PBR materials.
5628
5936
  * Babylon.js defaults this to an embedded Base64 LUT and lets apps swap in one of the
@@ -5885,6 +6193,28 @@ export declare class SmartArray<T> {
5885
6193
  dispose(): void;
5886
6194
  }
5887
6195
 
6196
+ declare interface SOGDataFile {
6197
+ shape: number[];
6198
+ dtype: string;
6199
+ mins?: number | number[];
6200
+ maxs?: number | number[];
6201
+ codebook?: number[];
6202
+ encoding?: string;
6203
+ quantization?: number;
6204
+ files: string[];
6205
+ bands?: number;
6206
+ }
6207
+
6208
+ declare interface SOGRootData {
6209
+ version?: number;
6210
+ means: SOGDataFile;
6211
+ scales: SOGDataFile;
6212
+ quats: SOGDataFile;
6213
+ sh0: SOGDataFile;
6214
+ shN?: SOGDataFile;
6215
+ count?: number;
6216
+ }
6217
+
5888
6218
  export declare class SolidParticleSystem {
5889
6219
  constructor();
5890
6220
  }
@@ -6205,6 +6535,8 @@ export declare class StandardMaterial extends PushMaterial {
6205
6535
  /** Diffuse col
6206
6536
  set diffuseColor(value: Color3);
6207
6537
  get specularColor(): Color3;
6208
6538
  set specularColor(value: Color3);
6539
+ get roughness(): number;
6540
+ set roughness(value: number);
6209
6541
  get emissiveColor(): Color3;
6210
6542
  set emissiveColor(value: Color3);
6211
6543
  get ambientColor(): Color3;
@@ -6372,6 +6704,31 @@ export declare class SurfaceMagnetismBehavior {
6372
6704
  constructor();
6373
6705
  }
6374
6706
 
6707
+ export declare const enum SwitchInput {
6708
+ B = 0,
6709
+ A = 1,
6710
+ Y = 2,
6711
+ X = 3,
6712
+ L = 4,
6713
+ R = 5,
6714
+ ZL = 6,
6715
+ ZR = 7,
6716
+ Minus = 8,
6717
+ Plus = 9,
6718
+ LS = 10,
6719
+ RS = 11,
6720
+ DPadUp = 12,
6721
+ DPadDown = 13,
6722
+ DPadLeft = 14,
6723
+ DPadRight = 15,
6724
+ Home = 16,
6725
+ Capture = 17,
6726
+ LStickXAxis = 18,
6727
+ LStickYAxis = 19,
6728
+ RStickXAxis = 20,
6729
+ RStickYAxis = 21
6730
+ }
6731
+
6375
6732
  declare interface Taggable {
6376
6733
  _tags?: Record<string, true>;
6377
6734
  }
@@ -6958,10 +7315,7 @@ export declare class WebGPUEngine extends AbstractEngine {
6958
7315
  }
6959
7316
 
6960
7317
  /** Babylon.js `WebGPUEngineOptions` subset accepted by the compat engine. */
6961
- export declare interface WebGPUEngineOptions extends EngineOptions {
6962
- antialias?: boolean;
6963
- adaptToDeviceRatio?: boolean;
6964
- useLargeWorldRendering?: boolean;
7318
+ export declare interface WebGPUEngineOptions extends AbstractEngineOptions {
6965
7319
  canvasToneMapping?: GPUCanvasToneMapping;
6966
7320
  canvasColorSpace?: PredefinedColorSpace;
6967
7321
  }
@@ -6975,4 +7329,28 @@ export declare class WeightedSound {
6975
7329
  constructor();
6976
7330
  }
6977
7331
 
7332
+ export declare const enum XboxInput {
7333
+ A = 0,
7334
+ B = 1,
7335
+ X = 2,
7336
+ Y = 3,
7337
+ LB = 4,
7338
+ RB = 5,
7339
+ LT = 6,
7340
+ RT = 7,
7341
+ Back = 8,
7342
+ Start = 9,
7343
+ LS = 10,
7344
+ RS = 11,
7345
+ DPadUp = 12,
7346
+ DPadDown = 13,
7347
+ DPadLeft = 14,
7348
+ DPadRight = 15,
7349
+ Home = 16,
7350
+ LStickXAxis = 17,
7351
+ LStickYAxis = 18,
7352
+ RStickXAxis = 19,
7353
+ RStickYAxis = 20
7354
+ }
7355
+
6978
7356
  export { }