@babylonjs/lite-compat 1.24.0-preview → 1.25.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
@@ -134,7 +134,7 @@ overloads within a supported area may still be absent.
134
134
  | Behaviors / Actions (`AutoRotation`, `Framing`, `ActionManager`, conditions) | ⚡ | `ActionManager` is manual-dispatch; drag / six-DoF / XR-oriented mesh behaviors throw |
135
135
  | Misc (`Observable`, `Tools`, `SmartArray`, `Tags`, gradients, `PerformanceMonitor`) | ✅ | |
136
136
  | Audio V2 (`AudioEngineV2`, `StaticSound`, `StreamingSound`, `AudioBus`, buses/sources/analyzer) | ⚡ | over Lite's AudioV2 port; `MainAudioBus` spatial/analyzer and a second main bus unsupported |
137
- | 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
+ | Physics (`HavokPlugin`, `scene.enablePhysics`/`getPhysicsEngine`, `PhysicsAggregate`/`PhysicsBody`/`PhysicsShape`) | ⚡ | Native Havok V2 forwarding for common body/shape operations; unrecognized shape/motion/prestep enum values throw at the compat boundary |
138
138
  | Particles (`NodeParticleSystemSet` / `ParticleSystemSet` — Node Particle Editor) | ⚡ | NPE snippet/JSON graphs: `Parse`/`ParseFromSnippetAsync` → `buildAsync` → `start`, incl. per-system `set.systems[i]` runtime (`start`/`animate`/`updateSpeed`/`particleTexture`). Imperative classic/GPU/solid `ParticleSystem` construction + programmatic block authoring unsupported |
139
139
  | Post-processes, layers (glow/highlight), probes, WebXR | ❌ | not in Babylon Lite — use native Lite `create*Task` functions |
140
140
 
package/index.d.ts CHANGED
@@ -8,6 +8,9 @@ import { EngineOptions } from '@babylonjs/lite';
8
8
  import { IridescenceProps } from '@babylonjs/lite';
9
9
  import { LineMaterial } from '@babylonjs/lite';
10
10
  import { Mesh as Mesh_2 } from '@babylonjs/lite';
11
+ import { PhysicsMassProperties } from '@babylonjs/lite';
12
+ import { PhysicsShape as PhysicsShape_2 } from '@babylonjs/lite';
13
+ import { PhysicsShapeParameters } from '@babylonjs/lite';
11
14
  import { PhysicsWorld } from '@babylonjs/lite';
12
15
  import { RenderCanvas } from '@babylonjs/lite';
13
16
  import { SceneNode } from '@babylonjs/lite';
