@babylonjs/lite-compat 1.27.0-preview → 1.29.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. */
@@ -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;
@@ -1752,6 +1786,31 @@ export declare class FBXFileLoader {
1752
1786
  constructor();
1753
1787
  }
1754
1788
 
1789
+ export declare class FluidRenderer {
1790
+ constructor(_scene: Scene);
1791
+ }
1792
+
1793
+ export declare class FluidRendererSceneComponent {
1794
+ constructor(_scene: Scene);
1795
+ }
1796
+
1797
+ export declare abstract class FluidRenderingObject {
1798
+ static UsePerParticleSizeAttribute: boolean;
1799
+ protected constructor(_scene: Scene, _shaderLanguage?: ShaderLanguage);
1800
+ }
1801
+
1802
+ export declare class FluidRenderingObjectCustomParticles extends FluidRenderingObject {
1803
+ constructor(scene: Scene, _buffers: Record<string, ArrayLike<number>>, _numParticles: number, shaderLanguage?: ShaderLanguage);
1804
+ }
1805
+
1806
+ export declare class FluidRenderingObjectParticleSystem extends FluidRenderingObject {
1807
+ constructor(scene: Scene, _particleSystem: unknown, shaderLanguage?: ShaderLanguage);
1808
+ }
1809
+
1810
+ export declare class FluidRenderingTargetRenderer {
1811
+ constructor(_scene: Scene, _camera?: Camera, _shaderLanguage?: ShaderLanguage);
1812
+ }
1813
+
1755
1814
  /** Babylon.js `FlyCamera` — 6-DOF free-flight camera. */
