@babylonjs/lite-compat 1.36.0-preview → 1.37.1-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/navigation.d.ts CHANGED
@@ -148,12 +148,19 @@ declare abstract class AbstractEngine {
148
148
  private _ensureInitialized;
149
149
  }
150
150
 
151
+ /** Babylon.js `AbstractEngineOptions` subset accepted by the compat engine. */
152
+ declare interface AbstractEngineOptions extends EngineOptions {
153
+ antialias?: boolean;
154
+ adaptToDeviceRatio?: boolean;
155
+ useLargeWorldRendering?: boolean;
156
+ useReverseDepthBuffer?: boolean;
157
+ }
158
+
151
159
  /**
152
160
  * Babylon.js `AbstractMesh` — a renderable transform node with a material,
153
161
  * visibility, and shadow-receipt. Concrete meshes derive from this.
154
162
  */
155
- declare class AbstractMesh extends TransformNode {
156
163
  private _material;
157
- private _meshBlendingTag;
164
+ declare class AbstractMesh extends TransformNode {
158
165
  private _material;
159
166
  private _meshBlendingTag;
160
167
  protected _visible: boolean;
161
168
  constructor(name: string, lite: Mesh, scene?: Scene);
162
169
  getClassName(): string;
163
170
  get material(): CompatMaterial | null;
@@ -358,13 +365,13 @@ declare class Animation_2 {
358
365
  getKeys(): IAnimationKey[];
359
366
  getHighestFrame(): number;
360
367
  /**
361
- * Assigns the easing function used to transform each non-STEP segment's normalized progress.
362
- * @param easingFunction - A Babylon.js-shaped easing object, or `null` to restore linear progress.
368
+ * Assigns default easing for non-STEP segments without a key-specific easing function.
369
+ * @param easingFunction - A Babylon.js-shaped easing object, or `null` to use linear progress on keys without an override.
363
370
  */
364
371
  setEasingFunction(easingFunction: IEasingFunction | null): void;
365
372
  /**
366
373
  * Gets the easing function currently assigned to this animation.
367
- * @returns The assigned easing object, or `null` when interpolation uses linear progress.
374
+ * @returns The assigned default easing object, or `null` when keys without an override use linear progress.
368
375
  */
369
376
  getEasingFunction(): IEasingFunction | null;
370
377
  /** Evaluate the animated value at `frame`, clamped to the key range. */
@@ -658,6 +665,11 @@ declare class CubeTexture extends BaseTexture {
658
665
  gammaSpace: boolean;
659
666
  level: number;
660
667
  /** Fires when the cube map is "ready" (resolved on a microtask in this compat layer). */
661
668
  readonly onLoadObservable: Observable<CubeTexture>;
669
+ /**
670
+ * Babylon.js `CubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
671
+ * texture as its `environmentTexture` turns its image-based lighting with it (see `Scene.environmentTexture`).
672
+ */
673
+ rotationY: number;
662
674
  private _ready;
663
675
  private readonly _readyPromise;
664
676
  constructor(url: string, _scene?: unknown, _extensions?: unknown, _noMipmap?: boolean, _files?: unknown, onLoad?: (() => void) | null, _onError?: unknown, _format?: unknown, _prefiltered?: boolean);
@@ -783,6 +795,11 @@ declare class HDRCubeTexture extends BaseTexture {
783
795
  gammaSpace: boolean;
784
796
  level: number;
785
797
  /** Fires when the HDR environment is "ready" (resolved on a microtask). */
786
798
  readonly onLoadObservable: Observable<HDRCubeTexture>;
799
+ /**
800
+ * Babylon.js `HDRCubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
801
+ * texture as its `environmentTexture` turns its image-based lighting with it (see `Scene.environmentTexture`).
802
+ */
803
+ rotationY: number;
787
804
  private _ready;
788
805
  private readonly _readyPromise;
789
806
  constructor(url: string, _sceneOrEngine?: unknown, size?: number, _noMipmap?: boolean, _generateHarmonics?: boolean, _gammaSpace?: boolean, _prefilterOnLoad?: boolean, onLoad?: (() => void) | null);
@@ -809,6 +826,8 @@ declare interface IAnimationKey {
809
826
  value: AnimationValue;
810
827
  /** Babylon.js per-key interpolation hint (`AnimationKeyInterpolation`). */
811
828
  interpolation?: number;
829
+ /** Easing for the segment starting at this key; overrides animation-level easing. */
830
+ easingFunction?: IEasingFunction;
812
831
  }
813
832
 
814
833
  /** Structural vector/quaternion value accepted by Babylon.js animation keys. */
@@ -1001,6 +1020,7 @@ declare class Matrix {
1001
1020
  multiplyToRef(other: Matrix, result: Matrix): Matrix;
1002
1021
  transpose(): Matrix;
1003
1022
  determinant(): number;
1023
+ /** Babylon.js `invert`: inverts this matrix in place and returns it. */
1004
1024
  invert(): Matrix;
1005
1025
  invertToRef(result: Matrix): Matrix;
1006
1026
  getTranslation(): Vector3;
@@ -1637,8 +1657,10 @@ declare class Plane {
1637
1657
  declare class PointerInfo {
1638
1658
  type: number;
1639
1659
  event: PointerEvent | WheelEvent;
1640
- private readonly _pickInfo;
1641
- constructor(type: number, event: PointerEvent | WheelEvent, _pickInfo: PickingInfo | null);
1660
+ private _pickInfo;
1661
+ private _pick;
1662
+ constructor(type: number, event: PointerEvent | WheelEvent, _pickInfo: PickingInfo | null, _pick?: (() => PickingInfo) | null);
1663
+ /** Like Babylon.js lazy picking: without a precomputed pick, `_pick` runs on the first read only. */
1642
1664
  get pickInfo(): PickingInfo | null;
1643
1665
  }
1644
1666
 
@@ -1655,6 +1677,7 @@ declare class Quaternion {
1655
1677
  constructor(x?: number, y?: number, z?: number, w?: number);
1656
1678
  set(x: number, y: number, z: number, w: number): this;
1657
1679
  copyFrom(source: Quaternion): this;
1680
+ /** Babylon.js `multiply`: the product `this · other` as a new quaternion. */
1658
1681
  multiply(other: Quaternion): Quaternion;
1659
1682
  length(): number;
1660
1683
  normalize(): this;
@@ -1806,6 +1829,9 @@ declare class Scene extends AbstractScene {
1806
1829
  /** Babylon.js fog-mode constant
1807
1830
  private readonly _engine;
1808
1831
  private _activeCamera;
1809
1832
  cameraToUseForPointers: Camera | null;
1833
+ /** Babylon.js `scene.pointerX` / `pointerY`: the last pointer position in CSS pixels relative to the canvas. */
1834
+ pointerX: number;
1835
+ pointerY: number;
1810
1836
  private _defaultMaterial;
1811
1837
  private _fogMode;
1812
1838
  private _fogStart;
@@ -1813,6 +1839,8 @@ declare class Scene extends AbstractScene {
1813
1839
  /** Babylon.js fog-mode constant
1814
1840
  private _fogDensity;
1815
1841
  private _fogColor;
1816
1842
  private _started;
1817
1843
  private _envTexture;
1844
+ /** Environment lighting rotation last forwarded to Lite. */
1845
+ private _envRotation;
1818
1846
  private _brdfTexture;
1819
1847
  private _defaultEnvOptions;
1820
1848
  private readonly _shadowGenerators;
@@ -1902,6 +1930,13 @@ declare class Scene extends AbstractScene {
1902
1930
  /** Babylon.js fog-mode constant
1903
1931
  set clipPlane(value: Plane | null);
1904
1932
  get environmentTexture(): CubeTexture | HDRCubeTexture | null;
1905
1933
  set environmentTexture(value: CubeTexture | HDRCubeTexture | null);
1934
+ /**
1935
+ * Forward the environment texture's `rotationY` to the image-based lighting only. As in Babylon.js, a skybox keeps the
1936
+ * orientation it was created with (see {@link createDefaultSkybox}) and the `createDefaultEnvironment` background never
1937
+ * turns. Also runs every frame, so the texture needs no link back to the scenes that use it. A scene whose
1938
+ * environment is never rotated never calls Lite.
1939
+ */
1940
+ private _syncEnvironmentRotation;
1906
1941
  /**
1907
1942
  * Babylon.js `scene.environmentBRDFTexture` — the BRDF lookup used by PBR materials.
1908
1943
  * Babylon.js defaults this to an embedded Base64 LUT and lets apps swap in one of the
@@ -2258,10 +2293,7 @@ declare class WebGPUEngine extends AbstractEngine {
2258
2293
  }
2259
2294
 
2260
2295
  /** Babylon.js `WebGPUEngineOptions` subset accepted by the compat engine. */
2261
- declare interface WebGPUEngineOptions extends EngineOptions {
2262
- antialias?: boolean;
2263
- adaptToDeviceRatio?: boolean;
2264
- useLargeWorldRendering?: boolean;
2296
+ declare interface WebGPUEngineOptions extends AbstractEngineOptions {
2265
2297
  canvasToneMapping?: GPUCanvasToneMapping;
2266
2298
  canvasColorSpace?: PredefinedColorSpace;
2267
2299
  }
package/navigation.js CHANGED
@@ -1,4 +1,4 @@
1
- import { D as registerMeshAtStart, Q as Vector3, b as Mesh } from "./meshes-zeNif9yt.js";
1
+ import { D as registerMeshAtStart, Q as Vector3, b as Mesh } from "./meshes-BqMDWl4h.js";
2
2
  import { addAgent, addBoxObstacle, addCylinderObstacle, agentGoto, computePath, createDebugNavMeshGeometry, createMeshFromData, createNavCrowd, createNavMesh, createNavigationPluginAsync, getAgentPosition, getClosestPoint, raycast, removeObstacle, updateNavCrowd, updateNavMeshObstacles } from "@babylonjs/lite";
3
3
  //#region src/navigation/navigation.ts
4
4
  /**
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@babylonjs/lite-compat",
3
- "version": "1.36.0-preview",
3
+ "version": "1.37.1-preview",
4
4
  "license": "Apache-2.0",
5
5
  "type": "module",
6
6
  "description": "Opt-in Babylon.js-shaped compatibility layer implemented on top of the Babylon Lite public API. Provides a migration runway from Babylon.js to Babylon Lite.",
@@ -47,8 +47,8 @@
47
47
  }
48
48
  },
49
49
  "babylonLiteRelease": {
50
- "azureBuildId": "61061",
51
- "sourceVersion": "5241e29f5a88ff23534a11d3114ac8ea983c5961",
52
- "builtAgainstLite": "1.36.0"
50
+ "azureBuildId": "61567",
51
+ "sourceVersion": "d60da9b48269c6af0ff48da2469e01d0e7bc126d",
52
+ "builtAgainstLite": "1.37.1"
53
53
  }
54
54
  }