@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 +21 -20
- package/index.d.ts +248 -28
- package/index.js +399 -32
- package/index.js.map +1 -1
- package/navigation.d.ts +129 -10
- package/package.json +4 -4
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
|
|
118
|
-
|
|
|
119
|
-
| Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`)
|
|
120
|
-
| Engine (`WebGPUEngine`, `Engine`, `ThinEngine`, `NullEngine`)
|
|
121
|
-
| Scene (clear color, cameras/lights, fog, environment, observables, ready state)
|
|
122
|
-
| Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`)
|
|
123
|
-
| Lights (`Hemispheric`, `Directional`, `Point`, `Spot`)
|
|
124
|
-
| Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF)
|
|
125
|
-
| Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `VertexData`)
|
|
126
|
-
| CSG / CSG2
|
|
127
|
-
| Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`)
|
|
128
|
-
| Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`)
|
|
129
|
-
| Textures (`Texture`, `RawTexture`, `DynamicTexture`, `CubeTexture`)
|
|
130
|
-
| Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend)
|
|
131
|
-
| Morph targets (`MorphTarget` / `MorphTargetManager`)
|
|
132
|
-
| Sprites (`SpriteManager` / `Sprite`)
|
|
133
|
-
| Behaviors / Actions (`AutoRotation`, `Framing`, `ActionManager`, conditions)
|
|
134
|
-
| Misc (`Observable`, `Tools`, `SmartArray`, `Tags`, gradients, `PerformanceMonitor`)
|
|
135
|
-
| Audio V2 (`AudioEngineV2`, `StaticSound`, `StreamingSound`, `AudioBus`, buses/sources/analyzer)
|
|
136
|
-
|
|
|
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
|
-
|
|
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
|
-
/**
|
|
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
|
-
|
|
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
|
|
2412
|
-
*
|
|
2413
|
-
*
|
|
2414
|
-
*
|
|
2415
|
-
*
|
|
2416
|
-
*
|
|
2417
|
-
*
|
|
2418
|
-
*
|
|
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
|
|
2426
|
-
*
|
|
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;
|