@@ -243,6 +246,8 @@ export declare class AbstractMesh extends TransformNode {
243
246
  private _material;
244
247
  set material(value: CompatMaterial | null);
245
248
  get isVisible(): boolean;
246
249
  set isVisible(value: boolean);
250
+ get isPickable(): boolean;
251
+ set isPickable(value: boolean);
247
252
  get receiveShadows(): boolean;
248
253
  set receiveShadows(value: boolean);
249
254
  protected _onEffectiveEnabledStateChanged(enabled: boolean): void;
250
255
  /**
@@ -795,6 +800,7 @@ export declare class AssetContainer {
795
800
  constructor(lite: AssetContainer_2);
796
801
  * same handles `scene.meshes` exposes.
797
802
  */
798
803
  get meshes(): Mesh[];
804
+ get skeletons(): Skeleton[];
799
805
  /** Add every entity, animation group, camera, and clear colour to the scene. */
800
806
  addAllToScene(scene: Scene): void;
801
807
  dispose(): void;
@@ -1014,7 +1020,15 @@ export declare const BloomEffect: new () => never;
1014
1020
  export declare const BlurPostProcess: new () => never;
1015
1021
 
1016
1022
  export declare class Bone {
1017
- constructor();
1023
+ private _enabled;
1024
+ readonly name: string;
1018
1025
  constructor(_name?: string, _skeleton?: Skeleton);
1019
1026
  getName(): string;
1027
+ getSkeleton(): Skeleton;
1028
+ setPosition(position: Vector3, space?: number): this;
1029
+ setRotationQuaternion(rotation: Quaternion, space?: number): this;
1030
+ setScale(scale: Vector3): this;
1031
+ setEnabled(value: boolean): void;
1032
+ isEnabled(): boolean;
1033
+ returnToRest(): void;
1020
1034
  }
1021
1035
 
1022
1036
  export declare class BounceEase extends EasingFunction {
@@ -1106,7 +1120,8 @@ export declare class BoundingSphere {
1106
1120
  private _worldMatrix;
1107
1121
  constructor(min: Vector3, max: Vector3, worldMatrix?: Matrix);
1108
1122
  reConstruct(min: Vector3, max: Vector3, worldMatrix?: Matrix): void;
1109
- getWorldMatrix(): Matrix;
1110
1123
  intersectsPoint(point: Vector3): boolean;
1124
+ getWorldMatrix(): Matrix;
1125
+ scale(factor: number): this;
1111
1126
  intersectsPoint(point: Vector3): boolean;
1112
1127
  static Intersects(a: BoundingSphere, b: BoundingSphere): boolean;
1113
1128
  }
1114
1129
 
@@ -2355,7 +2370,7 @@ export declare function ImportMeshAsync(source: string, scene: Scene, _options?:
2355
2370
  declare interface ImportResult {
2356
2371
  meshes: TransformNode[];
2357
2372
  particleSystems: unknown[];
2358
- skeletons: unknown[];
2373
+ skeletons: Skeleton[];
2359
2374
  animationGroups: AnimationGroup_2[];
2360
2375
  transformNodes: unknown[];
2361
2376
  lights: unknown[];
@@ -2735,6 +2750,8 @@ export declare class Matrix {
2735
2750
  constructor();
2736
2751
  set(index: number, value: number): this;
2737
2752
  copyFrom(source: Matrix): this;
2753
+ maximizeInPlace(other: Matrix): this;
2754
+ maximizeInPlaceFromFloats(m0: number, m1: number, m2: number, m3: number, m4: number, m5: number, m6: number, m7: number, m8: number, m9: number, m10: number, m11: number, m12: number, m13: number, m14: number, m15: number): this;
2738
2755
  clone(): Matrix;
2739
2756
  asArray(): Float32Array;
2740
2757
  toArray(): number[];
@@ -2976,7 +2993,8 @@ declare abstract class Node_2 {
2976
2993
  /** Process-unique numeric id, assigned at construction. */
2977
2994
  readonly uniqueId: number;
2978
2995
  /** Free-form user data slot (Babylon.js `Node.metadata`). */
2979
- metadata: unknown;
2980
2996
  protected constructor(name: string, scene?: Scene);
2997
+ metadata: unknown;
2998
+ readonly onDisposeObservable: Observable<Node_2>;
2981
2999
  protected constructor(name: string, scene?: Scene);
2982
3000
  /** The runtime class name (overridden by each subclass). */
2983
3001
  getClassName(): string;
2984
3002
  /** The scene this node belongs to, if any. */
@@ -3453,13 +3471,63 @@ export declare class PerformanceMonitor {
3453
3471
  reset(): void;
3454
3472
  }
3455
3473
 
3474
+ /** Babylon.js aggregate convenience object backed by Lite's native aggregate factory. */
3456
3475
  export declare class PhysicsAggregate {
3457
- constructor();
3476
+ readonly transformNode: TransformNode;
3477
+ readonly type: PhysicsShapeType | PhysicsShape;
3478
+ readonly body: PhysicsBody;
3479
+ readonly shape: PhysicsShape;
3480
+ readonly material: PhysicsMaterial;
3458
3481
  constructor(transformNode: TransformNode, type: PhysicsShapeType | PhysicsShape, options?: PhysicsAggregateParameters, scene?: Scene);
3482
+ dispose(): void;
3459
3483
  }
3460
3484
 
3461
- export declare class PhysicsBody {
3462
- constructor();
3463
- }
3485
+ export declare interface PhysicsAggregateParameters {
3486
+ mass: number;
3487
+ friction?: number;
3488
+ staticFriction?: number;
3489
+ restitution?: number;
3490
+ radius?: number;
3491
+ pointA?: Vec3Like;
3492
+ pointB?: Vec3Like;
3493
+ extents?: Vec3Like;
3494
+ rotation?: {
3495
+ x: number;
3496
+ y: number;
3497
+ z: number;
3498
+ w: number;
3499
+ };
3500
+ center?: Vec3Like;
3501
+ mesh?: Mesh;
3502
+ startAsleep?: boolean;
3503
+ isTriggerShape?: boolean;
3504
+ }
3505
+
3506
+ /** Babylon.js-shaped rigid body backed by a Babylon Lite physics body. */
3507
+ export declare class PhysicsBody {
3464
3508
  readonly transformNode: TransformNode;
3509
+ private _disableSync;
3510
+ readonly startAsleep: boolean;
3511
+ constructor(transformNode: TransformNode, motionType: PhysicsMotionType, startsAsleep: boolean, scene: Scene);
3465
3512
  getClassName(): string;
3513
+ get disablePreStep(): boolean;
3514
+ set disablePreStep(value: boolean);
3515
+ get disableSync(): boolean;
3516
+ set disableSync(value: boolean);
3517
+ get motionType(): PhysicsMotionType;
3518
+ set shape(value: PhysicsShape | null);
3519
+ get shape(): PhysicsShape | null;
3520
+ setMotionType(value: PhysicsMotionType): void;
3521
+ getMotionType(): PhysicsMotionType;
3522
+ setPrestepType(value: PhysicsPrestepType): void;
3523
+ getPrestepType(): PhysicsPrestepType;
3524
+ setMassProperties(properties: PhysicsMassProperties): void;
3525
+ setLinearVelocity(value: Vec3Like): void;
3526
+ getLinearVelocity(): Vector3;
3527
+ getLinearVelocityToRef(result: Vector3): void;
3528
+ setAngularVelocity(value: Vec3Like): void;
3529
+ getAngularVelocity(): Vector3;
3530
+ getAngularVelocityToRef(result: Vector3): void;
3531
+ applyImpulse(impulse: Vec3Like, location: Vec3Like): void;
3532
+ applyForce(force: Vec3Like, location: Vec3Like): void;
3533
+ dispose(): void;
3466
3534
 
3467
3535
  /** Type of a Physics V2 constraint. Values match Babylon.js `PhysicsConstraintType`. */
3468
3536
  export declare enum PhysicsConstraintType {
@@ -3494,6 +3562,18 @@ export declare class PhysicsEngine {
3494
3562
  /** Current world gravity. */
3495
3563
  dispose(): void;
3496
3564
  }
3497
3565
 
3566
+ export declare interface PhysicShapeOptions {
3567
+ type?: PhysicsShapeType;
3568
+ parameters?: PhysicsShapeParameters;
3569
+ pluginData?: PhysicsShape_2;
3570
+ }
3571
+
3572
+ export declare interface PhysicsMaterial {
3573
+ friction?: number;
3574
+ staticFriction?: number;
3575
+ restitution?: number;
3576
+ }
3577
+
3498
3578
  /** How a body moves. Values match Babylon.js `PhysicsMotionType`. */
3499
3579
  export declare enum PhysicsMotionType {
3500
3580
  STATIC = 0,
@@ -3508,8 +3588,18 @@ export declare enum PhysicsPrestepType {
3508
3588
  ACTION = 2
3509
3589
  }
3510
3590
 
3511
- export declare class PhysicsShape {
3512
- constructor();
3591
+ /** Babylon.js-shaped collision shape backed by a Babylon Lite physics shape. */
3592
+ export declare class PhysicsShape {
3513
3593
  constructor(options: PhysicShapeOptions, scene: Scene);
3514
3594
  getClassName(): string;
3595
+ get type(): PhysicsShapeType;
3596
+ set filterMembershipMask(value: number);
3597
+ get filterMembershipMask(): number;
3598
+ set filterCollideMask(value: number);
3599
+ get filterCollideMask(): number;
3600
+ set material(value: PhysicsMaterial);
3601
+ get material(): PhysicsMaterial;
3602
+ set isTrigger(value: boolean);
3603
+ get isTrigger(): boolean;
3604
+ dispose(): void;
3515
3605
  }
3516
3606
 
3517
3607
  /** The type of a Havok physics collision shape. Values match Babylon.js `PhysicsShapeType`. */
@@ -3527,6 +3617,28 @@ export declare enum PhysicsShapeType {
3527
3617
  /** A pickable compat mesh: a regular `Mesh` or a `GaussianSplattingMesh`. */
3528
3618
  declare type PickableMesh = Mesh | GaussianSplattingMesh;
3529
3619
 
3620
+ /** Babylon.js-compatible result of a scene pick. */
3621
+ export declare class PickingInfo {
3622
+ hit: boolean;
3623
+ distance: number;
3624
+ pickedPoint: Vector3 | null;
3625
+ pickedMesh: TransformNode | null;
3626
+ bu: number;
3627
+ bv: number;
3628
+ faceId: number;
3629
+ subMeshFaceId: number;
3630
+ subMeshId: number;
3631
+ pickedSprite: null;
3632
+ thinInstanceIndex: number;
3633
+ ray: Ray | null;
3634
+ originMesh: TransformNode | null;
3635
+ aimTransform: TransformNode | null;
3636
+ gripTransform: TransformNode | null;
3637
+ private _normal;
3638
+ private _worldNormal;
3530
3639
  getNormal(useWorldCoordinates?: boolean, _useVerticesNormals?: boolean): Vector3 | null;
3640
+ getTextureCoordinates(_uvSet?: string): Vector2 | null;
3641
+ }
3642
+
3531
3643
  declare type PickListItem = PickableMesh | {
3532
3644
  mesh: PickableMesh;
3533
3645
  material?: unknown;
@@ -3600,6 +3712,44 @@ export declare class PointsCloudSystem {
3600
3712
  constructor();
3601
3713
  }
3602
3714
 
3715
+ /** Babylon.js-compatible polar-coordinate value object. */
3716
+ export declare class Polar {
3717
+ radius: number;
3718
+ theta: number;
3719
+ constructor(radius: number, theta: number);
3720
+ getClassName(): string;
3721
+ toString(): string;
3722
+ asArray(): number[];
3723
+ addToRef(polar: Polar, ref: Polar): Polar;
3724
+ add(polar: Polar): Polar;
3725
+ addInPlace(polar: Polar): this;
3726
+ addInPlaceFromFloats(radius: number, theta: number): this;
3727
+ subtractToRef(polar: Polar, ref: Polar): Polar;
3728
+ subtract(polar: Polar): Polar;
3729
+ subtractInPlace(polar: Polar): this;
3730
+ subtractFromFloatsToRef(radius: number, theta: number, ref: Polar): Polar;
3731
+ subtractFromFloats(radius: number, theta: number): Polar;
3732
+ multiplyToRef(polar: Polar, ref: Polar): Polar;
3733
+ multiply(polar: Polar): Polar;
3734
+ multiplyInPlace(polar: Polar): this;
3735
+ divideToRef(polar: Polar, ref: Polar): Polar;
3736
+ divide(polar: Polar): Polar;
3737
+ divideInPlace(polar: Polar): this;
3738
+ clone(): Polar;
3739
+ copyFrom(source: Polar): this;
3740
+ copyFromFloats(radius: number, theta: number): this;
3741
+ scaleToRef(scale: number, ref: Polar): Polar;
3742
+ scale(scale: number): Polar;
3743
+ scaleInPlace(scale: number): this;
3744
+ set(radius: number, theta: number): this;
3745
+ setAll(value: number): this;
3746
+ toVector2ToRef(ref: Vector2): Vector2;
3747
+ toVector2(): Vector2;
3748
+ static FromVector2ToRef(vector: Vector2, ref: Polar): Polar;
3749
+ static FromVector2(vector: Vector2): Polar;
3750
+ static FromArray(array: number[]): Polar;
3751
+ }
3752
+
3603
3753
  export declare class PositionGizmo extends GizmoBase {
3604
3754
  private _attached;
3605
3755
  private _xGizmo;
3606
3756
  private _yGizmo;
@@ -4052,8 +4202,8 @@ export declare class Scene extends AbstractScene {
4052
4202
  /** Babylon.js fog-mode c
4053
4203
  isReady(): boolean;
4054
4204
  /** Synchronous CPU picking — unsupported. Babylon Lite uses async GPU picking. */
4055
4205
  pick(): never;
4056
- /** Synchronous ray picking — unsupported. */
4057
- pickWithRay(): never;
4058
4206
  /**
4207
+ /** Synchronous CPU ray picking over Babylon Lite's scene-mesh picker. */
4208
+ pickWithRay(ray: Ray, predicate?: (mesh: TransformNode) => boolean, fastCheck?: boolean, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
4059
4209
  /**
4060
4210
  * Babylon.js `scene.enablePhysics(gravity, plugin)`. Wires the given Havok V2
4061
4211
  * {@link HavokPlugin} to this scene, creating the native Lite physics world and
4062
4212
  * registering per-frame stepping. The plugin's `useDeltaForWorldStep` flag
@@ -4211,18 +4361,11 @@ export declare class Size {
4211
4361
  static Zero(): Size;
4212
4362
  }
4213
4363
 
4214
- /**
4215
- * Throwing stubs for additional Babylon.js core/loaders symbols that Babylon
4216
- * Lite either does not implement, or exposes only through a different native API
4217
- * that the compat layer does not wrap 1:1.
4218
- *
4219
- * Every stub throws {@link LiteCompatError} on use with a pointer to the native
4220
- * Babylon Lite alternative where one exists. This keeps the completeness
4221
- * invariant — every core/loaders symbol resolves to an import and fails loudly
4222
- * rather than silently.
4223
- */
4224
4364
  export declare class Skeleton {
4225
- constructor();
4365
+ readonly name: string;
4366
+ readonly id: string;
4367
+ readonly bones: Bone[];
4226
4368
  constructor(_name?: string, _id?: string, _scene?: Scene);
4227
4369
  getBoneIndexByName(name: string): number;
4370
+ getBoneByName(name: string): Bone | null;
4228
4371
  }
4229
4372
 
4230
4373
  /**
@@ -4316,6 +4459,45 @@ declare interface SphereOptions {
4316
4459
  segments?: number;
4317
4460
  }
4318
4461
 
4462
+ /** Babylon.js-compatible spherical-coordinate value object. */
4463
+ export declare class Spherical {
4464
+ radius: number;
4465
+ theta: number;
4466
+ phi: number;
4467
+ constructor(radius: number, theta: number, phi: number);
4468
+ getClassName(): string;
4469
+ toString(): string;
4470
+ asArray(): number[];
4471
+ addToRef(spherical: Spherical, ref: Spherical): Spherical;
4472
+ add(spherical: Spherical): Spherical;
4473
+ addInPlace(spherical: Spherical): this;
4474
+ addInPlaceFromFloats(radius: number, theta: number, phi: number): this;
4475
+ subtractToRef(spherical: Spherical, ref: Spherical): Spherical;
4476
+ subtract(spherical: Spherical): Spherical;
4477
+ subtractInPlace(spherical: Spherical): this;
4478
+ subtractFromFloatsToRef(radius: number, theta: number, phi: number, ref: Spherical): Spherical;
4479
+ subtractFromFloats(radius: number, theta: number, phi: number): Spherical;
4480
+ multiplyToRef(spherical: Spherical, ref: Spherical): Spherical;
4481
+ multiply(spherical: Spherical): Spherical;
4482
+ multiplyInPlace(spherical: Spherical): this;
4483
+ divideToRef(spherical: Spherical, ref: Spherical): Spherical;
4484
+ divide(spherical: Spherical): Spherical;
4485
+ divideInPlace(spherical: Spherical): this;
4486
+ clone(): Spherical;
4487
+ copyFrom(source: Spherical): this;
4488
+ copyFromFloats(radius: number, theta: number, phi: number): this;
4489
+ scaleToRef(scale: number, ref: Spherical): Spherical;
4490
+ scale(scale: number): Spherical;
4491
+ scaleInPlace(scale: number): this;
4492
+ set(radius: number, theta: number, phi: number): this;
4493
+ setAll(value: number): this;
4494
+ toVector3ToRef(ref: Vector3): Vector3;
4495
+ toVector3(): Vector3;
4496
+ static FromVector3ToRef(vector: Vector3, ref: Spherical): Spherical;
4497
+ static FromVector3(vector: Vector3): Spherical;
4498
+ static FromArray(array: number[]): Spherical;
4499
+ }
4500
+
4319
4501
  export declare class SpotLight extends Light {
4320
4502
  constructor(name: string, position: Vector3, direction: Vector3, angle: number, exponent: number, scene?: Scene);
4321
4503
  getClassName(): string;
4322
4504
  get angle(): number;
@@ -4773,7 +4955,7 @@ export declare function transformCoordinates(vector: Vector3, transformation: Ma
4773
4955
  * Wraps a Lite scene node (`_node`): either a standalone Lite transform node, or
4774
4956
  * (for meshes) the Lite mesh itself, which also carries the transform.
4775
4957
  */
4776
- export declare class TransformNode extends Node_2 {
4777
4958
  constructor(name: string, scene?: Scene, liteNode?: SceneNode);
4959
+ export declare class TransformNode extends Node_2 {
4778
4960
  physicsBody: PhysicsBody | null;
4779
4961
  constructor(name: string, scene?: Scene, liteNode?: SceneNode);
4780
4962
  getClassName(): string;
4781
4963
  get position(): Vector3;
4782
4964
  set position(value: Vector3);
@@ -4865,6 +5047,10 @@ export declare class Vector2 {
4865
5047
  length(): number;
4866
5048
  lengthSquared(): number;
4867
5049
  normalize(): this;
5050
+ normalizeToRef<T extends {
5051
+ x: number;
5052
+ y: number;
5053
+ }>(result: T): T;
4868
5054
  clone(): Vector2;
4869
5055
  equals(other: Vector2): boolean;
4870
5056
  asArray(): [number, number];