@babylonjs/lite-compat 1.31.1-preview → 1.33.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 +15 -15
- package/index.d.ts +228 -41
- package/index.js +533 -59
- package/index.js.map +1 -1
- package/{meshes-Fu955h5M.js → meshes-BLcUDvXV.js} +107 -8
- package/meshes-BLcUDvXV.js.map +1 -0
- package/navigation.d.ts +16 -6
- package/navigation.js +1 -1
- package/package.json +4 -4
- package/meshes-Fu955h5M.js.map +0 -1
package/README.md
CHANGED
|
@@ -119,17 +119,17 @@ overloads within a supported area may still be absent.
|
|
|
119
119
|
| ----------------------------------------------------------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
120
120
|
| Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`, color temperature/white balance) | ✅ | `Angle` / `Curve3` / `Path3D` partial |
|
|
121
121
|
| Engine (`WebGPUEngine`, `Engine`, `ThinEngine`, `NullEngine`) | ⚡ | async startup + render loop; `currentSampleCount` reports the active surface's MSAA count; `beginFrame`/`endFrame`, occlusion queries, engine-wide alpha-to-coverage, and manual `scene.render()` unsupported |
|
|
122
|
-
| Compute + GPU buffers (`ComputeShader`, `StorageBuffer`, `UniformBuffer`) | ⚡ | WGSL compute, direct/indirect dispatch, storage buffers, and compute-oriented std140 uniform buffers forward to Lite; shader registries/preprocessing, texture bindings, in-frame immediate dispatch, and Effect-oriented UBO methods remain unsupported
|
|
123
|
-
| Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | sync `scene.pick` forwards to Lite's CPU
|
|
122
|
+
| Compute + GPU buffers (`ComputeShader`, `StorageBuffer`, `UniformBuffer`) | ⚡ | WGSL compute, direct/indirect dispatch, storage buffers, and compute-oriented std140 uniform buffers forward to Lite; shader registries/preprocessing, texture bindings, in-frame immediate dispatch, and Effect-oriented UBO methods remain unsupported |
|
|
123
|
+
| Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | sync `scene.pick` forwards to Lite's CPU triangle picker with thin-instance, predicate, normal, and UV detail; actively deformed meshes still require async `GPUPicker`; `scene.meshes` + `getMeshBy*`/`getNodeBy*` enumerate every mesh via a canonical wrapper registry; exposure/contrast/tone mapping are forwarded, while white balance and fluid rendering throw because Lite lacks their cross-cutting shader/render-pass subsystems |
|
|
124
124
|
| Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`) | ✅ | arc controls include pointer, wheel, touch, and BJS-default Arrow-key input; orthographic bounds and projection-mode switching forward to Lite; fully unconfigured orthographic extents use Lite's `halfHeight` + aspect-ratio derivation rather than Babylon.js render dimensions; XR / device-orientation / stereoscopic rigs unsupported |
|
|
125
125
|
| Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `ClusteredLightContainer` clusters point lights (⚡ partial); `RectAreaLight` unsupported |
|
|
126
126
|
| Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` uses Lite's native 2–4 cascade CSM |
|
|
127
|
-
| Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `clone`, `VertexData`, `Mesh.MergeMeshes`) | ⚡ | `CreateLines`/`CreateLineSystem` support fixed-topology line lists and RGBA point colors; `CreateDashedLines` supports uniform-color dashed line lists; mesh-blending tag helpers and validated mesh metadata forward to native Lite; `MergeMeshes` bakes positions/normals/UVs and rejects unsupported attributes/animation;
|
|
127
|
+
| Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `clone`, `VertexData`, `Mesh.MergeMeshes`) | ⚡ | `CreateLines`/`CreateLineSystem` support fixed-topology line lists and RGBA point colors; `CreateDashedLines` supports uniform-color dashed line lists; mesh-blending tag helpers and validated mesh metadata forward to native Lite; `MergeMeshes` bakes positions/normals/UVs and rejects unsupported attributes/animation; polygon/extruded-polygon, decal/text/tiled builders, `GreasedLine*` (thick lines), `InstancedMesh`, LOD/edges/outline, and hardware instances unsupported |
|
|
128
128
|
| CSG / CSG2 | ✅ | over Lite boolean ops |
|
|
129
129
|
| Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`) | ⚡ | over Lite gizmo suite; `isEnabled` toggles per-axis interactivity (display-only when disabled) |
|
|
130
130
|
| Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `clone(name)` shares textures with its own renderable; fixed-slot custom WGSL `MaterialPluginBase` injection is supported (`#include`, regex replacement, and custom UBO/sampler hooks are not), while `DitheredTileFadeMaterialPlugin`, GLSL `ShaderMaterial`, `MultiMaterial`, `BackgroundMaterial`, and `OpenPBRMaterial` remain unsupported |
|
|
131
|
-
| Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `HtmlTexture`, `CubeTexture`, `HDRCubeTexture`) | ⚡ | `HDRCubeTexture` routes to native `loadHdrEnvironment`; `RawTexture2DArray` supports raw bytes, image sources/URLs, and single-file KTX2 arrays; `HtmlTexture` forwards native Lite DOM capture/update; `RenderTargetTexture` / `MirrorTexture` unsupported
|
|
132
|
-
| Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | All standard easing classes, including `PowerEase` / `BezierCurveEase`, reuse Lite's native functional curves; `beginAnimation` / `beginDirectAnimation` delegate supported float/vector/quaternion tracks to Lite property animation; unsupported tracks use an explicit compat evaluator; structural groups remain compat-owned; loaded glTF skeletal blending supported
|
|
131
|
+
| Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `HtmlTexture`, `CubeTexture`, `HDRCubeTexture`) | ⚡ | `HDRCubeTexture` routes to native `loadHdrEnvironment`; `RawTexture2DArray` supports raw bytes, image sources/URLs, and single-file KTX2 arrays; `RawTexture3D` supports base-level RGBA8 volumes but not mip generation; `HtmlTexture` forwards native Lite DOM capture/update; `RenderTargetTexture` / `MirrorTexture` unsupported |
|
|
132
|
+
| Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | All standard easing classes, including `PowerEase` / `BezierCurveEase`, reuse Lite's native functional curves; `beginAnimation` / `beginDirectAnimation` delegate supported float/vector/quaternion tracks to Lite property animation; unsupported tracks use an explicit compat evaluator; structural groups remain compat-owned; loaded glTF skeletal blending supported; root-motion analysis/controller APIs throw |
|
|
133
133
|
| Morph targets (`MorphTarget` / `MorphTargetManager`) | ✅ | over Lite morph targets |
|
|
134
134
|
| Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported |
|
|
135
135
|
| Behaviors / Actions (`AutoRotation`, `Framing`, `ActionManager`, conditions) | ⚡ | `ActionManager` is manual-dispatch; drag / six-DoF / XR-oriented mesh behaviors throw |
|
|
@@ -141,16 +141,16 @@ overloads within a supported area may still be absent.
|
|
|
141
141
|
|
|
142
142
|
### `@babylonjs/loaders`
|
|
143
143
|
|
|
144
|
-
| Feature area | Status | Notes
|
|
145
|
-
| ---------------------------------------------------------------------------------------------- | :----: |
|
|
146
|
-
| glTF 2.0 (+ extensions), `.babylon` | ✅ | via Lite `loadGltf` / `loadBabylon`; KHR_interactivity assets run through Lite's native flow-graph runtime
|
|
147
|
-
| `GLTF2.KHR_interactivity` public helpers | ⚡ | pure operation/data normalization and exporter data types are implemented; BJS FlowGraph registry/parser/export planning throws with named structural blockers
|
|
148
|
-
| glTF 1.0 loader and extensions | ❌ | named `GLTF1` stubs throw; Lite has no legacy parser, extension registry, or material-conversion subsystem
|
|
149
|
-
| OpenPBR glTF material adapter | ❌ | exported at root and under `GLTF2`; throws because Lite has no OpenPBR material subsystem
|
|
150
|
-
| OpenUSD (`USDFileLoader`) |
|
|
151
|
-
| `SceneLoader` (`ImportMeshAsync` / `AppendAsync` / `LoadAssetContainerAsync`), `AssetsManager` | ⚡ | `AssetContainer` partial
|
|
152
|
-
| Gaussian Splatting (`.ply` / `.splat` / `.sog` / `.spz`) | ⚡ | via `GaussianSplattingMesh
|
|
153
|
-
| `OBJ` / `STL` / `FBX` / `BVH` | ❌ | parser/materializer subsystems are not in Lite — convert to glTF
|
|
144
|
+
| Feature area | Status | Notes |
|
|
145
|
+
| ---------------------------------------------------------------------------------------------- | :----: | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
146
|
+
| glTF 2.0 (+ extensions), `.babylon` | ✅ | via Lite `loadGltf` / `loadBabylon`; KHR_interactivity assets run through Lite's native flow-graph runtime |
|
|
147
|
+
| `GLTF2.KHR_interactivity` public helpers | ⚡ | pure operation/data normalization and exporter data types are implemented; BJS FlowGraph registry/parser/export planning throws with named structural blockers |
|
|
148
|
+
| glTF 1.0 loader and extensions | ❌ | named `GLTF1` stubs throw; Lite has no legacy parser, extension registry, or material-conversion subsystem |
|
|
149
|
+
| OpenPBR glTF material adapter | ❌ | exported at root and under `GLTF2`; throws because Lite has no OpenPBR material subsystem |
|
|
150
|
+
| OpenUSD (`USDFileLoader`) | ⚡ | delegates binary import, virtual files, callbacks, diagnostics, asset containers, and disposal to Lite; all four custom runtime assets must share one directory |
|
|
151
|
+
| `SceneLoader` (`ImportMeshAsync` / `AppendAsync` / `LoadAssetContainerAsync`), `AssetsManager` | ⚡ | `AssetContainer` partial |
|
|
152
|
+
| Gaussian Splatting (`.ply` / `.splat` / `.sog` / `.spz`) | ⚡ | via `GaussianSplattingMesh` and the binary-data `SPLATFileLoader` plugin surface; detached containers, unpackaged/streaming SOG, replaceable decoder policies, and full glTF-embedded (`KHR_gaussian_splatting`) variants remain unsupported |
|
|
153
|
+
| `OBJ` / `STL` / `FBX` / `BVH` | ❌ | parser/materializer subsystems are not in Lite — convert to glTF |
|
|
154
154
|
|
|
155
155
|
### `@babylonjs/addons` · `@recast-navigation/*`
|
|
156
156
|
|
package/index.d.ts
CHANGED
|
@@ -22,6 +22,8 @@ import { StorageBuffer as StorageBuffer_2 } from '@babylonjs/lite';
|
|
|
22
22
|
import { Texture2D } from '@babylonjs/lite';
|
|
23
23
|
import { Texture2DArray } from '@babylonjs/lite';
|
|
24
24
|
import { UniformBuffer as UniformBuffer_2 } from '@babylonjs/lite';
|
|
25
|
+
import { UsdDiagnostics } from '@babylonjs/lite';
|
|
26
|
+
import { UsdProgress } from '@babylonjs/lite';
|
|
25
27
|
|
|
26
28
|
/** Base class for an asset-loading task. Subclasses implement {@link runAsync}. */
|
|
27
29
|
export declare abstract class AbstractAssetTask {
|
|
@@ -826,7 +828,9 @@ export declare class ArcRotateCamera extends Camera {
|
|
|
826
828
|
constructor(name: stri
|
|
827
829
|
set panningSensibility(value: number);
|
|
828
830
|
attachControl(canvas: HTMLCanvasElement, noPreventDefault?: boolean): void;
|
|
829
831
|
|
|
830
|
-
export declare class AssetContainer {
|
|
831
832
|
constructor(lite: AssetContainer_2);
|
|
833
|
+
export declare class AssetContainer {
|
|
832
834
|
private readonly _dispose;
|
|
833
835
|
private _sceneDisposeObserver;
|
|
836
|
+
private _disposed;
|
|
837
|
+
constructor(lite: AssetContainer_2, dispose?: () => void, ownedMeshes?: readonly Mesh_2[]);
|
|
834
838
|
get animationGroups(): AnimationGroup_2[];
|
|
835
839
|
/**
|
|
836
840
|
* Flat list of the loaded meshes as canonical, stable-identity compat `Mesh`
|
|
@@ -837,8 +841,10 @@ export declare class AssetContainer {
|
|
|
837
841
|
constructor(lite: AssetContainer_2);
|
|
838
842
|
get meshes(): Mesh[];
|
|
839
843
|
get skeletons(): Skeleton[];
|
|
840
844
|
/** Add every entity, animation group, camera, and clear colour to the scene. */
|
|
841
|
-
addAllToScene(scene: Scene): void;
|
|
842
|
-
dispose(): void;
|
|
845
|
+
addAllToScene(scene: Scene): void;
|
|
843
846
|
dispose(): void;
|
|
847
|
+
private _detachFromScene;
|
|
848
|
+
private _retireMeshWrappers;
|
|
849
|
+
private _disposeOnce;
|
|
844
850
|
}
|
|
845
851
|
|
|
846
852
|
export declare class AssetsManager {
|
|
@@ -1580,6 +1586,12 @@ export declare function CreateMicrophoneSoundSourceAsync(name: string, options?:
|
|
|
1580
1586
|
/** Babylon.js `CreatePlane(name, options, scene)` (planeBuilder). */
|
|
1581
1587
|
export declare function CreatePlane(name: string, options: PlaneOptions, scene: Scene): Mesh;
|
|
1582
1588
|
|
|
1589
|
+
/** Babylon.js `CreatePolygon(name, options, scene?, earcutInjection?)` — throwing stub (see `MeshBuilder.CreatePolygon`). */
|
|
1590
|
+
export declare function CreatePolygon(name: string, options: PolygonBuilderOptions, scene?: Scene | null, earcutInjection?: unknown): never;
|
|
1591
|
+
|
|
1592
|
+
/** Babylon.js `CreatePolygonVertexData` — the polygon geometry generator requires the unsupported polygon subsystem. */
|
|
1593
|
+
export declare function CreatePolygonVertexData(_polygon: Mesh, _sideOrientation: number, _faceUV?: Vector4[], _faceColors?: Color4[], _frontUVs?: Vector4, _backUVs?: Vector4, _wrap?: boolean): never;
|
|
1594
|
+
|
|
1583
1595
|
/** Babylon.js `CreateSoundAsync`. */
|
|
1584
1596
|
export declare function CreateSoundAsync(name: string, source: StaticSoundSource, options?: Partial<IStaticSoundOptions>, engine?: AudioEngineV2 | null): Promise<StaticSound>;
|
|
1585
1597
|
|
|
@@ -1934,6 +1946,9 @@ export declare class ExponentialEase extends EasingFunction {
|
|
|
1934
1946
|
easeInCore(gradient: number): number;
|
|
1935
1947
|
}
|
|
1936
1948
|
|
|
1949
|
+
/** Babylon.js `ExtrudePolygon(name, options, scene?, earcutInjection?)` — throwing stub (see `MeshBuilder.ExtrudePolygon`). */
|
|
1950
|
+
export declare function ExtrudePolygon(name: string, options: PolygonBuilderOptions, scene?: Scene | null, earcutInjection?: unknown): never;
|
|
1951
|
+
|
|
1937
1952
|
/** A gradient value bound to a [0, 1] position (Babylon.js `FactorGradient`). */
|
|
1938
1953
|
export declare class FactorGradient {
|
|
1939
1954
|
gradient: number;
|
|
@@ -3031,6 +3046,22 @@ export declare interface IRaycastQuery {
|
|
|
3031
3046
|
ignoreBody?: PhysicsBody;
|
|
3032
3047
|
}
|
|
3033
3048
|
|
|
3049
|
+
export declare interface IRootMotionClipOptions {
|
|
3050
|
+
rootNode?: TransformNode | Bone;
|
|
3051
|
+
characterNode?: TransformNode;
|
|
3052
|
+
contactNodes?: Array<TransformNode | Bone>;
|
|
3053
|
+
source?: RootMotionSource;
|
|
3054
|
+
extractRotation?: boolean;
|
|
3055
|
+
samplesPerSecond?: number;
|
|
3056
|
+
minimumTravel?: number;
|
|
3057
|
+
minimumTurn?: number;
|
|
3058
|
+
directionSnapAngle?: number;
|
|
3059
|
+
extractLateralMotion?: boolean;
|
|
3060
|
+
upAxis?: Vector3;
|
|
3061
|
+
name?: string;
|
|
3062
|
+
cloneAnimations?: boolean;
|
|
3063
|
+
}
|
|
3064
|
+
|
|
3034
3065
|
/**
|
|
3035
3066
|
* Babylon.js `ISafeOrbitCameraLimits` — safe-orbit camera limits embedded in a Gaussian
|
|
3036
3067
|
* Splatting file's metadata (Adobe safe-orbit extension). Exposed on the loaded mesh via
|
|
@@ -3053,6 +3084,8 @@ export declare interface ISceneLoaderOptions {
|
|
|
3053
3084
|
preprocessUrlAsync?: (url: string) => Promise<string>;
|
|
3054
3085
|
[option: string]: unknown;
|
|
3055
3086
|
};
|
|
3087
|
+
splat?: Partial<Readonly<SPLATLoadingOptions>>;
|
|
3088
|
+
usd?: Partial<USDFileLoaderOptions>;
|
|
3056
3089
|
};
|
|
3057
3090
|
}
|
|
3058
3091
|
|
|
@@ -3564,6 +3597,10 @@ export declare class Mesh extends AbstractMesh {
|
|
|
3564
3597
|
static CreateCylinder(name: string, height: number, diameterTop: number, diameterBottom: number, tessellation: number, _subdivisions: number, scene: Scene): Mesh;
|
|
3565
3598
|
/** Legacy `Mesh.CreateTorus(name, diameter, thickness, tessellation, scene)`. */
|
|
3566
3599
|
static CreateTorus(name: string, diameter: number, thickness: number, tessellation: number, scene: Scene): Mesh;
|
|
3600
|
+
/** Legacy `Mesh.CreatePolygon(name, shape, scene, holes?, updatable?, sideOrientation?, earcutInjection?)`. */
|
|
3601
|
+
static CreatePolygon(_name: string, _shape: Vector3[], _scene: Scene, _holes?: Vector3[][], _updatable?: boolean, _sideOrientation?: number, _earcutInjection?: unknown): never;
|
|
3602
|
+
/** Legacy `Mesh.ExtrudePolygon(name, shape, depth, scene, holes?, updatable?, sideOrientation?, earcutInjection?)`. */
|
|
3603
|
+
static ExtrudePolygon(_name: string, _shape: Vector3[], _depth: number, _scene: Scene, _holes?: Vector3[][], _updatable?: boolean, _sideOrientation?: number, _earcutInjection?: unknown): never;
|
|
3567
3604
|
/** Hardware-instanced copy — unsupported. Use native thin instances instead. */
|
|
3568
3605
|
createInstance(): never;
|
|
3569
3606
|
/**
|
|
@@ -3682,11 +3719,13 @@ export declare const MeshBuilder: {
|
|
|
3682
3719
|
CreateText(): never;
|
|
3683
3720
|
CreateTiledBox(_name?: string, _options?: object, _scene?: Scene): never;
|
|
3684
3721
|
CreateTiledPlane(_name?: string, _options?: object, _scene?: Scene): never;
|
|
3722
|
+
CreatePolygon(_name: string, _options: PolygonBuilderOptions, _scene?: Scene | null, _earcutInjection?: unknown): never;
|
|
3723
|
+
ExtrudePolygon(_name: string, _options: PolygonBuilderOptions, _scene?: Scene | null, _earcutInjection?: unknown): never;
|
|
3685
3724
|
};
|
|
3686
3725
|
|
|
3687
3726
|
/** A compat mesh exposes its backing Lite mesh as `_lite`. */
|
|
3688
3727
|
declare interface MeshLike {
|
|
3689
|
-
_lite:
|
|
3728
|
+
_lite: Mesh;
|
|
3690
3729
|
}
|
|
3691
3730
|
|
|
3692
3731
|
/**
|
|
@@ -3716,6 +3755,8 @@ export declare class MeshoptCompression {
|
|
|
3716
3755
|
static get Default(): MeshoptCompression;
|
|
3717
3756
|
}
|
|
3718
3757
|
|
|
3758
|
+
export declare type MeshPredicate = (mesh: AbstractMesh, thinInstanceIndex: number) => boolean;
|
|
3759
|
+
|
|
3719
3760
|
export { MinTemperatureKelvin }
|
|
3720
3761
|
|
|
3721
3762
|
export declare class MirrorTexture {
|
|
@@ -3918,8 +3959,7 @@ export declare class Observable<T> {
|
|
|
3918
3959
|
addOnce(callback: ObserverCallback<T>, mask?: number): ObserverCallback<T>;
|
|
3919
3960
|
remove(callback: ObserverCallback<T> | null | undefined): boolean;
|
|
3920
3961
|
removeCallback(callback: ObserverCallback<T>): boolean;
|
|
3921
|
-
notifyObservers(eventData?: T, mask?: number): void;
|
|
3922
|
-
hasObservers(): boolean;
|
|
3962
|
+
notifyObservers(eventData?: T, mask?: number): void;
|
|
3923
3963
|
hasObservers(): boolean;
|
|
3924
3964
|
clear(): void;
|
|
3925
3965
|
cleanLastNotifiedState(): void;
|
|
3926
3966
|
}
|
|
@@ -4560,8 +4600,11 @@ export declare class PickingInfo {
|
|
|
4560
4600
|
aimTransform: TransformNode | null;
|
|
4561
4601
|
gripTransform: TransformNode | null;
|
|
4562
4602
|
private _normal;
|
|
4563
|
-
private _worldNormal;
|
|
4564
4603
|
getNormal(useWorldCoordinates?: boolean, _useVerticesNormals?: boolean): Vector3 | null;
|
|
4565
|
-
|
|
4604
|
+
private _worldNormal;
|
|
4605
|
+
private _faceNormal;
|
|
4606
|
+
private _faceWorldNormal;
|
|
4607
|
+
private _uv;
|
|
4566
4608
|
getNormal(useWorldCoordinates?: boolean, useVerticesNormals?: boolean): Vector3 | null;
|
|
4609
|
+
getTextureCoordinates(uvSet?: string): Vector2 | null;
|
|
4567
4610
|
}
|
|
4568
4611
|
|
|
4569
4612
|
declare type PickListItem = PickableMesh | {
|
|
@@ -4695,6 +4738,26 @@ export declare class Polar {
|
|
|
4695
4738
|
static FromArray(array: number[]): Polar;
|
|
4696
4739
|
}
|
|
4697
4740
|
|
|
4741
|
+
/** Babylon.js polygon-builder namespace object. */
|
|
4742
|
+
export declare const PolygonBuilder: {
|
|
4743
|
+
ExtrudePolygon: typeof ExtrudePolygon;
|
|
4744
|
+
CreatePolygon: typeof CreatePolygon;
|
|
4745
|
+
};
|
|
4746
|
+
|
|
4747
|
+
declare interface PolygonBuilderOptions {
|
|
4748
|
+
shape: Vector3[];
|
|
4749
|
+
holes?: Vector3[][];
|
|
4750
|
+
depth?: number;
|
|
4751
|
+
smoothingThreshold?: number;
|
|
4752
|
+
faceUV?: Vector4[];
|
|
4753
|
+
faceColors?: Color4[];
|
|
4754
|
+
updatable?: boolean;
|
|
4755
|
+
sideOrientation?: number;
|
|
4756
|
+
frontUVs?: Vector4;
|
|
4757
|
+
backUVs?: Vector4;
|
|
4758
|
+
wrap?: boolean;
|
|
4759
|
+
}
|
|
4760
|
+
|
|
4698
4761
|
export declare class PositionGizmo extends GizmoBase {
|
|
4699
4762
|
private _attached;
|
|
4700
4763
|
private _xGizmo;
|
|
4701
4764
|
private _yGizmo;
|
|
@@ -4898,7 +4961,7 @@ export declare class RawTexture3D extends BaseTexture {
|
|
|
4898
4961
|
readonly is3D = true;
|
|
4899
4962
|
constructor(data: ArrayBufferView | null, width: number, height: number, depth: number,
|
|
4900
4963
|
/** Babylon.js texture format (recorded for parity; Lite uploads RGBA8). */
|
|
4901
|
-
format: number, scene: Scene,
|
|
4964
|
+
format: number, scene: Scene, generateMipMaps?: boolean, _invertY?: boolean, _samplingMode?: number, _textureType?: number, _creationFlags?: number);
|
|
4902
4965
|
getClassName(): string;
|
|
4903
4966
|
/** Gets the width of the texture. */
|
|
4904
4967
|
get width(): number;
|
|
@@ -4972,13 +5035,66 @@ export declare function RegisterMeshBlendingPostProcessBlock(): never;
|
|
|
4972
5035
|
|
|
4973
5036
|
export declare function RegisterOpenpbrMaterial(): void;
|
|
4974
5037
|
|
|
4975
|
-
|
|
5038
|
+
/**
|
|
5039
|
+
* Babylon.js side-effect registration shim. Compat defines the corresponding
|
|
5040
|
+
* methods directly, so importing or calling this function requires no mutation.
|
|
5041
|
+
*/
|
|
5042
|
+
export declare function RegisterPolygonBuilder(): void;
|
|
5043
|
+
|
|
5044
|
+
export declare function RegisterSPLATFileLoader(): void;
|
|
5045
|
+
|
|
5046
|
+
export declare function RegisterUSDFileLoader(): void;
|
|
4976
5047
|
|
|
4977
5048
|
/** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
|
|
4978
5049
|
export declare class RenderTargetTexture {
|
|
4979
5050
|
constructor();
|
|
4980
5051
|
}
|
|
4981
5052
|
|
|
5053
|
+
export declare class RootMotionClip {
|
|
5054
|
+
constructor(_animationGroup: AnimationGroup, _options?: IRootMotionClipOptions);
|
|
5055
|
+
get sourceAnimationGroup(): AnimationGroup;
|
|
5056
|
+
get animationGroup(): AnimationGroup;
|
|
5057
|
+
get controller(): RootMotionController | null;
|
|
5058
|
+
get source(): RootMotionSource;
|
|
5059
|
+
get rootNode(): TransformNode | null;
|
|
5060
|
+
get characterNode(): TransformNode;
|
|
5061
|
+
get contactNodes(): ReadonlyArray<TransformNode>;
|
|
5062
|
+
get upAxis(): Vector3;
|
|
5063
|
+
get fromFrame(): number;
|
|
5064
|
+
get toFrame(): number;
|
|
5065
|
+
get travelDirection(): Vector3;
|
|
5066
|
+
get cycleOffset(): Vector3;
|
|
5067
|
+
get cycleDistance(): number;
|
|
5068
|
+
get cycleRotation(): number;
|
|
5069
|
+
get extractsRotation(): boolean;
|
|
5070
|
+
get duration(): number;
|
|
5071
|
+
get averageSpeed(): number;
|
|
5072
|
+
get characterHeight(): number;
|
|
5073
|
+
getOffsetAtFrame(_frame: number, _result: Vector3): Vector3;
|
|
5074
|
+
getRotationAtFrame(_frame: number): number;
|
|
5075
|
+
dispose(): void;
|
|
5076
|
+
}
|
|
5077
|
+
|
|
5078
|
+
export declare class RootMotionController {
|
|
5079
|
+
applyToCharacter: boolean;
|
|
5080
|
+
readonly onRootMotionObservable: Observable<RootMotionController>;
|
|
5081
|
+
constructor(_characterNode: TransformNode, _clips?: RootMotionClip[]);
|
|
5082
|
+
get characterNode(): TransformNode;
|
|
5083
|
+
get clips(): ReadonlyArray<RootMotionClip>;
|
|
5084
|
+
get deltaPosition(): Vector3;
|
|
5085
|
+
get deltaRotation(): number;
|
|
5086
|
+
addClip(_clip: RootMotionClip): void;
|
|
5087
|
+
removeClip(_clip: RootMotionClip): void;
|
|
5088
|
+
reset(): void;
|
|
5089
|
+
dispose(): void;
|
|
5090
|
+
}
|
|
5091
|
+
|
|
5092
|
+
export declare enum RootMotionSource {
|
|
5093
|
+
None = 0,
|
|
5094
|
+
Root = 1,
|
|
5095
|
+
FootContact = 2
|
|
5096
|
+
}
|
|
5097
|
+
|
|
4982
5098
|
export declare class RotationGizmo extends GizmoBase {
|
|
4983
5099
|
private _attached;
|
|
4984
5100
|
private _xGizmo;
|
|
4985
5101
|
private _yGizmo;
|
|
@@ -5207,14 +5323,14 @@ export declare class Scene extends AbstractScene {
|
|
|
5207
5323
|
/** Babylon.js fog-mode c
|
|
5208
5324
|
/** Babylon.js synchronous readiness check — always ready in the compat layer. */
|
|
5209
5325
|
isReady(): boolean;
|
|
5210
5326
|
/** Babylon.js synchronous screen-coordinate picking over Lite's CPU ray picker. */
|
|
5211
|
-
pick(x: number, y: number, predicate?:
|
|
5327
|
+
pick(x: number, y: number, predicate?: MeshPredicate, fastCheck?: boolean, camera?: Camera | null, trianglePredicate?: TrianglePickingPredicate): PickingInfo;
|
|
5212
5328
|
/**
|
|
5213
5329
|
* Babylon.js `Scene.createPickingRay` — translate CSS coordinates and camera
|
|
5214
5330
|
* transforms into Lite's reverse-Z unprojection helper.
|
|
5215
5331
|
*/
|
|
5216
5332
|
createPickingRay(x: number, y: number, world?: Matrix | null, camera?: Camera | null, cameraViewSpace?: boolean): Ray;
|
|
5217
5333
|
/** Synchronous CPU ray picking over Babylon Lite's scene-mesh picker. */
|
|
5218
|
-
pickWithRay(ray: Ray, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
|
|
5219
5334
|
/**
|
|
5335
|
+
pickWithRay(ray: Ray, predicate?: MeshPredicate, fastCheck?: boolean, trianglePredicate?: TrianglePickingPredicate): PickingInfo;
|
|
5220
5336
|
/**
|
|
5221
5337
|
* Babylon.js `scene.enablePhysics(gravity, plugin)`. Wires the given Havok V2
|
|
5222
5338
|
* {@link HavokPlugin} to this scene, creating the native Lite physics world and
|
|
5223
5339
|
* registering per-frame stepping. The plugin's `useDeltaForWorldStep` flag
|
|
@@ -5532,6 +5648,60 @@ export declare class Spherical {
|
|
|
5532
5648
|
static FromArray(array: number[]): Spherical;
|
|
5533
5649
|
}
|
|
5534
5650
|
|
|
5651
|
+
export declare class SPLATFileLoader {
|
|
5652
|
+
readonly name = "splat";
|
|
5653
|
+
readonly extensions: {
|
|
5654
|
+
readonly ".splat": {
|
|
5655
|
+
readonly isBinary: true;
|
|
5656
|
+
};
|
|
5657
|
+
readonly ".ply": {
|
|
5658
|
+
readonly isBinary: true;
|
|
5659
|
+
};
|
|
5660
|
+
readonly ".spz": {
|
|
5661
|
+
readonly isBinary: true;
|
|
5662
|
+
};
|
|
5663
|
+
readonly ".json": {
|
|
5664
|
+
readonly isBinary: false;
|
|
5665
|
+
};
|
|
5666
|
+
readonly ".sog": {
|
|
5667
|
+
readonly isBinary: true;
|
|
5668
|
+
};
|
|
5669
|
+
};
|
|
5670
|
+
private readonly _loadingOptions;
|
|
5671
|
+
constructor(loadingOptions?: Partial<Readonly<SPLATLoadingOptions>>);
|
|
5672
|
+
createPlugin(options: {
|
|
5673
|
+
splat?: Partial<Readonly<SPLATLoadingOptions>>;
|
|
5674
|
+
}): SPLATFileLoader;
|
|
5675
|
+
importMeshAsync(_meshesNames: unknown, scene: Scene, data: unknown, _rootUrl: string, _onProgress?: (event: ISceneLoaderProgressEvent) => void, _fileName?: string): Promise<SPLATImportResult>;
|
|
5676
|
+
loadAsync(scene: Scene, data: unknown, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<void>;
|
|
5677
|
+
loadAssetContainerAsync(_scene: Scene, _data: string, _rootUrl: string): Promise<AssetContainer>;
|
|
5535
5678
|
private _load;
|
|
5679
|
+
private _loadReserved;
|
|
5680
|
+
private _adoptLoaded;
|
|
5681
|
+
}
|
|
5682
|
+
|
|
5683
|
+
declare interface SPLATImportResult {
|
|
5684
|
+
meshes: GaussianSplattingMesh[];
|
|
5685
|
+
particleSystems: unknown[];
|
|
5686
|
+
skeletons: unknown[];
|
|
5687
|
+
animationGroups: unknown[];
|
|
5688
|
+
transformNodes: unknown[];
|
|
5689
|
+
geometries: unknown[];
|
|
5690
|
+
lights: unknown[];
|
|
5691
|
+
spriteManagers: unknown[];
|
|
5692
|
+
}
|
|
5693
|
+
|
|
5694
|
+
export declare type SPLATLoadingOptions = {
|
|
5695
|
+
keepInRam?: boolean;
|
|
5696
|
+
flipY?: boolean;
|
|
5697
|
+
deflateURL?: string;
|
|
5698
|
+
fflate?: unknown;
|
|
5699
|
+
disableAutoCameraLimits?: boolean;
|
|
5700
|
+
gaussianSplattingMesh?: GaussianSplattingMesh;
|
|
5701
|
+
needsRotationScaleTextures?: boolean;
|
|
5702
|
+
useSogTextures?: boolean;
|
|
5703
|
+
spzLibraryUrl?: string;
|
|
5704
|
+
};
|
|
5705
|
+
|
|
5536
5706
|
export declare class SpotLight extends Light {
|
|
5537
5707
|
constructor(name: string, position: Vector3, direction: Vector3, angle: number, exponent: number, scene?: Scene);
|
|
5538
5708
|
getClassName(): string;
|
|
5539
5709
|
get angle(): number;
|
|
@@ -6050,6 +6220,8 @@ export declare class TransformNode extends Node_2 {
|
|
|
6050
6220
|
physicsBody: PhysicsBody
|
|
6051
6221
|
|
|
6052
6222
|
export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
|
|
6053
6223
|
|
|
6224
|
+
export declare type TrianglePickingPredicate = (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray, i0: number, i1: number, i2: number) => boolean;
|
|
6225
|
+
|
|
6054
6226
|
/** Minimum Babylon.js UniformBuffer surface needed to author compute bindings. */
|
|
6055
6227
|
export declare class UniformBuffer {
|
|
6056
6228
|
private readonly _engine;
|
|
@@ -6154,7 +6326,34 @@ export declare function UploadImageToTexture2DArrayLayer(texture: RawTexture2DAr
|
|
|
6154
6326
|
export declare type USDBinaryInput = ArrayBuffer | ArrayBufferView;
|
|
6155
6327
|
|
|
6156
6328
|
export declare class USDFileLoader {
|
|
6157
|
-
|
|
6329
|
+
static get DefaultConfiguration(): Required<Pick<USDFileLoaderOptions, "workerUrl" | "glueUrl" | "wasmUrl" | "dataUrl">>;
|
|
6330
|
+
static set DefaultConfiguration(configuration: Required<Pick<USDFileLoaderOptions, "workerUrl" | "glueUrl" | "wasmUrl" | "dataUrl">>);
|
|
6331
|
+
readonly name = "usd";
|
|
6332
|
+
readonly extensions: {
|
|
6333
|
+
readonly ".usd": {
|
|
6334
|
+
readonly isBinary: true;
|
|
6335
|
+
};
|
|
6336
|
+
readonly ".usda": {
|
|
6337
|
+
readonly isBinary: true;
|
|
6338
|
+
};
|
|
6339
|
+
readonly ".usdc": {
|
|
6340
|
+
readonly isBinary: true;
|
|
6341
|
+
};
|
|
6342
|
+
readonly ".usdz": {
|
|
6343
|
+
readonly isBinary: true;
|
|
6344
|
+
};
|
|
6345
|
+
};
|
|
6346
|
+
private readonly _options;
|
|
6347
|
+
private readonly _activeLoads;
|
|
6348
|
+
constructor(options?: Partial<USDFileLoaderOptions>);
|
|
6349
|
+
createPlugin(options: {
|
|
6350
|
+
usd?: Partial<USDFileLoaderOptions>;
|
|
6351
|
+
}): USDFileLoader;
|
|
6352
|
+
importMeshAsync(_meshNames: string | readonly string[] | null | undefined, scene: Scene, data: unknown, _rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<USDImportResult>;
|
|
6353
|
+
loadAsync(scene: Scene, data: unknown, _rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<void>;
|
|
6354
|
+
loadAssetContainerAsync(scene: Scene, data: unknown, _rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<AssetContainer>;
|
|
6355
|
+
dispose(): void;
|
|
6356
|
+
private _load;
|
|
6158
6357
|
}
|
|
6159
6358
|
|
|
6160
6359
|
export declare interface USDFileLoaderOptions {
|
|
@@ -6170,38 +6369,24 @@ export declare interface USDFileLoaderOptions {
|
|
|
6170
6369
|
onComplete?: (diagnostics: USDImportDiagnostics) => void;
|
|
6171
6370
|
}
|
|
6172
6371
|
|
|
6173
|
-
export declare
|
|
6174
|
-
timings: USDImportTimings;
|
|
6175
|
-
statistics: USDImportStatistics;
|
|
6176
|
-
missingAssets: readonly string[];
|
|
6177
|
-
}
|
|
6372
|
+
export declare type USDImportDiagnostics = UsdDiagnostics;
|
|
6178
6373
|
|
|
6179
|
-
|
|
6180
|
-
|
|
6181
|
-
|
|
6182
|
-
|
|
6183
|
-
|
|
6184
|
-
|
|
6185
|
-
|
|
6186
|
-
triangles: number;
|
|
6187
|
-
commandBytes: number;
|
|
6188
|
-
dataBytes: number;
|
|
6374
|
+
declare interface USDImportResult {
|
|
6375
|
+
meshes: Mesh[];
|
|
6376
|
+
particleSystems: unknown[];
|
|
6377
|
+
skeletons: Skeleton[];
|
|
6378
|
+
animationGroups: AnimationGroup_2[];
|
|
6379
|
+
transformNodes: unknown[];
|
|
6380
|
+
lights: unknown[];
|
|
6189
6381
|
}
|
|
6190
6382
|
|
|
6191
|
-
export declare
|
|
6192
|
-
totalMs: number;
|
|
6193
|
-
stageOpenMs: number;
|
|
6194
|
-
stageReadMs: number;
|
|
6195
|
-
preparationMs: number;
|
|
6196
|
-
packingMs: number;
|
|
6197
|
-
heapCopyMs: number;
|
|
6198
|
-
materializeMs: number;
|
|
6199
|
-
}
|
|
6383
|
+
export declare type USDImportStatistics = UsdDiagnostics["statistics"];
|
|
6200
6384
|
|
|
6201
|
-
export declare
|
|
6202
|
-
|
|
6203
|
-
|
|
6204
|
-
|
|
6385
|
+
export declare type USDImportTimings = UsdDiagnostics["timings"];
|
|
6386
|
+
|
|
6387
|
+
export declare type USDLoadProgress = Omit<UsdProgress, "phase"> & {
|
|
6388
|
+
phase: Exclude<UsdProgress["phase"], "fetching">;
|
|
6389
|
+
};
|
|
6205
6390
|
|
|
6206
6391
|
export declare type USDVirtualFiles = Readonly<Record<string, USDBinaryInput>>;
|
|
6207
6392
|
|
|
@@ -6388,6 +6573,8 @@ export declare class VertexData {
|
|
|
6388
6573
|
uvs: number[] | Float32Array | null;
|
|
6389
6574
|
colors: number[] | Float32Array | null;
|
|
6390
6575
|
indices: number[] | Uint32Array | Uint16Array | null;
|
|
6576
|
+
/** Deprecated Babylon.js polygon vertex-data entry point. */
|
|
6577
|
+
static CreatePolygon(polygon: Mesh, sideOrientation: number, faceUV?: Vector4[], faceColors?: Color4[], frontUVs?: Vector4, backUVs?: Vector4, wrap?: boolean): never;
|
|
6391
6578
|
/**
|
|
6392
6579
|
* Babylon.js `VertexData.applyToMesh(mesh)` — upload this CPU geometry onto a
|
|
6393
6580
|
* mesh (typically one created via `new Mesh(name, scene)`). Replaces the Lite
|