@babylonjs/lite-compat 1.8.0-preview → 1.9.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/README.md CHANGED
@@ -114,26 +114,27 @@ overloads within a supported area may still be absent.
114
114
 
115
115
  ### `@babylonjs/core`
116
116
 
117
- | Feature area | Status | Notes |
118
- | ------------------------------------------------------------------------------------------------------- | :----: | -------------------------------------------------------------------------------------------------------- |
119
- | Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`) | ✅ | `Angle` / `Curve3` / `Path3D` partial |
120
- | Engine (`WebGPUEngine`, `Engine`, `ThinEngine`, `NullEngine`) | ⚡ | async startup + render loop; `beginFrame`/`endFrame` and manual `scene.render()` unsupported |
121
- | Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | sync `scene.pick` unsupported (use async `GPUPicker`); some scene enumeration needs Lite core |
122
- | Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`) | ✅ | XR / device-orientation / stereoscopic rigs unsupported |
123
- | Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `RectAreaLight` / clustered lights unsupported |
124
- | Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` falls back to single cascade |
125
- | Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `VertexData`) | ⚡ | `CreateLines`/`CreateDecal`/`CreateText`, `InstancedMesh`, LOD/edges/outline, clone/instance unsupported |
126
- | CSG / CSG2 | ✅ | over Lite boolean ops |
127
- | Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`) | ⚡ | over Lite gizmo suite |
128
- | Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `ShaderMaterial` (GLSL), `MultiMaterial`, `BackgroundMaterial` unsupported |
129
- | Textures (`Texture`, `RawTexture`, `DynamicTexture`, `CubeTexture`) | ⚡ | `HDRCubeTexture` / `RenderTargetTexture` / `MirrorTexture` / `HtmlTexture` unsupported |
130
- | Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | CPU evaluation; loaded glTF skeletal blending supported |
131
- | Morph targets (`MorphTarget` / `MorphTargetManager`) | ✅ | over Lite morph targets |
132
- | Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported |
133
- | Behaviors / Actions (`AutoRotation`, `Framing`, `ActionManager`, conditions) | ⚡ | `ActionManager` is manual-dispatch; drag behaviors need Lite core |
134
- | Misc (`Observable`, `Tools`, `SmartArray`, `Tags`, gradients, `PerformanceMonitor`) | ✅ | |
135
- | Audio V2 (`AudioEngineV2`, `StaticSound`, `StreamingSound`, `AudioBus`, buses/sources/analyzer) | ⚡ | over Lite's AudioV2 port; `MainAudioBus` spatial/analyzer and a second main bus unsupported |
136
- | Particles, post-processes, layers (glow/highlight), probes, physics, WebXR | ❌ | not in Babylon Lite — use native Lite `create*Task` / Havok-V2 functions |
117
+ | Feature area | Status | Notes |
118
+ | --------------------------------------------------------------------------------------------------------- | :----: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
119
+ | Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`) | ✅ | `Angle` / `Curve3` / `Path3D` partial |
120
+ | Engine (`WebGPUEngine`, `Engine`, `ThinEngine`, `NullEngine`) | ⚡ | async startup + render loop; `beginFrame`/`endFrame` and manual `scene.render()` unsupported |
121
+ | Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | sync `scene.pick` unsupported (use async `GPUPicker`); some scene enumeration needs Lite core |
122
+ | Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`) | ✅ | XR / device-orientation / stereoscopic rigs unsupported |
123
+ | Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `RectAreaLight` / clustered lights unsupported |
124
+ | Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` falls back to single cascade |
125
+ | Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `VertexData`) | ⚡ | `CreateLines`/`CreateDecal`/`CreateText`, `InstancedMesh`, LOD/edges/outline, clone/instance unsupported |
126
+ | CSG / CSG2 | ✅ | over Lite boolean ops |
127
+ | Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`) | ⚡ | over Lite gizmo suite; `isEnabled` toggles per-axis interactivity (display-only when disabled) |
128
+ | Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `ShaderMaterial` (GLSL), `MultiMaterial`, `BackgroundMaterial` unsupported |
129
+ | Textures (`Texture`, `RawTexture`, `RawTexture3D`, `DynamicTexture`, `CubeTexture`, `HDRCubeTexture`) | ⚡ | `HDRCubeTexture` routes to native `loadHdrEnvironment`; `RenderTargetTexture` / `MirrorTexture` / `HtmlTexture` unsupported |
130
+ | Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | CPU evaluation; loaded glTF skeletal blending supported |
131
+ | Morph targets (`MorphTarget` / `MorphTargetManager`) | ✅ | over Lite morph targets |
132
+ | Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported |
133
+ | Behaviors / Actions (`AutoRotation`, `Framing`, `ActionManager`, conditions) | ⚡ | `ActionManager` is manual-dispatch; drag behaviors need Lite core |
134
+ | Misc (`Observable`, `Tools`, `SmartArray`, `Tags`, gradients, `PerformanceMonitor`) | ✅ | |
135
+ | Audio V2 (`AudioEngineV2`, `StaticSound`, `StreamingSound`, `AudioBus`, buses/sources/analyzer) | ⚡ | over Lite's AudioV2 port; `MainAudioBus` spatial/analyzer and a second main bus unsupported |
136
+ | Physics (`HavokPlugin`, `scene.enablePhysics`/`getPhysicsEngine`, `PhysicsShapeType`/`PhysicsMotionType`) | ⚡ | Havok V2 over Lite `createHavokWorld`; refresh-rate-independent `useDeltaForWorldStep`. Bodies via native `createPhysicsAggregate` (`PhysicsAggregate` class not wrapped) |
137
+ | Particles, post-processes, layers (glow/highlight), probes, WebXR | ❌ | not in Babylon Lite — use native Lite `create*Task` functions |
137
138
 