1756
1815
  export declare class FlyCamera extends TargetCamera {
1757
1816
  constructor(name: string, position: Vector3, scene?: Scene);
1758
1817
  get upVector(): Vector3;
@@ -1916,6 +1975,8 @@ export declare function GetPointsCount(..._args: unknown[]): never;
1916
1975
  */
1917
1976
  export declare function GetSupportedSimultaneousLights(scene: Scene, maxSimultaneousLights: number): number;
1918
1977
 
1978
+ export declare function GetWhiteBalanceMatrix(_temperatureKelvin: number, _tint: number): Float32Array | number[];
1979
+
1919
1980
  /** Shared base for compat gizmos (Babylon.js `Gizmo`). */
1920
1981
  declare abstract class GizmoBase {
1921
1982
  protected constructor(layer: UtilityLayerRenderer);
1922
1983
  abstract get attachedMesh(): AbstractMesh | null;
@@ -1950,6 +2011,18 @@ export declare class GlowLayer {
1950
2011
  constructor();
1951
2012
  }
1952
2013
 
2014
+ export declare namespace GLTF1 {
2015
+ export {
2016
+ RegisterGLTF1Loader,
2017
+ RegisterGLTFBinaryExtension,
2018
+ RegisterGLTFMaterialsCommonExtension,
2019
+ GLTFLoaderBase,
2020
+ GLTFLoader,
2021
+ GLTFBinaryExtension,
2022
+ GLTFMaterialsCommonExtension
2023
+ }
2024
+ }
2025
+
1953
2026
  export declare namespace GLTF2 {
1954
2027
  export {
1955
2028
  OpenPBRMaterialLoadingAdapter
@@ -2248,8 +2321,23 @@ export declare class HtmlRaycastInteractionManager {
2248
2321
  constructor();
2249
2322
  }
2250
2323
 
2251
- export declare class HtmlTexture {
2252
- constructor();
2324
+ /** Babylon.js `HtmlTexture`, forwarding DOM capture and updates to Babylon Lite. */
2325
+ export declare class HtmlTexture extends BaseTexture {
2326
+ readonly element: HTMLElement;
2327
+ readonly host: HTMLElement | null;
2328
+ readonly onLoadObservable: Observable<HtmlTexture>;
2329
+ private readonly _engine;
2330
+ private readonly _textureMatrix;
2331
+ private readonly _ready;
2332
+ private _htmlTexture;
2333
+ private _disposed;
2334
+ constructor(name: string, element: HTMLElement, options: IHtmlTextureOptions);
2335
+ getTextureMatrix(): Matrix;
2336
+ requestUpdate(): void;
2337
+ update(invertY?: boolean): void;
2338
+ getClassName(): string;
2339
+ whenReadyAsync(): Promise<void>;
2340
+ dispose(): void;
2253
2341
  }
2254
2342
 
2255
2343
  /** Babylon.js `IAbstractSoundOptions` (subset). */
@@ -2385,9 +2473,17 @@ export declare interface IHtmlRaycastInteractionManagerOptions {
2385
2473
  [key: string]: unknown;
2386
2474
  }
2387
2475
 
2388
- /** Options accepted by Babylon.js `HtmlTexture` (shape-only stub for type parity). */
2476
+ /** Options accepted by Babylon.js `HtmlTexture`. */
2389
2477
  export declare interface IHtmlTextureOptions {
2390
- [key: string]: unknown;
2478
+ width?: number;
2479
+ height?: number;
2480
+ generateMipMaps?: boolean;
2481
+ samplingMode?: number;
2482
+ format?: number;
2483
+ autoUpdate?: boolean;
2484
+ useSvgFallback?: boolean;
2485
+ engine?: AbstractEngine | null;
2486
+ scene?: Scene | null;
2391
2487
  }
2392
2488
 
2393
2489
  /** Options accepted by `InstallHtmlInCanvasPolyfill` (shape-only stub). */
@@ -2396,14 +2492,25 @@ export declare interface IInstallHtmlInCanvasPolyfillOptions {
2396
2492
  }
2397
2493
 
2398
2494
  /**
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`).
2495
+ * Minimal Babylon.js `ImageProcessingConfiguration` facade over Lite's image
2496
+ * processing state.
2402
2497
  */
2403
2498
  export declare class ImageProcessingConfiguration {
2404
2499
  static readonly TONEMAPPING_STANDARD = 0;
2405
2500
  static readonly TONEMAPPING_ACES = 1;
2406
2501
  static readonly TONEMAPPING_KHR_PBR_NEUTRAL = 2;
2502
+ private _backing;
2407
2503
  get exposure(): number;
2504
+ set exposure(value: number);
2505
+ get contrast(): number;
2506
+ set contrast(value: number);
2507
+ get toneMappingEnabled(): boolean;
2508
+ set toneMappingEnabled(value: boolean);
2509
+ get whiteBalanceEnabled(): boolean;
2510
+ set whiteBalanceEnabled(value: boolean);
2511
+ get temperature(): number;
2512
+ set temperature(value: number);
2513
+ get tint(): number;
2514
+ set tint(value: number);
2408
2515
  }
2409
2516
 
2410
2517
  /** The decoded image sources WebGPU (and therefore Lite) can upload into a layer. */
@@ -2455,6 +2562,14 @@ export declare class InterpolatingBehavior {
2455
2562
  constructor();
2456
2563
  }
2457
2564
 
2565
+ /** Babylon.js raycast collision-filter options. */
2566
+ export declare interface IRaycastQuery {
2567
+ membership?: number;
2568
+ collideWith?: number;
2569
+ shouldHitTriggers?: boolean;
2570
+ ignoreBody?: PhysicsBody;
2571
+ }
2572
+
2458
2573
  /**
2459
2574
  * Babylon.js `ISafeOrbitCameraLimits` — safe-orbit camera limits embedded in a Gaussian
2460
2575
  * Splatting file's metadata (Adobe safe-orbit extension). Exposed on the loaded mesh via
@@ -2489,8 +2604,8 @@ export declare interface ISceneLoaderProgressEvent {
2489
2604
  /** Babylon.js `IsHtmlInCanvasSupportedNatively` — the HTML-in-canvas feature is unsupported by the compat layer. */
2490
2605
  export declare function IsHtmlInCanvasSupportedNatively(): never;
2491
2606
 
2492
- /** Babylon.js `IsHtmlInCanvasUploadSupported` — HTML texture upload is unsupported by the compat layer. */
2493
- export declare function IsHtmlInCanvasUploadSupported(): never;
2607
+ /** Babylon.js `IsHtmlInCanvasUploadSupported` — kept in lockstep with the unavailable upload helper. */
2608
+ export declare function IsHtmlInCanvasUploadSupported(engine: AbstractEngine): boolean;
2494
2609
 
2495
2610
  /** Babylon.js `ISOGLODMetadata` — SOG LOD octree metadata (shape-only stub for type parity). */
2496
2611
  export declare interface ISOGLODMetadata {
@@ -2637,6 +2752,8 @@ export declare interface IWebAudioEngineOptions extends IAudioEngineV2Options {
2637
2752
  resumeOnPause: boolean;
2638
2753
  /** Retry interval (ms) for `resumeOnPause`. Defaults to `1000`. */
2639
2754
  resumeOnPauseRetryInterval: number;
2755
+ /** Disable Babylon.js's iOS ringer-switch workaround. Lite does not install that workaround. */
2756
+ disableIOSRingerSwitchWorkaround?: boolean;
2640
2757
  }
2641
2758
 
2642
2759
  /**
@@ -2668,9 +2785,7 @@ export declare abstract class Light extends Node_2 {
2668
2785
  protected constructor(n
2669
2786
  */
2670
2787
  get intensity(): number;
2671
2788
  set intensity(value: number);
2672
2789
  /** Detach this light's shadow generator (compat for `light.shadowEnabled = false`). */
2673
- set shadowEnabled(enabled: boolean);
2674
- dispose(): void;
2675
- }
2790
+ set shadowEnabled(enabled: boolean);
2676
2791
 
2677
2792
  export declare class LightGizmo {
2678
2793
  private _attached;
2679
2794
  constructor(layer: UtilityLayerRenderer);
@@ -2829,6 +2944,8 @@ export declare class Matrix {
2829
2944
  constructor();
2830
2945
  set(index: number, value: number): this;
2831
2946
  copyFrom(source: Matrix): this;
2947
+ /** Set only this matrix's translation components. */
2948
+ setTranslationFromFloats(x: number, y: number, z: number): this;
2832
2949
  maximizeInPlace(other: Matrix): this;
2833
2950
  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
2951
  clone(): Matrix;
@@ -2849,7 +2966,7 @@ export declare class Matrix {
2849
2966
  * TRS matrix into its scale, rotation (quaternion), and translation parts,
2850
2967
  * writing into any provided out-params. Returns `false` (matching BJS) when a
2851
2968
  * scale axis is zero. The rotation extraction is backed by Lite's
2852
- * `quatFromRotationMatrix` (via `Quaternion.FromRotationMatrixToRef`); the
2969
+ * `createQuatFromRotationMat4` (via `Quaternion.FromRotationMatrixToRef`); the
2853
2970
  * negative-determinant `scale.y` flip matches Babylon.js exactly.
2854
2971
  */
2855
2972
  decompose(scale?: Vector3, rotation?: Quaternion, translation?: Vector3): boolean;
@@ -2881,6 +2998,8 @@ export declare class Matrix {
2881
2998
  markAsUpdated(): this;
2882
2999
  }
2883
3000
 
3001
+ export declare const MaxTintMagnitude = 150;
3002
+
2884
3003
  /** Babylon.js `Mesh` — a concrete renderable mesh with geometry. */
2885
3004
  export declare class Mesh extends AbstractMesh {
2886
3005
  constructor(name: string, sceneOrLite?: Scene | Mesh_2, scene?: Scene);
@@ -3016,6 +3135,8 @@ export declare class MeshoptCompression {
3016
3135
  static get Default(): MeshoptCompression;
3017
3136
  }
3018
3137
 
3138
+ export declare const MinTemperatureKelvin: number;
3139
+
3019
3140
  export declare class MirrorTexture {
3020
3141
  constructor();
3021
3142
  }
@@ -3198,12 +3319,13 @@ export declare class Observable<T> {
3198
3319
  private _observers;
3199
3320
  private _hasNotified;
3200
3321
  private _lastNotifiedValue;
3322
+ private _lastNotifiedMask;
3201
3323
  constructor(_onObserverAdded?: ((observer: ObserverCallback<T>) => void) | undefined, notifyIfTriggered?: boolean);
3202
- add(callback: ObserverCallback<T>): ObserverCallback<T>;
3203
- addOnce(callback: ObserverCallback<T>): ObserverCallback<T>;
3324
+ add(callback: ObserverCallback<T>, mask?: number): ObserverCallback<T>;
3325
+ addOnce(callback: ObserverCallback<T>, mask?: number): ObserverCallback<T>;
3204
3326
  remove(callback: ObserverCallback<T> | null | undefined): boolean;
3205
3327
  removeCallback(callback: ObserverCallback<T>): boolean;
3206
- notifyObservers(eventData?: T): void;
3328
+ notifyObservers(eventData?: T, mask?: number): void;
3207
3329
  hasObservers(): boolean;
3208
3330
  clear(): void;
3209
3331
  cleanLastNotifiedState(): void;
@@ -3747,6 +3869,10 @@ export declare class PhysicsEngine {
3747
3869
  /** Current world gravity. */
3748
3870
  setTimeStep(newTimeStep: number): void;
3749
3871
  /** Get the fixed timestep. */
3750
3872
  getTimeStep(): number;
3873
+ /** Cast a ray through the active Lite Havok world. */
3874
+ raycast(from: Vector3, to: Vector3, query?: IRaycastQuery): PhysicsRaycastResult;
3875
+ /** Cast a ray through the active Lite Havok world and write into `result`. */
3876
+ raycastToRef(from: Vector3, to: Vector3, result: PhysicsRaycastResult, query?: IRaycastQuery): void;
3751
3877
  /** Release the underlying physics world. */
3752
3878
  dispose(): void;
3753
3879
  }
@@ -3777,6 +3903,21 @@ export declare enum PhysicsPrestepType {
3777
3903
  ACTION = 2
3778
3904
  }
3779
3905
 
3906
+ /** Babylon.js raycast result backed by Lite's native Havok query result. */
3907
+ export declare class PhysicsRaycastResult extends CastingResult {
3908
+ private _hitDistance;
3909
+ private readonly _rayFromWorld;
3910
+ private readonly _rayToWorld;
3911
+ get hitDistance(): number;
3912
+ get hitNormalWorld(): Vector3;
3913
+ get hitPointWorld(): Vector3;
3914
+ get rayFromWorld(): Vector3;
3915
+ get rayToWorld(): Vector3;
3916
+ setHitDistance(distance: number): void;
3917
+ calculateHitDistance(): void;
3918
+ reset(from?: Vector3, to?: Vector3): void;
3919
+ }
3920
+
3780
3921
  /** Babylon.js-shaped collision shape backed by a Babylon Lite physics shape. */
3781
3922
  export declare class PhysicsShape {
3782
3923
  constructor(options: PhysicShapeOptions, scene: Scene);
3783
3924
  getClassName(): string;
3784
3925
  get type(): PhysicsShapeType;
@@ -3885,6 +4026,26 @@ export declare class PointerDragBehavior {
3885
4026
  constructor();
3886
4027
  }
3887
4028
 
4029
+ /** Babylon.js pointer event masks emitted by `Scene.onPointerObservable`. */
4030
+ export declare class PointerEventTypes {
4031
+ static readonly POINTERDOWN = 1;
4032
+ static readonly POINTERUP = 2;
4033
+ static readonly POINTERMOVE = 4;
4034
+ static readonly POINTERWHEEL = 8;
4035
+ static readonly POINTERPICK = 16;
4036
+ static readonly POINTERTAP = 32;
4037
+ static readonly POINTERDOUBLETAP = 64;
4038
+ }
4039
+
4040
+ /** Babylon.js-shaped payload emitted by `Scene.onPointerObservable`. */
4041
+ export declare class PointerInfo {
4042
+ type: number;
4043
+ event: PointerEvent | WheelEvent;
4044
+ private readonly _pickInfo;
4045
+ constructor(type: number, event: PointerEvent | WheelEvent, _pickInfo: PickingInfo | null);
4046
+ get pickInfo(): PickingInfo | null;
4047
+ }
4048
+
3888
4049
  export declare class PointLight extends Light {
3889
4050
  constructor(name: string, position: Vector3, scene?: Scene);
3890
4051
  getClassName(): string;
3891
4052
  get range(): number;
@@ -4009,7 +4170,7 @@ export declare class Quaternion {
4009
4170
  conjugate(): Quaternion;
4010
4171
  /**
4011
4172
  * Babylon.js `Quaternion.fromRotationMatrix` — update this quaternion in place
4012
- * from the rotation part of `matrix`. Backed by Lite's `quatFromRotationMatrix`.
4173
+ * from the rotation part of `matrix`. Backed by Lite's `createQuatFromRotationMat4`.
4013
4174
  */
4014
4175
  fromRotationMatrix(matrix: Matrix): this;
4015
4176
  /**
@@ -4024,12 +4185,12 @@ export declare class Quaternion {
4024
4185
  static Identity(): Quaternion;
4025
4186
  /**
4026
4187
  * Babylon.js `Quaternion.FromRotationMatrix` — create a new quaternion from the
4027
- * rotation part of `matrix`. Backed by Lite's `quatFromRotationMatrix`.
4188
+ * rotation part of `matrix`. Backed by Lite's `createQuatFromRotationMat4`.
4028
4189
  */
4029
4190
  static FromRotationMatrix(matrix: Matrix): Quaternion;
4030
4191
  /**
4031
4192
  * Babylon.js `Quaternion.FromRotationMatrixToRef` — write the rotation part of
4032
- * `matrix` into `result`. Backed by Lite's `quatFromRotationMatrix`.
4193
+ * `matrix` into `result`. Backed by Lite's `createQuatFromRotationMat4`.
4033
4194
  */
4034
4195
  static FromRotationMatrixToRef(matrix: Matrix, result: Quaternion): Quaternion;
4035
4196
  static FromEulerAngles(x: number, y: number, z: number): Quaternion;
@@ -4171,10 +4332,23 @@ export declare class ReflectionProbe {
4171
4332
  constructor();
4172
4333
  }
4173
4334
 
4335
+ /**
4336
+ * Babylon.js pure-module texture-loader registration hook. Lite dispatches its
4337
+ * supported texture formats directly, so no registration is required.
4338
+ */
4339
+ export declare function RegisterAbstractEngineTextureLoaders(): void;
4340
+
4341
+ export declare function RegisterFluidRenderer(): void;
4342
+
4174
4343
  export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
4175
4344
 
4345
+ /** Babylon.js pure-module registration hook. */
4346
+ export declare function RegisterImageProcessingConfiguration(): void;
4347
+
4176
4348
  export declare function RegisterOpenpbrMaterial(): void;
4177
4349
 
4350
+ export declare function RegisterUSDFileLoader(): never;
4351
+
4178
4352
  /** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
4179
4353
  export declare class RenderTargetTexture {
4180
4354
  constructor();
@@ -4239,9 +4413,12 @@ export declare class Scene extends AbstractScene {
4239
4413
  /** Babylon.js fog-mode c
4240
4414
  readonly onBeforeAnimationsObservable: Observable<Scene>;
4241
4415
  /** Fires after each scene render. */
4242
4416
  readonly onAfterRenderObservable: Observable<Scene>;
4417
+ /** Fires after each Lite Havok simulation step. */
4418
+ readonly onAfterPhysicsObservable: Observable<Scene>;
4243
4419
  /** Fires once when the scene is disposed. */
4244
4420
  readonly onDisposeObservable: Observable<Scene>;
4245
- /**
4421
+ /** Babylon.js scene-level pointer events from the engine rendering canvas. */
4422
+ readonly onPointerObservable: Observable<PointerInfo>;
4246
4423
  /**
4247
4424
  * Babylon.js `scene.animationGroups` / `scene.animatables`. Loaded glTF /
4248
4425
  * `.babylon` animation clips live on the Lite scene; `animationGroups` returns
4249
4426
  * BJS-shaped `AnimationGroup`s over them (so scenes can `goToFrame`/`pause`/`stop`
@@ -4254,6 +4431,7 @@ export declare class Scene extends AbstractScene {
4254
4431
  /** Babylon.js fog-mode c
4255
4432
  get animatables(): Animatable_2[];
4256
4433
  private readonly _engine;
4257
4434
  private _activeCamera;
4435
+ cameraToUseForPointers: Camera | null;
4258
4436
  private _defaultMaterial;
4259
4437
  private _fogMode;
4260
4438
  private _fogStart;
@@ -4269,9 +4447,12 @@ export declare class Scene extends AbstractScene {
4269
4447
  /** Babylon.js fog-mode c
4270
4448
  private readonly _pendingMorphBuilds;
4271
4449
  private readonly _runningAnimatables;
4272
4450
  private readonly _animationGroupCache;
4273
4451
  private _ambientColor;
4274
- private _environmentIntensity;
4275
4452
  /** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
4453
+ private _environmentIntensity;
4454
+ private _imageProcessingConfiguration;
4276
4455
  /** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
4277
4456
  readonly uniqueId: number;
4278
- constructor(engine: WebGPUEngine);
4279
4457
  getEngine(): WebGPUEngine;
4458
+ constructor(engine: WebGPUEngine);
4459
+ private _attachPointerEvents;
4460
+ private _detachPointerEvents;
4280
4461
  getEngine(): WebGPUEngine;
4281
4462
  /** Babylon.js `scene.getClassName()`. */
4282
4463
  getClassName(): string;
4283
4464
  /** Babylon.js `scene.getUniqueId()` — the process-unique scene id. */
@@ -4286,12 +4467,12 @@ export declare class Scene extends AbstractScene {
4286
4467
  /** Babylon.js fog-mode c
4287
4468
  get clearColor(): Color4;
4288
4469
  set clearColor(value: Color4);
4289
4470
  get activeCamera(): Camera | null;
4290
- set activeCamera(camera: Camera | null);
4291
4471
  /** Image-processing exposure proxy (Babylon.js `imageProcessingConfiguration.exposure`). */
4292
- get imageProcessingConfiguration(): {
4293
- exposure: number;
4294
- contrast: number;
4295
- toneMappingEnabled: boolean;
4296
- };
4472
+ set activeCamera(camera: Camera | null);
4297
4473
  /** Babylon.js image-processing facade over the scene's Lite state. */
4474
+ get imageProcessingConfiguration(): ImageProcessingConfiguration;
4475
+ get fluidRenderer(): FluidRenderer | null;
4476
+ set fluidRenderer(value: FluidRenderer | null);
4477
+ enableFluidRenderer(): FluidRenderer | null;
4478
+ disableFluidRenderer(): void;
4298
4479
  /** Babylon.js `scene.performancePriority` — accepted for parity; Babylon Lite tunes its own pipeline. */
4299
4480
  performancePriority: number;
4300
4481
  /**
@@ -4395,10 +4576,15 @@ export declare class Scene extends AbstractScene {
4395
4576
  /** Babylon.js fog-mode c
4396
4577
  whenReadyAsync(): Promise<void>;
4397
4578
  /** Babylon.js synchronous readiness check — always ready in the compat layer. */
4398
4579
  isReady(): boolean;
4399
- /** Synchronous CPU picking — unsupported. Babylon Lite uses async GPU picking. */
4400
- pick(): never;
4580
+ /** Babylon.js synchronous screen-coordinate picking over Lite's CPU ray picker. */
4581
+ 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;
4582
+ /**
4583
+ * Babylon.js `Scene.createPickingRay` — translate CSS coordinates and camera
4584
+ * transforms into Lite's reverse-Z unprojection helper.
4585
+ */
4586
+ createPickingRay(x: number, y: number, world?: Matrix | null, camera?: Camera | null, cameraViewSpace?: boolean): Ray;
4401
4587
  /** 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
4588
  /**
4589
+ pickWithRay(ray: Ray, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
4404
4590
  /**
4405
4591
  * Babylon.js `scene.enablePhysics(gravity, plugin)`. Wires the given Havok V2
4406
4592
  * {@link HavokPlugin} to this scene, creating the native Lite physics world and
4407
4593
  * registering per-frame stepping. The plugin's `useDeltaForWorldStep` flag
@@ -4499,7 +4685,11 @@ export declare class ShaderMaterial {
4499
4685
  export declare class ShadowGenerator {
4500
4686
  private readonly _mapSize;
4501
4687
  private readonly _light;
4502
- private readonly _casters;
4503
4688
  getClassName(): string;
4689
+ private readonly _casters;
4690
+ private readonly _casterDisposeObservers;
4691
+ private _casterSyncScheduled;
4692
+ private _casterSyncDirty;
4693
+ private readonly _disposeBeforeRenderFlush;
4504
4694
  getClassName(): string;
4505
4695
  /** Percentage-closer filtering. */
4506
4696
  usePercentageCloserFiltering: boolean;
4507
4697
  /** Contact-hardening (treated as PCF here). */
@@ -4524,9 +4714,14 @@ export declare class ShadowGenerator {
4524
4714
  orthoMaxZ: number | undefined;
4525
4715
  constructor(mapSize: number, light: Light);
4526
4716
  /** Babylon.js `addShadowCaster(mesh, includeDescendants?)`. */
4527
- addShadowCaster(mesh: AbstractMesh, _includeDescendants?: boolean): ShadowGenerator;
4528
- /** Babylon.js `removeShadowCaster(mesh)`. */
4529
- removeShadowCaster(mesh: AbstractMesh): ShadowGenerator;
4717
+ addShadowCaster(mesh: AbstractMesh, includeDescendants?: boolean): ShadowGenerator;
4718
+ /** Babylon.js `removeShadowCaster(mesh, includeDescendants?)`. */
4719
+ removeShadowCaster(mesh: AbstractMesh, includeDescendants?: boolean): ShadowGenerator;
4720
+ private _casterTree;
4721
+ private _detachCasterDisposeObserver;
4722
+ private _removeCaster;
4723
+ private _scheduleCasterSync;
4724
+ private _flushCasterSync;
4530
4725
  /** Babylon.js `getShadowMap()` — returns a minimal render-list holder for parity. */
4531
4726
  getShadowMap(): {
4532
4727
  renderList: AbstractMesh[];
@@ -5023,6 +5218,8 @@ export declare class TargetCamera extends Camera {
5023
5218
  constructor(name: string,
5024
5219
 
5025
5220
  declare type TaskState = "init" | "running" | "done" | "error";
5026
5221
 
5222
+ export declare function TemperatureTintToXyz(_temperatureKelvin: number, _tint: number): Vector3;
5223
+
5027
5224
  export declare class Texture extends BaseTexture {
5028
5225
  private readonly _ready;
5029
5226
  private _onLoadObservable;
@@ -5179,8 +5376,7 @@ export declare class TransformNode extends Node_2 {
5179
5376
  physicsBody: PhysicsBody
5180
5377
  * setter, which keeps the local transform and lets the world move.
5181
5378
  */
5182
5379
  setParent(parent: Node_2 | null): TransformNode;
5183
- protected _applyParent(parent: Node_2 | null): void;
5184
- }
5380
+ protected _applyParent(parent: Node_2 | null): void;
5185
5381
 
5186
5382
  export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
5187
5383
 
@@ -5206,6 +5402,60 @@ export declare function UploadHtmlElementToTexture(): never;
5206
5402
  */
5207
5403
  export declare function UploadImageToTexture2DArrayLayer(texture: RawTexture2DArray, source: ImageSource, layer: number, options?: IUploadImageToTexture2DArrayLayerOptions): void;
5208
5404
 
5405
+ export declare type USDBinaryInput = ArrayBuffer | ArrayBufferView;
5406
+
5407
+ export declare class USDFileLoader {
5408
+ constructor(_options?: Partial<USDFileLoaderOptions>);
5409
+ }
5410
+
5411
+ export declare interface USDFileLoaderOptions {
5412
+ rootFileName?: string;
5413
+ files?: USDVirtualFiles;
5414
+ resolveByFileName?: boolean;
5415
+ workerUrl?: string | URL;
5416
+ glueUrl?: string;
5417
+ wasmUrl?: string;
5418
+ dataUrl?: string;
5419
+ onProgress?: (progress: USDLoadProgress) => void;
5420
+ onLog?: (level: "info" | "warning" | "error", message: string) => void;
5421
+ onComplete?: (diagnostics: USDImportDiagnostics) => void;
5422
+ }
5423
+
5424
+ export declare interface USDImportDiagnostics {
5425
+ timings: USDImportTimings;
5426
+ statistics: USDImportStatistics;
5427
+ missingAssets: readonly string[];
5428
+ }
5429
+
5430
+ export declare interface USDImportStatistics {
5431
+ nodes: number;
5432
+ meshes: number;
5433
+ analyticPrimitives: number;
5434
+ instances: number;
5435
+ materials: number;
5436
+ vertices: number;
5437
+ triangles: number;
5438
+ commandBytes: number;
5439
+ dataBytes: number;
5440
+ }
5441
+
5442
+ export declare interface USDImportTimings {
5443
+ totalMs: number;
5444
+ stageOpenMs: number;
5445
+ stageReadMs: number;
5446
+ preparationMs: number;
5447
+ packingMs: number;
5448
+ heapCopyMs: number;
5449
+ materializeMs: number;
5450
+ }
5451
+
5452
+ export declare interface USDLoadProgress {
5453
+ phase: "initializing" | "staging" | "extracting" | "materializing";
5454
+ message: string;
5455
+ }
5456
+
5457
+ export declare type USDVirtualFiles = Readonly<Record<string, USDBinaryInput>>;
5458
+
5209
5459
  /** Babylon.js `UtilityLayerRenderer` — the overlay scene gizmos render into. */
5210
5460
  export declare class UtilityLayerRenderer {
5211
5461
  private _registered;
5212
5462
  constructor(scene: Scene);
5213
5463
  dispose(): void;
@@ -5318,6 +5568,10 @@ export declare class Vector3 {
5318
5568
  static NormalizeToRef<T extends Vector3>(vector: Vector3, result: T): T;
5319
5569
  static Minimize(a: Vector3, b: Vector3): Vector3;
5320
5570
  static Maximize(a: Vector3, b: Vector3): Vector3;
5571
+ /** Project a world-space point into a Babylon.js viewport. */
5572
+ static Project(vector: Vector3, world: Matrix, transform: Matrix, viewport: Viewport): Vector3;
5573
+ /** Project a world-space point into a Babylon.js viewport, writing into `result`. */
5574
+ static ProjectToRef<T extends Vector3>(vector: Vector3, world: Matrix, transform: Matrix, viewport: Viewport, result: T): T;
5321
5575
  /** Transform a coordinate (point) by a matrix using the row-vector convention. */
5322
5576
  static TransformCoordinates(vector: Vector3, transformation: Matrix): Vector3;
5323
5577
  /** Transform a coordinate (point) by a matrix using the row-vector convention. */