@babylonjs/lite-compat 1.28.0-preview → 1.30.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
@@ -315,7 +315,6 @@ export declare class AbstractMesh extends TransformNode {
315
315
  private _material;
316
316
  * reset: the supplied matrix is independent of the node transform.
317
317
  */
318
318
  bakeTransformIntoVertices(transform: Matrix): this;
319
- dispose(): void;
320
319
  }
321
320
 
322
321
  /** Babylon.js `AbstractNamedAudioNode` — an `AbstractAudioNode` with a mutable name. */
@@ -788,7 +787,7 @@ export declare class ArcRotateCamera extends Camera {
788
787
  constructor(name: stri
789
788
  /** Right-drag panning sensitivity in pixels-per-unit (LOWER = faster pan). Babylon default 50. */
790
789
  get panningSensibility(): number;
791
790
  set panningSensibility(value: number);
792
- attachControl(canvas: HTMLCanvasElement, _noPreventDefault?: boolean): void;
791
+ attachControl(canvas: HTMLCanvasElement, noPreventDefault?: boolean): void;
793
792
 
794
793
  export declare class AssetContainer {
795
794
  constructor(lite: AssetContainer_2);
796
795
  get animationGroups(): AnimationGroup_2[];
@@ -1140,7 +1139,13 @@ export declare class BVHFileLoader {
1140
1139
  }
1141
1140
 
1142
1141
  /** Babylon.js `Camera` — base class for all cameras (derives from `Node`). */
1143
- export declare abstract class Camera extends Node_2 {
1144
1142
  private _detach;
1143
+ export declare abstract class Camera extends Node_2 {
1144
+ static readonly PERSPECTIVE_CAMERA = 0;
1145
+ static readonly ORTHOGRAPHIC_CAMERA = 1;
1145
1146
  private _detach;
1147
+ private _orthoLeft;
1148
+ private _orthoRight;
1149
+ private _orthoBottom;
1150
+ private _orthoTop;
1146
1151
  protected constructor(name: string, scene?: Scene);
1147
1152
  getClassName(): string;
1148
1153
  get fov(): number;
@@ -1149,6 +1154,18 @@ export declare abstract class Camera extends Node_2 {
1149
1154
  private _detach;
1150
1155
  set minZ(value: number);
1151
1156
  get maxZ(): number;
1152
1157
  set maxZ(value: number);
1158
+ get orthoLeft(): number | null;
1159
+ set orthoLeft(value: number | null);
1160
+ get orthoRight(): number | null;
1161
+ set orthoRight(value: number | null);
1162
+ get orthoBottom(): number | null;
1163
+ set orthoBottom(value: number | null);
1164
+ get orthoTop(): number | null;
1165
+ set orthoTop(value: number | null);
1166
+ get mode(): number;
1167
+ set mode(value: number);
1168
+ get viewport(): Viewport;
1169
+ set viewport(value: Viewport);
1153
1170
  /** World-space position of the camera. */
1154
1171
  get globalPosition(): Vector3;
1155
1172
  /** Babylon.js `camera.getViewMatrix()` — the camera's view matrix. */
@@ -1186,6 +1203,23 @@ export declare class CascadedShadowGenerator extends ShadowGenerator {
1186
1203
  getClassName(): string;
1187
1204
  }
1188
1205
 
1206
+ /** Base result shared by Babylon.js physics casting queries. */
1207
+ export declare class CastingResult {
1208
+ protected readonly _hitNormal: Vector3;
1209
+ protected readonly _hitPoint: Vector3;
1210
+ private _hasHit;
1211
+ private _triangleIndex;
1212
+ body?: PhysicsBody;
1213
+ bodyIndex?: number;
1214
+ shape?: PhysicsShape;
1215
+ get hitPoint(): Vector3;
1216
+ get hitNormal(): Vector3;
1217
+ get hasHit(): boolean;
1218
+ get triangleIndex(): number;
1219
+ setHitData(hitNormal: Vec3Like, hitPoint: Vec3Like, triangleIndex?: number): void;
1220
+ reset(): void;
1221
+ }
1222
+
1189
1223
  declare interface CellSize {
1190
1224
  width: number;
1191
1225
  height: number;
@@ -1637,6 +1671,20 @@ export declare class DistanceConstraint extends PhysicsConstraint {
1637
1671
  constructor(maxDistance: number, scene: Scene);
1638
1672
  }
1639
1673
 
1674
+ /** Babylon.js drag move payload. */
1675
+ declare type DragEvent_2 = {
1676
+ delta: Vector3;
1677
+ dragPlanePoint: Vector3;
1678
+ dragPlaneNormal: Vector3;
1679
+ dragDistance: number;
1680
+ pointerId: number;
1681
+ pointerInfo: PointerInfo | null;
1682
+ };
1683
+ export { DragEvent_2 as DragEvent }
1684
+
1685
+ /** Babylon.js drag start/end payload. */
1686
+ export declare type DragStartEndEvent = Pick<DragEvent_2, "dragPlanePoint" | "pointerId" | "pointerInfo">;
1687
+
1640
1688
  /**
1641
1689
  * Babylon.js `DynamicTexture` — a canvas-backed texture. Draw into
1642
1690
  * `getContext()`, then call `update()` to upload the canvas pixels to the GPU.
@@ -1752,6 +1800,31 @@ export declare class FBXFileLoader {
1752
1800
  constructor();
1753
1801
  }
1754
1802
 
1803
+ export declare class FluidRenderer {
1804
+ constructor(_scene: Scene);
1805
+ }
1806
+
1807
+ export declare class FluidRendererSceneComponent {
1808
+ constructor(_scene: Scene);
1809
+ }
1810
+
1811
+ export declare abstract class FluidRenderingObject {
1812
+ static UsePerParticleSizeAttribute: boolean;
1813
+ protected constructor(_scene: Scene, _shaderLanguage?: ShaderLanguage);
1814
+ }
1815
+
1816
+ export declare class FluidRenderingObjectCustomParticles extends FluidRenderingObject {
1817
+ constructor(scene: Scene, _buffers: Record<string, ArrayLike<number>>, _numParticles: number, shaderLanguage?: ShaderLanguage);
1818
+ }
1819
+
1820
+ export declare class FluidRenderingObjectParticleSystem extends FluidRenderingObject {
1821
+ constructor(scene: Scene, _particleSystem: unknown, shaderLanguage?: ShaderLanguage);
1822
+ }
1823
+
1824
+ export declare class FluidRenderingTargetRenderer {
1825
+ constructor(_scene: Scene, _camera?: Camera, _shaderLanguage?: ShaderLanguage);
1826
+ }
1827
+
1755
1828
  /** Babylon.js `FlyCamera` — 6-DOF free-flight camera. */
1756
1829
  export declare class FlyCamera extends TargetCamera {
1757
1830
  constructor(name: string, position: Vector3, scene?: Scene);
1758
1831
  get upVector(): Vector3;
@@ -1865,10 +1938,22 @@ export declare class GaussianSplattingStream {
1865
1938
  /** Babylon.js `GaussianSplattingStreamDebugLodSource` — LOD debug source selector (shape-only stub for type parity). */
1866
1939
  export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
1867
1940
 
1941
+ /** Babylon.js finest-LOD splat-count resolution state. */
1942
+ export declare type GaussianSplattingStreamLod0SplatCount = Readonly<{
1943
+ status: "pending";
1944
+ }> | Readonly<{
1945
+ status: "available";
1946
+ count: number;
1947
+ }> | Readonly<{
1948
+ status: "unavailable";
1949
+ }>;
1950
+
1868
1951
  export declare class GeometryBufferRenderer {
1869
1952
  constructor();
1870
1953
  }
1871
1954
 
1955
+ export declare type GeometryRenderingObjectIdProvider = (mesh: AbstractMesh) => number;
1956
+
1872
1957
  /**
1873
1958
  * Babylon.js `GeospatialCamera` — globe-orbit camera anchored to a surface
1874
1959
  * `center` (ECEF), orbiting at `radius` with `yaw`/`pitch`. Wraps Babylon Lite's
@@ -1916,6 +2001,8 @@ export declare function GetPointsCount(..._args: unknown[]): never;
1916
2001
  */
1917
2002
  export declare function GetSupportedSimultaneousLights(scene: Scene, maxSimultaneousLights: number): number;
1918
2003
 
2004
+ export declare function GetWhiteBalanceMatrix(_temperatureKelvin: number, _tint: number): Float32Array | number[];
2005
+
1919
2006
  /** Shared base for compat gizmos (Babylon.js `Gizmo`). */
1920
2007
  declare abstract class GizmoBase {
1921
2008
  protected constructor(layer: UtilityLayerRenderer);
1922
2009
  abstract get attachedMesh(): AbstractMesh | null;
@@ -1950,6 +2037,18 @@ export declare class GlowLayer {
1950
2037
  constructor();
1951
2038
  }
1952
2039
 
2040
+ export declare namespace GLTF1 {
2041
+ export {
2042
+ RegisterGLTF1Loader,
2043
+ RegisterGLTFBinaryExtension,
2044
+ RegisterGLTFMaterialsCommonExtension,
2045
+ GLTFLoaderBase,
2046
+ GLTFLoader,
2047
+ GLTFBinaryExtension,
2048
+ GLTFMaterialsCommonExtension
2049
+ }
2050
+ }
2051
+
1953
2052
  export declare namespace GLTF2 {
1954
2053
  export {
1955
2054
  OpenPBRMaterialLoadingAdapter
@@ -2248,8 +2347,23 @@ export declare class HtmlRaycastInteractionManager {
2248
2347
  constructor();
2249
2348
  }
2250
2349
 
2251
- export declare class HtmlTexture {
2252
- constructor();
2350
+ /** Babylon.js `HtmlTexture`, forwarding DOM capture and updates to Babylon Lite. */
2351
+ export declare class HtmlTexture extends BaseTexture {
2352
+ readonly element: HTMLElement;
2353
+ readonly host: HTMLElement | null;
2354
+ readonly onLoadObservable: Observable<HtmlTexture>;
2355
+ private readonly _engine;
2356
+ private readonly _textureMatrix;
2357
+ private readonly _ready;
2358
+ private _htmlTexture;
2359
+ private _disposed;
2360
+ constructor(name: string, element: HTMLElement, options: IHtmlTextureOptions);
2361
+ getTextureMatrix(): Matrix;
2362
+ requestUpdate(): void;
2363
+ update(invertY?: boolean): void;
2364
+ getClassName(): string;
2365
+ whenReadyAsync(): Promise<void>;
2366
+ dispose(): void;
2253
2367
  }
2254
2368
 
2255
2369
  /** Babylon.js `IAbstractSoundOptions` (subset). */
@@ -2385,9 +2499,17 @@ export declare interface IHtmlRaycastInteractionManagerOptions {
2385
2499
  [key: string]: unknown;
2386
2500
  }
2387
2501
 
2388
- /** Options accepted by Babylon.js `HtmlTexture` (shape-only stub for type parity). */
2502
+ /** Options accepted by Babylon.js `HtmlTexture`. */
2389
2503
  export declare interface IHtmlTextureOptions {
2390
- [key: string]: unknown;
2504
+ width?: number;
2505
+ height?: number;
2506
+ generateMipMaps?: boolean;
2507
+ samplingMode?: number;
2508
+ format?: number;
2509
+ autoUpdate?: boolean;
2510
+ useSvgFallback?: boolean;
2511
+ engine?: AbstractEngine | null;
2512
+ scene?: Scene | null;
2391
2513
  }
2392
2514
 
2393
2515
  /** Options accepted by `InstallHtmlInCanvasPolyfill` (shape-only stub). */
@@ -2396,14 +2518,25 @@ export declare interface IInstallHtmlInCanvasPolyfillOptions {
2396
2518
  }
2397
2519
 
2398
2520
  /**
2399
- * Babylon.js `ImageProcessingConfiguration` — only the tone-mapping constants are
2400
- * surfaced (the live exposure/contrast/tone-mapping toggle is exposed through
2401
- * `scene.imageProcessingConfiguration`).
2521
+ * Minimal Babylon.js `ImageProcessingConfiguration` facade over Lite's image
2522
+ * processing state.
2402
2523
  */
2403
2524
  export declare class ImageProcessingConfiguration {
2404
2525
  static readonly TONEMAPPING_STANDARD = 0;
2405
2526
  static readonly TONEMAPPING_ACES = 1;
2406
2527
  static readonly TONEMAPPING_KHR_PBR_NEUTRAL = 2;
2528
+ private _backing;
2407
2529
  get exposure(): number;
2530
+ set exposure(value: number);
2531
+ get contrast(): number;
2532
+ set contrast(value: number);
2533
+ get toneMappingEnabled(): boolean;
2534
+ set toneMappingEnabled(value: boolean);
2535
+ get whiteBalanceEnabled(): boolean;
2536
+ set whiteBalanceEnabled(value: boolean);
2537
+ get temperature(): number;
2538
+ set temperature(value: number);
2539
+ get tint(): number;
2540
+ set tint(value: number);
2408
2541
  }
2409
2542
 
2410
2543
  /** The decoded image sources WebGPU (and therefore Lite) can upload into a layer. */
@@ -2455,6 +2588,14 @@ export declare class InterpolatingBehavior {
2455
2588
  constructor();
2456
2589
  }
2457
2590
 
2591
+ /** Babylon.js raycast collision-filter options. */
2592
+ export declare interface IRaycastQuery {
2593
+ membership?: number;
2594
+ collideWith?: number;
2595
+ shouldHitTriggers?: boolean;
2596
+ ignoreBody?: PhysicsBody;
2597
+ }
2598
+
2458
2599
  /**
2459
2600
  * Babylon.js `ISafeOrbitCameraLimits` — safe-orbit camera limits embedded in a Gaussian
2460
2601
  * Splatting file's metadata (Adobe safe-orbit extension). Exposed on the loaded mesh via
@@ -2489,8 +2630,8 @@ export declare interface ISceneLoaderProgressEvent {
2489
2630
  /** Babylon.js `IsHtmlInCanvasSupportedNatively` — the HTML-in-canvas feature is unsupported by the compat layer. */
2490
2631
  export declare function IsHtmlInCanvasSupportedNatively(): never;
2491
2632
 
2492
- /** Babylon.js `IsHtmlInCanvasUploadSupported` — HTML texture upload is unsupported by the compat layer. */
2493
- export declare function IsHtmlInCanvasUploadSupported(): never;
2633
+ /** Babylon.js `IsHtmlInCanvasUploadSupported` — kept in lockstep with the unavailable upload helper. */
2634
+ export declare function IsHtmlInCanvasUploadSupported(engine: AbstractEngine): boolean;
2494
2635
 
2495
2636
  /** Babylon.js `ISOGLODMetadata` — SOG LOD octree metadata (shape-only stub for type parity). */
2496
2637
  export declare interface ISOGLODMetadata {
@@ -2637,6 +2778,8 @@ export declare interface IWebAudioEngineOptions extends IAudioEngineV2Options {
2637
2778
  resumeOnPause: boolean;
2638
2779
  /** Retry interval (ms) for `resumeOnPause`. Defaults to `1000`. */
2639
2780
  resumeOnPauseRetryInterval: number;
2781
+ /** Disable Babylon.js's iOS ringer-switch workaround. Lite does not install that workaround. */
2782
+ disableIOSRingerSwitchWorkaround?: boolean;
2640
2783
  }
2641
2784
 
2642
2785
  /**
@@ -2668,9 +2811,7 @@ export declare abstract class Light extends Node_2 {
2668
2811
  protected constructor(n
2669
2812
  */
2670
2813
  get intensity(): number;
2671
2814
  set intensity(value: number);
2672
2815
  /** Detach this light's shadow generator (compat for `light.shadowEnabled = false`). */
2673
- set shadowEnabled(enabled: boolean);
2674
- dispose(): void;
2675
- }
2816
+ set shadowEnabled(enabled: boolean);
2676
2817
 
2677
2818
  export declare class LightGizmo {
2678
2819
  private _attached;
2679
2820
  constructor(layer: UtilityLayerRenderer);
@@ -2829,6 +2970,8 @@ export declare class Matrix {
2829
2970
  constructor();
2830
2971
  set(index: number, value: number): this;
2831
2972
  copyFrom(source: Matrix): this;
2973
+ /** Set only this matrix's translation components. */
2974
+ setTranslationFromFloats(x: number, y: number, z: number): this;
2832
2975
  maximizeInPlace(other: Matrix): this;
2833
2976
  maximizeInPlaceFromFloats(m0: number, m1: number, m2: number, m3: number, m4: number, m5: number, m6: number, m7: number, m8: number, m9: number, m10: number, m11: number, m12: number, m13: number, m14: number, m15: number): this;
2834
2977
  clone(): Matrix;
@@ -2849,7 +2992,7 @@ export declare class Matrix {
2849
2992
  * TRS matrix into its scale, rotation (quaternion), and translation parts,
2850
2993
  * writing into any provided out-params. Returns `false` (matching BJS) when a
2851
2994
  * scale axis is zero. The rotation extraction is backed by Lite's
2852
- * `quatFromRotationMatrix` (via `Quaternion.FromRotationMatrixToRef`); the
2995
+ * `createQuatFromRotationMat4` (via `Quaternion.FromRotationMatrixToRef`); the
2853
2996
  * negative-determinant `scale.y` flip matches Babylon.js exactly.
2854
2997
  */
2855
2998
  decompose(scale?: Vector3, rotation?: Quaternion, translation?: Vector3): boolean;
@@ -2881,6 +3024,8 @@ export declare class Matrix {
2881
3024
  markAsUpdated(): this;
2882
3025
  }
2883
3026
 
3027
+ export declare const MaxTintMagnitude = 150;
3028
+
2884
3029
  /** Babylon.js `Mesh` — a concrete renderable mesh with geometry. */
2885
3030
  export declare class Mesh extends AbstractMesh {
2886
3031
  constructor(name: string, sceneOrLite?: Scene | Mesh_2, scene?: Scene);
@@ -3016,6 +3161,8 @@ export declare class MeshoptCompression {
3016
3161
  static get Default(): MeshoptCompression;
3017
3162
  }
3018
3163
 
3164
+ export declare const MinTemperatureKelvin: number;
3165
+
3019
3166
  export declare class MirrorTexture {
3020
3167
  constructor();
3021
3168
  }
@@ -3198,12 +3345,13 @@ export declare class Observable<T> {
3198
3345
  private _observers;
3199
3346
  private _hasNotified;
3200
3347
  private _lastNotifiedValue;
3348
+ private _lastNotifiedMask;
3201
3349
  constructor(_onObserverAdded?: ((observer: ObserverCallback<T>) => void) | undefined, notifyIfTriggered?: boolean);
3202
- add(callback: ObserverCallback<T>): ObserverCallback<T>;
3203
- addOnce(callback: ObserverCallback<T>): ObserverCallback<T>;
3350
+ add(callback: ObserverCallback<T>, mask?: number): ObserverCallback<T>;
3351
+ addOnce(callback: ObserverCallback<T>, mask?: number): ObserverCallback<T>;
3204
3352
  remove(callback: ObserverCallback<T> | null | undefined): boolean;
3205
3353
  removeCallback(callback: ObserverCallback<T>): boolean;
3206
- notifyObservers(eventData?: T): void;
3354
+ notifyObservers(eventData?: T, mask?: number): void;
3207
3355
  hasObservers(): boolean;
3208
3356
  clear(): void;
3209
3357
  cleanLastNotifiedState(): void;
@@ -3747,6 +3895,10 @@ export declare class PhysicsEngine {
3747
3895
  /** Current world gravity. */
3748
3896
  setTimeStep(newTimeStep: number): void;
3749
3897
  /** Get the fixed timestep. */
3750
3898
  getTimeStep(): number;
3899
+ /** Cast a ray through the active Lite Havok world. */
3900
+ raycast(from: Vector3, to: Vector3, query?: IRaycastQuery): PhysicsRaycastResult;
3901
+ /** Cast a ray through the active Lite Havok world and write into `result`. */
3902
+ raycastToRef(from: Vector3, to: Vector3, result: PhysicsRaycastResult, query?: IRaycastQuery): void;
3751
3903
  /** Release the underlying physics world. */
3752
3904
  dispose(): void;
3753
3905
  }
@@ -3777,6 +3929,21 @@ export declare enum PhysicsPrestepType {
3777
3929
  ACTION = 2
3778
3930
  }
3779
3931
 
3932
+ /** Babylon.js raycast result backed by Lite's native Havok query result. */
3933
+ export declare class PhysicsRaycastResult extends CastingResult {
3934
+ private _hitDistance;
3935
+ private readonly _rayFromWorld;
3936
+ private readonly _rayToWorld;
3937
+ get hitDistance(): number;
3938
+ get hitNormalWorld(): Vector3;
3939
+ get hitPointWorld(): Vector3;
3940
+ get rayFromWorld(): Vector3;
3941
+ get rayToWorld(): Vector3;
3942
+ setHitDistance(distance: number): void;
3943
+ calculateHitDistance(): void;
3944
+ reset(from?: Vector3, to?: Vector3): void;
3945
+ }
3946
+
3780
3947
  /** Babylon.js-shaped collision shape backed by a Babylon Lite physics shape. */
3781
3948
  export declare class PhysicsShape {
3782
3949
  constructor(options: PhysicShapeOptions, scene: Scene);
3783
3950
  getClassName(): string;
3784
3951
  get type(): PhysicsShapeType;
@@ -3885,6 +4052,26 @@ export declare class PointerDragBehavior {
3885
4052
  constructor();
3886
4053
  }
3887
4054
 
4055
+ /** Babylon.js pointer event masks emitted by `Scene.onPointerObservable`. */
4056
+ export declare class PointerEventTypes {
4057
+ static readonly POINTERDOWN = 1;
4058
+ static readonly POINTERUP = 2;
4059
+ static readonly POINTERMOVE = 4;
4060
+ static readonly POINTERWHEEL = 8;
4061
+ static readonly POINTERPICK = 16;
4062
+ static readonly POINTERTAP = 32;
4063
+ static readonly POINTERDOUBLETAP = 64;
4064
+ }
4065
+
4066
+ /** Babylon.js-shaped payload emitted by `Scene.onPointerObservable`. */
4067
+ export declare class PointerInfo {
4068
+ type: number;
4069
+ event: PointerEvent | WheelEvent;
4070
+ private readonly _pickInfo;
4071
+ constructor(type: number, event: PointerEvent | WheelEvent, _pickInfo: PickingInfo | null);
4072
+ get pickInfo(): PickingInfo | null;
4073
+ }
4074
+
3888
4075
  export declare class PointLight extends Light {
3889
4076
  constructor(name: string, position: Vector3, scene?: Scene);
3890
4077
  getClassName(): string;
3891
4078
  get range(): number;
@@ -3943,6 +4130,10 @@ export declare class PositionGizmo extends GizmoBase {
3943
4130
  private _attached;
3944
4131
  private _xGizmo;
3945
4132
  private _yGizmo;
3946
4133
  private _zGizmo;
4134
+ private _dragSubscriptions;
4135
+ readonly onDragStartObservable: Observable<DragStartEndEvent>;
4136
+ readonly onDragObservable: Observable<DragEvent_2>;
4137
+ readonly onDragEndObservable: Observable<DragStartEndEvent>;
3947
4138
  constructor(layer: UtilityLayerRenderer);
3948
4139
  /** Babylon.js `PositionGizmo.xGizmo/yGizmo/zGizmo` — the per-axis drag sub-gizmos.
3949
4140
  * Exposed so callers can toggle interactivity per axis (e.g. `xGizmo.isEnabled = false`
@@ -4009,7 +4200,7 @@ export declare class Quaternion {
4009
4200
  conjugate(): Quaternion;
4010
4201
  /**
4011
4202
  * Babylon.js `Quaternion.fromRotationMatrix` — update this quaternion in place
4012
- * from the rotation part of `matrix`. Backed by Lite's `quatFromRotationMatrix`.
4203
+ * from the rotation part of `matrix`. Backed by Lite's `createQuatFromRotationMat4`.
4013
4204
  */
4014
4205
  fromRotationMatrix(matrix: Matrix): this;
4015
4206
  /**
@@ -4024,12 +4215,12 @@ export declare class Quaternion {
4024
4215
  static Identity(): Quaternion;
4025
4216
  /**
4026
4217
  * Babylon.js `Quaternion.FromRotationMatrix` — create a new quaternion from the
4027
- * rotation part of `matrix`. Backed by Lite's `quatFromRotationMatrix`.
4218
+ * rotation part of `matrix`. Backed by Lite's `createQuatFromRotationMat4`.
4028
4219
  */
4029
4220
  static FromRotationMatrix(matrix: Matrix): Quaternion;
4030
4221
  /**
4031
4222
  * Babylon.js `Quaternion.FromRotationMatrixToRef` — write the rotation part of
4032
- * `matrix` into `result`. Backed by Lite's `quatFromRotationMatrix`.
4223
+ * `matrix` into `result`. Backed by Lite's `createQuatFromRotationMat4`.
4033
4224
  */
4034
4225
  static FromRotationMatrixToRef(matrix: Matrix, result: Quaternion): Quaternion;
4035
4226
  static FromEulerAngles(x: number, y: number, z: number): Quaternion;
@@ -4171,10 +4362,30 @@ export declare class ReflectionProbe {
4171
4362
  constructor();
4172
4363
  }
4173
4364
 
4365
+ /**
4366
+ * Babylon.js pure-module texture-loader registration hook. Lite dispatches its
4367
+ * supported texture formats directly, so no registration is required.
4368
+ */
4369
+ export declare function RegisterAbstractEngineTextureLoaders(): void;
4370
+
4371
+ /**
4372
+ * Babylon.js registers built-in loader factories through a global plugin
4373
+ * registry. Compat dispatches its supported formats directly, so registration
4374
+ * is already complete and this compatibility hook is intentionally idempotent.
4375
+ */
4376
+ export declare function registerBuiltInLoaders(): void;
4377
+
4378
+ export declare function RegisterFluidRenderer(): void;
4379
+
4174
4380
  export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
4175
4381
 
4382
+ /** Babylon.js pure-module registration hook. */
4383
+ export declare function RegisterImageProcessingConfiguration(): void;
4384
+
4176
4385
  export declare function RegisterOpenpbrMaterial(): void;
4177
4386
 
4387
+ export declare function RegisterUSDFileLoader(): never;
4388
+
4178
4389
  /** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
4179
4390
  export declare class RenderTargetTexture {
4180
4391
  constructor();
@@ -4184,6 +4395,10 @@ export declare class RotationGizmo extends GizmoBase {
4184
4395
  private _attached;
4185
4396
  private _xGizmo;
4186
4397
  private _yGizmo;
4187
4398
  private _zGizmo;
4399
+ private _dragSubscriptions;
4400
+ readonly onDragStartObservable: Observable<DragStartEndEvent>;
4401
+ readonly onDragObservable: Observable<DragEvent_2>;
4402
+ readonly onDragEndObservable: Observable<DragStartEndEvent>;
4188
4403
  constructor(layer: UtilityLayerRenderer);
4189
4404
  /** Babylon.js `RotationGizmo.xGizmo/yGizmo/zGizmo` — the per-plane rotation sub-gizmos. */
4190
4405
  get xGizmo(): PlaneRotationGizmo;
@@ -4239,9 +4454,12 @@ export declare class Scene extends AbstractScene {
4239
4454
  /** Babylon.js fog-mode c
4240
4455
  readonly onBeforeAnimationsObservable: Observable<Scene>;
4241
4456
  /** Fires after each scene render. */
4242
4457
  readonly onAfterRenderObservable: Observable<Scene>;
4458
+ /** Fires after each Lite Havok simulation step. */
4459
+ readonly onAfterPhysicsObservable: Observable<Scene>;
4243
4460
  /** Fires once when the scene is disposed. */
4244
4461
  readonly onDisposeObservable: Observable<Scene>;
4245
- /**
4462
+ /** Babylon.js scene-level pointer events from the engine rendering canvas. */
4463
+ readonly onPointerObservable: Observable<PointerInfo>;
4246
4464
  /**
4247
4465
  * Babylon.js `scene.animationGroups` / `scene.animatables`. Loaded glTF /
4248
4466
  * `.babylon` animation clips live on the Lite scene; `animationGroups` returns
4249
4467
  * BJS-shaped `AnimationGroup`s over them (so scenes can `goToFrame`/`pause`/`stop`
@@ -4254,6 +4472,7 @@ export declare class Scene extends AbstractScene {
4254
4472
  /** Babylon.js fog-mode c
4255
4473
  get animatables(): Animatable_2[];
4256
4474
  private readonly _engine;
4257
4475
  private _activeCamera;
4476
+ cameraToUseForPointers: Camera | null;
4258
4477
  private _defaultMaterial;
4259
4478
  private _fogMode;
4260
4479
  private _fogStart;
@@ -4269,9 +4488,12 @@ export declare class Scene extends AbstractScene {
4269
4488
  /** Babylon.js fog-mode c
4270
4489
  private readonly _pendingMorphBuilds;
4271
4490
  private readonly _runningAnimatables;
4272
4491
  private readonly _animationGroupCache;
4273
4492
  private _ambientColor;
4274
- private _environmentIntensity;
4275
4493
  /** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
4494
+ private _environmentIntensity;
4495
+ private _imageProcessingConfiguration;
4276
4496
  /** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
4277
4497
  readonly uniqueId: number;
4278
- constructor(engine: WebGPUEngine);
4279
4498
  getEngine(): WebGPUEngine;
4499
+ constructor(engine: WebGPUEngine);
4500
+ private _attachPointerEvents;
4501
+ private _detachPointerEvents;
4280
4502
  getEngine(): WebGPUEngine;
4281
4503
  /** Babylon.js `scene.getClassName()`. */
4282
4504
  getClassName(): string;
4283
4505
  /** Babylon.js `scene.getUniqueId()` — the process-unique scene id. */
@@ -4286,12 +4508,12 @@ export declare class Scene extends AbstractScene {
4286
4508
  /** Babylon.js fog-mode c
4287
4509
  get clearColor(): Color4;
4288
4510
  set clearColor(value: Color4);
4289
4511
  get activeCamera(): Camera | null;
4290
- set activeCamera(camera: Camera | null);
4291
4512
  /** Image-processing exposure proxy (Babylon.js `imageProcessingConfiguration.exposure`). */
4292
- get imageProcessingConfiguration(): {
4293
- exposure: number;
4294
- contrast: number;
4295
- toneMappingEnabled: boolean;
4296
- };
4513
+ set activeCamera(camera: Camera | null);
4297
4514
  /** Babylon.js image-processing facade over the scene's Lite state. */
4515
+ get imageProcessingConfiguration(): ImageProcessingConfiguration;
4516
+ get fluidRenderer(): FluidRenderer | null;
4517
+ set fluidRenderer(value: FluidRenderer | null);
4518
+ enableFluidRenderer(): FluidRenderer | null;
4519
+ disableFluidRenderer(): void;
4298
4520
  /** Babylon.js `scene.performancePriority` — accepted for parity; Babylon Lite tunes its own pipeline. */
4299
4521
  performancePriority: number;
4300
4522
  /**
@@ -4395,10 +4617,15 @@ export declare class Scene extends AbstractScene {
4395
4617
  /** Babylon.js fog-mode c
4396
4618
  whenReadyAsync(): Promise<void>;
4397
4619
  /** Babylon.js synchronous readiness check — always ready in the compat layer. */
4398
4620
  isReady(): boolean;
4399
- /** Synchronous CPU picking — unsupported. Babylon Lite uses async GPU picking. */
4400
- pick(): never;
4621
+ /** Babylon.js synchronous screen-coordinate picking over Lite's CPU ray picker. */
4622
+ pick(x: number, y: number, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, camera?: Camera | null, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
4623
+ /**
4624
+ * Babylon.js `Scene.createPickingRay` — translate CSS coordinates and camera
4625
+ * transforms into Lite's reverse-Z unprojection helper.
4626
+ */
4627
+ createPickingRay(x: number, y: number, world?: Matrix | null, camera?: Camera | null, cameraViewSpace?: boolean): Ray;
4401
4628
  /** Synchronous CPU ray picking over Babylon Lite's scene-mesh picker. */
4402
- pickWithRay(ray: Ray, predicate?: (mesh: TransformNode) => boolean, fastCheck?: boolean, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
4403
4629
  /**
4630
+ pickWithRay(ray: Ray, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
4404
4631
  /**
4405
4632
  * Babylon.js `scene.enablePhysics(gravity, plugin)`. Wires the given Havok V2
4406
4633
  * {@link HavokPlugin} to this scene, creating the native Lite physics world and
4407
4634
  * registering per-frame stepping. The plugin's `useDeltaForWorldStep` flag
@@ -4499,7 +4726,11 @@ export declare class ShaderMaterial {
4499
4726
  export declare class ShadowGenerator {
4500
4727
  private readonly _mapSize;
4501
4728
  private readonly _light;
4502
- private readonly _casters;
4503
4729
  getClassName(): string;
4730
+ private readonly _casters;
4731
+ private readonly _casterDisposeObservers;
4732
+ private _casterSyncScheduled;
4733
+ private _casterSyncDirty;
4734
+ private readonly _disposeBeforeRenderFlush;
4504
4735
  getClassName(): string;
4505
4736
  /** Percentage-closer filtering. */
4506
4737
  usePercentageCloserFiltering: boolean;
4507
4738
  /** Contact-hardening (treated as PCF here). */
@@ -4524,9 +4755,14 @@ export declare class ShadowGenerator {
4524
4755
  orthoMaxZ: number | undefined;
4525
4756
  constructor(mapSize: number, light: Light);
4526
4757
  /** Babylon.js `addShadowCaster(mesh, includeDescendants?)`. */
4527
- addShadowCaster(mesh: AbstractMesh, _includeDescendants?: boolean): ShadowGenerator;
4528
- /** Babylon.js `removeShadowCaster(mesh)`. */
4529
- removeShadowCaster(mesh: AbstractMesh): ShadowGenerator;
4758
+ addShadowCaster(mesh: AbstractMesh, includeDescendants?: boolean): ShadowGenerator;
4759
+ /** Babylon.js `removeShadowCaster(mesh, includeDescendants?)`. */
4760
+ removeShadowCaster(mesh: AbstractMesh, includeDescendants?: boolean): ShadowGenerator;
4761
+ private _casterTree;
4762
+ private _detachCasterDisposeObserver;
4763
+ private _removeCaster;
4764
+ private _scheduleCasterSync;
4765
+ private _flushCasterSync;
4530
4766
  /** Babylon.js `getShadowMap()` — returns a minimal render-list holder for parity. */
4531
4767
  getShadowMap(): {
4532
4768
  renderList: AbstractMesh[];
@@ -5023,6 +5259,8 @@ export declare class TargetCamera extends Camera {
5023
5259
  constructor(name: string,
5024
5260
 
5025
5261
  declare type TaskState = "init" | "running" | "done" | "error";
5026
5262
 
5263
+ export declare function TemperatureTintToXyz(_temperatureKelvin: number, _tint: number): Vector3;
5264
+
5027
5265
  export declare class Texture extends BaseTexture {
5028
5266
  private readonly _ready;
5029
5267
  private _onLoadObservable;
@@ -5179,8 +5417,7 @@ export declare class TransformNode extends Node_2 {
5179
5417
  physicsBody: PhysicsBody
5180
5418
  * setter, which keeps the local transform and lets the world move.
5181
5419
  */
5182
5420
  setParent(parent: Node_2 | null): TransformNode;
5183
- protected _applyParent(parent: Node_2 | null): void;
5184
- }
5421
+ protected _applyParent(parent: Node_2 | null): void;
5185
5422
 
5186
5423
  export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
5187
5424
 
@@ -5206,6 +5443,60 @@ export declare function UploadHtmlElementToTexture(): never;
5206
5443
  */
5207
5444
  export declare function UploadImageToTexture2DArrayLayer(texture: RawTexture2DArray, source: ImageSource, layer: number, options?: IUploadImageToTexture2DArrayLayerOptions): void;
5208
5445
 
5446
+ export declare type USDBinaryInput = ArrayBuffer | ArrayBufferView;
5447
+
5448
+ export declare class USDFileLoader {
5449
+ constructor(_options?: Partial<USDFileLoaderOptions>);
5450
+ }
5451
+
5452
+ export declare interface USDFileLoaderOptions {
5453
+ rootFileName?: string;
5454
+ files?: USDVirtualFiles;
5455
+ resolveByFileName?: boolean;
5456
+ workerUrl?: string | URL;
5457
+ glueUrl?: string;
5458
+ wasmUrl?: string;
5459
+ dataUrl?: string;
5460
+ onProgress?: (progress: USDLoadProgress) => void;
5461
+ onLog?: (level: "info" | "warning" | "error", message: string) => void;
5462
+ onComplete?: (diagnostics: USDImportDiagnostics) => void;
5463
+ }
5464
+
5465
+ export declare interface USDImportDiagnostics {
5466
+ timings: USDImportTimings;
5467
+ statistics: USDImportStatistics;
5468
+ missingAssets: readonly string[];
5469
+ }
5470
+
5471
+ export declare interface USDImportStatistics {
5472
+ nodes: number;
5473
+ meshes: number;
5474
+ analyticPrimitives: number;
5475
+ instances: number;
5476
+ materials: number;
5477
+ vertices: number;
5478
+ triangles: number;
5479
+ commandBytes: number;
5480
+ dataBytes: number;
5481
+ }
5482
+
5483
+ export declare interface USDImportTimings {
5484
+ totalMs: number;
5485
+ stageOpenMs: number;
5486
+ stageReadMs: number;
5487
+ preparationMs: number;
5488
+ packingMs: number;
5489
+ heapCopyMs: number;
5490
+ materializeMs: number;
5491
+ }
5492
+
5493
+ export declare interface USDLoadProgress {
5494
+ phase: "initializing" | "staging" | "extracting" | "materializing";
5495
+ message: string;
5496
+ }
5497
+
5498
+ export declare type USDVirtualFiles = Readonly<Record<string, USDBinaryInput>>;
5499
+
5209
5500
  /** Babylon.js `UtilityLayerRenderer` — the overlay scene gizmos render into. */
5210
5501
  export declare class UtilityLayerRenderer {
5211
5502
  private _registered;
5212
5503
  constructor(scene: Scene);
5213
5504
  dispose(): void;
@@ -5318,6 +5609,10 @@ export declare class Vector3 {
5318
5609
  static NormalizeToRef<T extends Vector3>(vector: Vector3, result: T): T;
5319
5610
  static Minimize(a: Vector3, b: Vector3): Vector3;
5320
5611
  static Maximize(a: Vector3, b: Vector3): Vector3;
5612
+ /** Project a world-space point into a Babylon.js viewport. */
5613
+ static Project(vector: Vector3, world: Matrix, transform: Matrix, viewport: Viewport): Vector3;
5614
+ /** Project a world-space point into a Babylon.js viewport, writing into `result`. */
5615
+ static ProjectToRef<T extends Vector3>(vector: Vector3, world: Matrix, transform: Matrix, viewport: Viewport, result: T): T;
5321
5616
  /** Transform a coordinate (point) by a matrix using the row-vector convention. */
5322
5617
  static TransformCoordinates(vector: Vector3, transformation: Matrix): Vector3;
5323
5618
  /** Transform a coordinate (point) by a matrix using the row-vector convention. */