138
139
  ### `@babylonjs/loaders`
139
140
 
package/index.d.ts CHANGED
@@ -7,6 +7,7 @@ import { EngineContext } from '@babylonjs/lite';
7
7
  import { EngineOptions } from '@babylonjs/lite';
8
8
  import { IridescenceProps } from '@babylonjs/lite';
9
9
  import { Mesh as Mesh_2 } from '@babylonjs/lite';
10
+ import { PhysicsWorld } from '@babylonjs/lite';
10
11
  import { RenderCanvas } from '@babylonjs/lite';
11
12
  import { SceneNode } from '@babylonjs/lite';
12
13
  import { SheenProps } from '@babylonjs/lite';
@@ -855,7 +856,11 @@ export declare const Axis: {
855
856
 
856
857
  /** Babylon.js `AxisDragGizmo` — drags the attached node along a single world axis. */
857
858
  export declare class AxisDragGizmo extends GizmoBase {
858
859
  private _attached;
859
- constructor(dragAxis: Vector3, color: Color3, layer: UtilityLayerRenderer);
860
+ constructor(dragAxis: Vector3, color: Color3, layer: UtilityLayerRenderer);
860
861
  /** Babylon.js `IAxisDragGizmo.isEnabled` — when false the gizmo is non-interactive
862
+ * (no drag, and no GPU hover picking), while its meshes stay visible and keep
863
+ * following the attached node. Toggles the underlying Lite pointer-drag. */
864
+ get isEnabled(): boolean;
865
+ set isEnabled(value: boolean);
861
866
  get attachedMesh(): AbstractMesh | null;
862
867
  set attachedMesh(value: AbstractMesh | null);
863
868
  get attachedNode(): Node_2 | null;
@@ -865,7 +870,9 @@ export declare class AxisDragGizmo extends GizmoBase {
865
870
  private _attached;
866
871
 
867
872
  /** Babylon.js `AxisScaleGizmo` — scales the attached node along a single axis. */
868
873
  export declare class AxisScaleGizmo extends GizmoBase {
869
874
  private _attached;
870
- constructor(dragAxis: Vector3, color: Color3, layer: UtilityLayerRenderer);
875
+ constructor(dragAxis: Vector3, color: Color3, layer: UtilityLayerRenderer);
871
876
  /** Babylon.js `IAxisScaleGizmo.isEnabled` — toggles interactivity (drag + hover pick). */
877
+ get isEnabled(): boolean;
878
+ set isEnabled(value: boolean);
872
879
  get attachedMesh(): AbstractMesh | null;
873
880
  set attachedMesh(value: AbstractMesh | null);
874
881
  get attachedNode(): Node_2 | null;
@@ -1256,8 +1263,7 @@ export declare class CubeTexture {
1256
1263
  coordinatesMode: number;
1257
1264
  name: string;
1258
1265
  gammaSpace: boolean;
1259
- level: number;
1260
- /** Fires when the cube map is "ready" (resolved on a microtask in this compat layer). */
1266
+ level: number;
1261
1267
  /** Fires when the cube map is "ready" (resolved on a microtask in this compat layer). */
1262
1268
  readonly onLoadObservable: Observable<CubeTexture>;
1263
1269
  private _ready;
1264
1270
  constructor(url: string, _scene?: unknown, _extensions?: unknown, _noMipmap?: boolean, _files?: unknown, onLoad?: (() => void) | null, _onError?: unknown, _format?: unknown, _prefiltered?: boolean);
@@ -1686,13 +1692,73 @@ declare interface GroundOptions {
1686
1692
  subdivisions?: number;
1687
1693
  }
1688
1694
 
1695
+ /**
1696
+ * Babylon.js-shaped Havok V2 physics plugin, backed by Babylon Lite's native
1697
+ * `createHavokWorld` API.
1698
+ *
1699
+ * Construct it exactly as in Babylon.js and pass it to {@link Scene.enablePhysics}:
1700
+ * ```ts
1701
+ * const hknp = await HavokPhysics();
1702
+ * scene.enablePhysics(new Vector3(0, -9.81, 0), new HavokPlugin(true, hknp));
1703
+ * ```
1704
+ *
1705
+ * The first constructor argument, `useDeltaForWorldStep` (default `true`,
1706
+ * matching Babylon.js), selects delta-driven stepping: the world advances by the
1707
+ * elapsed real time each frame, so the simulation runs at the same real-time
1708
+ * speed regardless of the display refresh rate (issue #332). Pass `false` for the
1709
+ * legacy fixed `1/60`-per-frame behaviour.
1710
+ *
1711
+ * Bodies are still created with the native `createPhysicsAggregate` /
1712
+ * `createPhysicsBody` API against {@link world}; the Babylon.js `PhysicsAggregate`
1713
+ * class is not wrapped.
1714
+ */
1689
1715
  export declare class HavokPlugin {
1690
- constructor();
1691
- }
1716
+ /** Name of the plugin. */
1717
+ readonly name: string;
1692
1718
  /** The native Lite physics world, created when the plugin is attached to a scene. */
1719
+ world: PhysicsWorld | null;
1693
1720
  constructor(useDeltaForWorldStep?: boolean, hpInjection?: unknown);
1721
+ /** Whether the plugin has a usable Havok module. */
1722
+ isSupported(): boolean;
1723
+ /** Babylon.js physics plugin version (Havok is V2). */
1724
+ getPluginVersion(): number;
1725
+ /** Set the fixed timestep used when delta stepping is disabled. Matches Babylon.js. */
1726
+ setTimeStep(timeStep: number): void;
1727
+ /** Get the fixed timestep. Matches Babylon.js. */
1728
+ getTimeStep(): number;
1729
+ /** Set the world gravity. */
1730
+ setGravity(gravity: Vec3Like, worldPosition?: Vec3Like): void;
1731
+ /**
1732
+ * Manual single-step entry point. Babylon Lite drives world stepping
1733
+ * internally (once per rendered frame, via the scene's before-render hook),
1734
+ * so calling this directly is unsupported — use {@link Scene.enablePhysics}.
1735
+ */
1736
+ executeStep(): never;
1737
+ /** Release the native physics world. */
1738
+ dispose(): void;
1694
1739
 
1695
- /** Babylon.js `HDRCubeTexture` — see {@link CubeTexture}; use native `loadHdrEnvironment`. */
1740
+ /**
1741
+ * Babylon.js `HDRCubeTexture` — a Radiance `.hdr` (RGBE) equirectangular panorama
1742
+ * used as an environment / IBL source. Like {@link CubeTexture} this is a
1743
+ * lightweight handle that records the `.hdr` URL; the actual GPU work (equirect →
1744
+ * prefiltered cubemap + irradiance SH + BRDF LUT) happens when it is assigned to
1745
+ * `scene.environmentTexture` and the engine starts, at which point the scene
1746
+ * routes it through Babylon Lite's native `loadHdrEnvironment`.
1747
+ */
1696
1748
  export declare class HDRCubeTexture {
1697
- constructor();
1749
+ /** Source URL of the `.hdr` panorama. */
1750
+ readonly url: string;
1751
+ /** Requested cubemap face size (BJS `size`); forwarded to Lite's `faceSize`. */
1752
+ readonly size: number;
1753
+ /** Babylon.js `coordinatesMode` (skybox = 5). Recorded for API parity. */
1754
+ coordinatesMode: number;
1755
+ name: string;
1756
+ gammaSpace: boolean;
1757
+ level: number;
1698
1758
  /** Fires when the HDR environment is "ready" (resolved on a microtask). */
1759
+ readonly onLoadObservable: Observable<HDRCubeTexture>;
1760
+ private _ready;
1761
+ constructor(url: string, _sceneOrEngine?: unknown, size?: number, _noMipmap?: boolean, _generateHarmonics?: boolean, _gammaSpace?: boolean, _prefilterOnLoad?: boolean, onLoad?: (() => void) | null);
1762
+ /** Babylon.js `BaseTexture.isReady()`. */
1763
+ isReady(): boolean;
1764
+ dispose(): void;
1699
1765
  }
1700
1766
 
1701
1767
  export declare class HemisphericLight extends Light {
1702
1768
  constructor(name: string, direction: Vector3, scene?: Scene);
@@ -2408,22 +2474,28 @@ declare class NodeMaterialBlockProxy {
2408
2474
 
2409
2475
  /**
2410
2476
  * Babylon.js's `NullEngine` — a headless engine with no GPU device, used to run
2411
- * scene logic (animations, observables, frame timing) without rendering. Babylon
2412
- * Lite has no headless context, so the compat `NullEngine` builds nothing on the
2413
- * GPU: it drives a pure-JS `requestAnimationFrame` loop that advances each scene's
2414
- * CPU animations and fires its before/after-render observables. Scenes constructed
2415
- * against it skip the Lite scene-context build (see `Scene`'s headless branch), so
2416
- * only the deviceless surface (CPU animations, manual 2D-canvas drawing, etc.)
2417
- * works — there is no WebGPU rendering. Extends {@link WebGPUEngine} so it is
2418
- * accepted everywhere a compat engine is (e.g. `new Scene(engine)`).
2477
+ * scene logic (animations, observables, physics stepping, frame timing) without
2478
+ * rendering. Backed by Babylon Lite's real device-less headless engine
2479
+ * (`createNullEngine`): scenes constructed against it build a Lite scene context
2480
+ * with **no** frame-graph render task (`defaultRenderTask: false`), so no swapchain
2481
+ * or GPU resource is ever allocated. The compat `NullEngine` drives a pure-JS
2482
+ * `requestAnimationFrame` loop that advances each scene by the wall-clock delta
2483
+ * between frames via Lite's `stepScene` (which fires the scene's `onBeforeRender`
2484
+ * callbacks — CPU animations,
2485
+ * physics steps, user logic). Only the device-less simulation surface works; adding
2486
+ * meshes with materials (whose deferred GPU builders need a device) is unsupported,
2487
+ * matching Babylon.js's `NullEngine` limitations. Extends {@link WebGPUEngine} so it
2488
+ * is accepted everywhere a compat engine is (e.g. `new Scene(engine)`).
2419
2489
  */
2420
2490
  export declare class NullEngine extends WebGPUEngine {
2421
2491
  constructor();
2422
2492
  /** No GPU device to acquire. */
2423
2493
  initAsync(): Promise<void>;
2424
2494
  /**
2425
- * Drive a pure-JS frame loop: each tick advances every registered scene's CPU
2426
- * animations + render observables, then runs the user callback(s). No GPU work.
2495
+ * Drive a pure-JS frame loop: each tick advances every registered scene by the
2496
+ * wall-clock delta between frames through Lite's `stepScene` (which fires the scene's before-render
2497
+ * callbacks: CPU animations, physics, render observables), then runs the user
2498
+ * callback(s). No GPU work is recorded or submitted.
2427
2499
  */
2428
2500
  runRenderLoop(callback: () => void): void;
2429
2501
 
@@ -2592,10 +2664,10 @@ export declare class PBRMaterial extends PushMaterial {
2592
2664
  constructor(name: st
2593
2665
  * environment assigned to a material is routed to the owning scene's
2594
2666
  * environment (the dominant single-IBL case Babylon.js scenes use).
2595
2667
  */
2596
- get environmentTexture(): CubeTexture | null;
2597
- set environmentTexture(value: CubeTexture | null);
2598
- get reflectionTexture(): CubeTexture | null;
2599
- set reflectionTexture(value: CubeTexture | null);
2668
+ get environmentTexture(): CubeTexture | HDRCubeTexture | null;
2669
+ set environmentTexture(value: CubeTexture | HDRCubeTexture | null);
2670
+ get reflectionTexture(): CubeTexture | HDRCubeTexture | null;
2671
+ set reflectionTexture(value: CubeTexture | HDRCubeTexture | null);
2600
2672
 
2601
2673
  /**
2602
2674
  * Babylon.js `PBRMetallicRoughnessMaterial` — a simplified façade over
@@ -2667,10 +2739,69 @@ export declare class PhysicsBody {
2667
2739
  constructor();
2668
2740
  }
2669
2741
 
2742
+ /** Type of a Physics V2 constraint. Values match Babylon.js `PhysicsConstraintType`. */
2743
+ export declare enum PhysicsConstraintType {
2744
+ BALL_AND_SOCKET = 1,
2745
+ DISTANCE = 2,
2746
+ HINGE = 3,
2747
+ SLIDER = 4,
2748
+ LOCK = 5,
2749
+ PRISMATIC = 6,
2750
+ SIX_DOF = 7
2751
+ }
2752
+
2753
+ /**
2754
+ * Babylon.js-shaped Physics V2 engine wrapper returned by
2755
+ * {@link Scene.getPhysicsEngine}. Holds the active {@link HavokPlugin} and the
2756
+ * world gravity, exposing the common Babylon.js `IPhysicsEngine` surface.
2757
+ */
2758
+ export declare class PhysicsEngine {
2670
2759
  /** Current world gravity. */
2760
+ gravity: Vec3Like;
2761
+ constructor(plugin: HavokPlugin, gravity: Vec3Like);
2762
+ /** The underlying physics plugin. */
2763
+ getPhysicsPlugin(): HavokPlugin;
2764
+ /** Physics engine plugin version (Havok is V2). */
2765
+ getPluginVersion(): number;
2766
+ /** Set the world gravity. */
2767
+ setGravity(gravity: Vec3Like): void;
2768
+ /** Set the fixed timestep. */
2769
+ setTimeStep(newTimeStep: number): void;
2770
+ /** Get the fixed timestep. */
2771
+ getTimeStep(): number;
2772
+ /** Release the underlying physics world. */
2773
+ dispose(): void;
2774
+ }
2775
+
2776
+ /** How a body moves. Values match Babylon.js `PhysicsMotionType`. */
2777
+ export declare enum PhysicsMotionType {
2778
+ STATIC = 0,
2779
+ ANIMATED = 1,
2780
+ DYNAMIC = 2
2781
+ }
2782
+
2783
+ /** How a moved transform node is propagated to its body before each step. Values match Babylon.js `PhysicsPrestepType`. */
2784
+ export declare enum PhysicsPrestepType {
2785
+ DISABLED = 0,
2786
+ TELEPORT = 1,
2787
+ ACTION = 2
2788
+ }
2789
+
2671
2790
  export declare class PhysicsShape {
2672
2791
  constructor();
2673
2792
  }
2674
2793
 
2794
+ /** The type of a Havok physics collision shape. Values match Babylon.js `PhysicsShapeType`. */
2795
+ export declare enum PhysicsShapeType {
2796
+ SPHERE = 0,
2797
+ CAPSULE = 1,
2798
+ CYLINDER = 2,
2799
+ BOX = 3,
2800
+ CONVEX_HULL = 4,
2801
+ CONTAINER = 5,
2802
+ MESH = 6,
2803
+ HEIGHTFIELD = 7
2804
+ }
2805
+
2675
2806
  /** A pickable compat mesh: a regular `Mesh` or a `GaussianSplattingMesh`. */
2676
2807
  declare type PickableMesh = Mesh | GaussianSplattingMesh;
2677
2808
 
@@ -2699,7 +2830,9 @@ export declare class Plane {
2699
2830
 
2700
2831
  /** Babylon.js `PlaneDragGizmo` — drags the attached node within a plane. */
2701
2832
  export declare class PlaneDragGizmo extends GizmoBase {
2702
2833
  private _attached;
2703
- constructor(dragPlaneNormal: Vector3, color: Color3, layer: UtilityLayerRenderer);
2834
+ constructor(dragPlaneNormal: Vector3, color: Color3, layer: UtilityLayerRenderer);
2704
2835
  /** Babylon.js `IPlaneDragGizmo.isEnabled` — toggles interactivity (drag + hover pick). */
2836
+ get isEnabled(): boolean;
2837
+ set isEnabled(value: boolean);
2705
2838
  get attachedMesh(): AbstractMesh | null;
2706
2839
  set attachedMesh(value: AbstractMesh | null);
2707
2840
  get attachedNode(): Node_2 | null;
@@ -2715,7 +2848,9 @@ declare interface PlaneOptions {
2715
2848
 
2716
2849
  /** Babylon.js `PlaneRotationGizmo` — rotates the attached node about a plane normal. */
2717
2850
  export declare class PlaneRotationGizmo extends GizmoBase {
2718
2851
  private _attached;
2719
- constructor(planeNormal: Vector3, color: Color3, layer: UtilityLayerRenderer);
2852
+ constructor(planeNormal: Vector3, color: Color3, layer: UtilityLayerRenderer);
2720
2853
  /** Babylon.js `IPlaneRotationGizmo.isEnabled` — toggles interactivity (drag + hover pick). */
2854
+ get isEnabled(): boolean;
2855
+ set isEnabled(value: boolean);
2721
2856
  get attachedMesh(): AbstractMesh | null;
2722
2857
  set attachedMesh(value: AbstractMesh | null);
2723
2858
  get attachedNode(): Node_2 | null;
@@ -2742,7 +2877,16 @@ export declare class PointsCloudSystem {
2742
2877
  }
2743
2878
 
2744
2879
  export declare class PositionGizmo extends GizmoBase {
2745
2880
  private _attached;
2881
+ private _xGizmo;
2882
+ private _yGizmo;
2883
+ private _zGizmo;
2746
2884
  constructor(layer: UtilityLayerRenderer);
2885
+ /** Babylon.js `PositionGizmo.xGizmo/yGizmo/zGizmo` — the per-axis drag sub-gizmos.
2886
+ * Exposed so callers can toggle interactivity per axis (e.g. `xGizmo.isEnabled = false`
2887
+ * for a display-only gizmo). Wrappers are cached so identity is stable. */
2888
+ get xGizmo(): AxisDragGizmo;
2889
+ get yGizmo(): AxisDragGizmo;
2890
+ get zGizmo(): AxisDragGizmo;
2747
2891
  /** Babylon.js `Gizmo.updateGizmoRotationToMatchAttachedMesh` — orient widgets to the node's local axes. */
2748
2892
  set updateGizmoRotationToMatchAttachedMesh(value: boolean);
2749
2893
  get attachedMesh(): AbstractMesh | null;
@@ -2841,6 +2985,40 @@ export declare class RawTexture extends BaseTexture {
2841
2985
  static CreateRGBATexture(data: Uint8Array, width: number, height: number, scene: Scene): RawTexture;
2842
2986
  }
2843
2987
 
2988
+ /**
2989
+ * Babylon.js `RawTexture3D` — a volumetric texture created from raw RGBA8 pixel
2990
+ * bytes (the common case being a colour-grading LUT / colour cube). Backed by
2991
+ * Babylon Lite's `createTexture3DFromPixels`; the GPU handle is available
2992
+ * synchronously after construction.
2993
+ *
2994
+ * Babylon Lite's 3D-texture path is RGBA8-only, so the `format` argument is
2995
+ * recorded for API parity but the upload always treats `data` as tightly-packed
2996
+ * `width * height * depth * 4` RGBA bytes (x fastest, then y, then z).
2997
+ */
2998
+ export declare class RawTexture3D extends BaseTexture {
2999
+ /** Babylon.js texture format (recorded for parity; Lite uploads RGBA8). */
3000
+ format: number;
3001
+ private readonly _scene;
3002
+ /** Babylon.js `RawTexture3D.is3D` — always true for a 3D texture. */
3003
+ readonly is3D = true;
3004
+ constructor(data: ArrayBufferView | null, width: number, height: number, depth: number,
3005
+ /** Babylon.js texture format (recorded for parity; Lite uploads RGBA8). */
3006
+ format: number, scene: Scene, _generateMipMaps?: boolean, _invertY?: boolean, _samplingMode?: number, _textureType?: number, _creationFlags?: number);
3007
+ getClassName(): string;
3008
+ /** Gets the width of the texture. */
3009
+ get width(): number;
3010
+ /** Gets the height of the texture. */
3011
+ get height(): number;
3012
+ /** Gets the depth of the texture. */
3013
+ get depth(): number;
3014
+ /**
3015
+ * Replace the texture's pixel contents. Babylon Lite has no in-place 3D update,
3016
+ * so the volume is re-uploaded (a fresh Lite 3D texture handle).
3017
+ */
3018
+ update(data: ArrayBufferView): void;
3019
+ whenReadyAsync(): Promise<void>;
3020
+ }
3021
+
2844
3022
  export declare class Ray {
2845
3023
  origin: Vector3;
2846
3024
  direction: Vector3;
@@ -2873,7 +3051,14 @@ export declare class RenderTargetTexture {
2873
3051
  }
2874
3052
 
2875
3053
  export declare class RotationGizmo extends GizmoBase {
2876
3054
  private _attached;
3055
+ private _xGizmo;
3056
+ private _yGizmo;
3057
+ private _zGizmo;
2877
3058
  constructor(layer: UtilityLayerRenderer);
3059
+ /** Babylon.js `RotationGizmo.xGizmo/yGizmo/zGizmo` — the per-plane rotation sub-gizmos. */
3060
+ get xGizmo(): PlaneRotationGizmo;
3061
+ get yGizmo(): PlaneRotationGizmo;
3062
+ get zGizmo(): PlaneRotationGizmo;
2878
3063
  /** Babylon.js `Gizmo.updateGizmoRotationToMatchAttachedMesh` — orient widgets to the node's local axes. */
2879
3064
  set updateGizmoRotationToMatchAttachedMesh(value: boolean);
2880
3065
  get attachedMesh(): AbstractMesh | null;
@@ -2896,7 +3081,14 @@ export declare const Scalar: {
2896
3081
  };
2897
3082
 
2898
3083
  export declare class ScaleGizmo extends GizmoBase {
2899
3084
  private _attached;
3085
+ private _xGizmo;
3086
+ private _yGizmo;
3087
+ private _zGizmo;
2900
3088
  constructor(layer: UtilityLayerRenderer);
3089
+ /** Babylon.js `ScaleGizmo.xGizmo/yGizmo/zGizmo` — the per-axis scale sub-gizmos. */
3090
+ get xGizmo(): AxisScaleGizmo;
3091
+ get yGizmo(): AxisScaleGizmo;
3092
+ get zGizmo(): AxisScaleGizmo;
2901
3093
  /** Babylon.js `Gizmo.updateGizmoRotationToMatchAttachedMesh` — orient widgets to the node's local axes. */
2902
3094
  set updateGizmoRotationToMatchAttachedMesh(value: boolean);
2903
3095
  get attachedMesh(): AbstractMesh | null;
@@ -3021,8 +3213,8 @@ export declare class Scene extends AbstractScene {
3021
3213
  /** Babylon.js fog-mode c
3022
3214
  */
3023
3215
  get clipPlane(): Plane | null;
3024
3216
  set clipPlane(value: Plane | null);
3025
- get environmentTexture(): CubeTexture | null;
3026
- set environmentTexture(value: CubeTexture | null);
3217
+ get environmentTexture(): CubeTexture | HDRCubeTexture | null;
3218
+ set environmentTexture(value: CubeTexture | HDRCubeTexture | null);
3027
3219
  /**
3028
3220
  * Babylon.js `scene.createDefaultEnvironment` — adds an IBL skybox and ground.
3029
3221
  * Babylon Lite performs this through `loadEnvironment` (deferred to engine start),
@@ -3038,7 +3230,7 @@ export declare class Scene extends AbstractScene {
3038
3230
  /** Babylon.js fog-mode c
3039
3231
  * loaded `.env` specular cubemap as an HDR skybox, so this records the env URL (if
3040
3232
  * not already set) and flags a skybox-from-environment load at engine start.
3041
3233
  */
3042
- createDefaultSkybox(texture?: CubeTexture, _pbr?: boolean, scale?: number, _blur?: number, _setGlobalEnv?: boolean): {
3234
+ createDefaultSkybox(texture?: CubeTexture | HDRCubeTexture, _pbr?: boolean, scale?: number, _blur?: number, _setGlobalEnv?: boolean): {
3043
3235
  dispose(): void;
3044
3236
  };
3045
3237
  /** Create and activate a default arc-rotate camera framing the scene. */
3046
3238
  createDefaultCamera(_createArcRotateCamera?: boolean, _replace?: boolean, _attachControl?: boolean): Camera;
@@ -3057,7 +3249,28 @@ export declare class Scene extends AbstractScene {
3057
3249
  /** Babylon.js fog-mode c
3058
3250
  /** Synchronous CPU picking — unsupported. Babylon Lite uses async GPU picking. */
3059
3251
  pick(): never;
3060
3252
  /** Synchronous ray picking — unsupported. */
3061
- pickWithRay(): never;
3253
+ pickWithRay(): never;
3062
3254
  /**
3255
+ * Babylon.js `scene.enablePhysics(gravity, plugin)`. Wires the given Havok V2
3256
+ * {@link HavokPlugin} to this scene, creating the native Lite physics world and
3257
+ * registering per-frame stepping. The plugin's `useDeltaForWorldStep` flag
3258
+ * controls whether the world advances by elapsed frame time (refresh-rate
3259
+ * independent — issue #332) or a fixed `1/60` step.
3260
+ *
3261
+ * Bodies are created with the native `createPhysicsAggregate` /
3262
+ * `createPhysicsBody` API against `scene.getPhysicsEngine().getPhysicsPlugin().world`.
3263
+ * @returns `true` once physics is enabled.
3264
+ */
3265
+ enablePhysics(gravity?: {
3266
+ x: number;
3267
+ y: number;
3268
+ z: number;
3269
+ } | null, plugin?: HavokPlugin): boolean;
3270
+ /** Babylon.js `scene.getPhysicsEngine()` — the active Physics V2 engine, or `null`. */
3271
+ getPhysicsEngine(): PhysicsEngine | null;
3272
+ /** Babylon.js `scene.isPhysicsEnabled()`. */
3273
+ isPhysicsEnabled(): boolean;
3274
+ /** Babylon.js `scene.disablePhysicsEngine()` — release the active physics world. */
3275
+ disablePhysicsEngine(): void;
3063
3276
  /**
3064
3277
  * Babylon.js `scene.beginDirectAnimation(target, animations, from, to, loop, speedRatio?)`.
3065
3278
  * Drives the given `Animation`s on the CPU each frame, writing onto the target's
@@ -3792,6 +4005,13 @@ export declare const ValueConditionOperators: {
3792
4005
  readonly IsLesser: 3;
3793
4006
  };
3794
4007
 
4008
+ /** Minimal `{x, y, z}` view shared by the compat `Vector3` and Lite's `Vec3`. */
4009
+ declare interface Vec3Like {
4010
+ x: number;
4011
+ y: number;
4012
+ z: number;
4013
+ }
4014
+
3795
4015
  export declare class Vector2 {
3796
4016
  x: number;
3797
4017
  y: number;