@babylonjs/lite-compat 1.38.1-preview → 1.39.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/navigation.d.ts CHANGED
@@ -1,5 +1,6 @@
1
1
  import { AnisotropyProps } from '@babylonjs/lite';
2
2
  import { ClearCoatProps } from '@babylonjs/lite';
3
+ import { EngineContext } from '@babylonjs/lite';
3
4
  import { EngineOptions } from '@babylonjs/lite';
4
5
  import { IridescenceProps } from '@babylonjs/lite';
5
6
  import { LineMaterial } from '@babylonjs/lite';
@@ -162,12 +163,19 @@ declare interface AbstractEngineOptions extends EngineOptions {
162
163
  * visibility, and shadow-receipt. Concrete meshes derive from this.
163
164
  */
164
165
  declare class AbstractMesh extends TransformNode {
165
166
  private _material;
166
167
  private _meshBlendingTag;
168
+ protected _visibilityValue: number;
167
169
  protected _visible: boolean;
168
170
  constructor(name: string, lite: Mesh, scene?: Scene);
169
171
  getClassName(): string;
170
172
  get material(): CompatMaterial | null;
171
173
  set material(value: CompatMaterial | null);
172
174
  get isVisible(): boolean;
173
175
  set isVisible(value: boolean);
176
+ /** Raw finite Babylon visibility; rendering clamps it to [0, 1]. Independent of isVisible. */
177
+ get visibility(): number;
178
+ set visibility(value: number);
179
+ private _validateCompatOpacityMaterial;
180
+ /** A glTF node owns its immediate primitive meshes, never a child glTF node's primitives. */
181
+ private _opacityTargets;
174
182
  get isPickable(): boolean;
175
183
  set isPickable(value: boolean);
176
184
  get receiveShadows(): boolean;
@@ -487,6 +495,19 @@ declare abstract class BaseTexture {
487
495
  dispose(): void;
488
496
  }
489
497
 
498
+ declare class Bone {
499
+ private _enabled;
500
+ readonly name: string;
501
+ readonly parent: Bone | null;
490
502
  constructor(_name?: string, _skeleton?: Skeleton);
491
503
  getName(): string;
504
+ getSkeleton(): Skeleton;
505
+ setPosition(position: Vector3, space?: number): this;
506
+ setRotationQuaternion(rotation: Quaternion, space?: number): this;
507
+ setScale(scale: Vector3): this;
508
+ setEnabled(value: boolean): void;
509
+ isEnabled(): boolean;
510
+ returnToRest(): void;
511
+ }
512
+
492
513
  declare class BoundingBox {
493
514
  readonly minimum: Vector3;
494
515
  readonly maximum: Vector3;
@@ -553,6 +574,12 @@ declare abstract class Camera extends Node_2 {
553
574
  private _orthoTop;
554
575
  protected constructor(name: string, scene?: Scene);
555
576
  getClassName(): string;
577
+ /**
578
+ * Babylon.js `Camera.resetViewHistory()` invalidates temporal history owned by
579
+ * every render pass using this camera. Lite's TAA/history state is owned by
580
+ * independently-created frame-graph tasks, with no camera-to-task registry.
581
+ */
582
+ resetViewHistory(): never;
556
583
  get fov(): number;
557
584
  set fov(value: number);
558
585
  get minZ(): number;
@@ -1111,6 +1138,8 @@ declare class Matrix {
1111
1138
  declare class Mesh_2 extends AbstractMesh {
1112
1139
  constructor(name: string, sceneOrLite?: Scene | Mesh, scene?: Scene);
1113
1140
  getClassName(): string;
1114
1141
  private _morphTargetManager;
1142
+ private readonly _ownedMorphTargetManagers;
1143
+ private _retainMorphTargetManagerOwnership;
1115
1144
  /**
1116
1145
  * Babylon.js `mesh.morphTargetManager`. Babylon Lite builds morph GPU data via
1117
1146
  * `createMorphTargets` and stores it on the Lite mesh; the compat manager is
@@ -1118,8 +1147,7 @@ declare class Mesh_2 extends AbstractMesh {
1118
1147
  * CPU geometry exists) and assigns it onto the Lite mesh before registration.
1119
1148
  */
1120
1149
  get morphTargetManager(): MorphTargetManager | null;
1121
- set morphTargetManager(value: MorphTargetManager | null);
1122
- /** Legacy `Mesh.CreateSphere(name, segments, diameter, scene)`. */
1150
+ set morphTargetManager(value: MorphTargetManager | null);
1123
1151
  /** Legacy `Mesh.CreateSphere(name, segments, diameter, scene)`. */
1124
1152
  static CreateSphere(name: string, segments: number, diameter: number, scene: Scene): Mesh_2;
1125
1153
  /** Legacy `Mesh.CreateBox(name, size, scene)`. */
1126
1154
  static CreateBox(name: string, size: number, scene: Scene): Mesh_2;
@@ -1197,16 +1225,16 @@ declare class MorphTarget {
1197
1225
  /** Babylon.js `MorphTarget.setNormals(data)` — absolute target normals. */
1198
1226
  setNormals(data: Float32Array | number[] | null): void;
1199
1227
  /** Babylon.js `MorphTarget.getNormals()`. */
1200
- getNormals(): Float32Array | null;
1201
- }
1228
+ getNormals(): Float32Array | null;
1202
1229
 
1203
1230
  /** Babylon.js `MorphTargetManager` — owns a mesh's morph targets (Babylon Lite supports up to 4). */
1204
1231
  declare class MorphTargetManager {
1205
1232
  private readonly _targets;
1206
- constructor(_scene?: Scene);
1207
- get numTargets(): number;
1233
+ constructor(_scene?: Scene);
1208
1234
  get numTargets(): number;
1209
1235
  getTarget(index: number): MorphTarget;
1210
1236
  /** Babylon.js `MorphTargetManager.addTarget(target)`. */
1211
- addTarget(target: MorphTarget): void;
1237
+ addTarget(target: MorphTarget): void;
1212
1238
  /** Babylon.js `MorphTargetManager.dispose()` — release this manager's morph-resource claim. */
1239
+ dispose(): void;
1240
+ }
1213
1241
 
1214
1242
  /**
1215
1243
  * Result of {@link RecastNavigationJSPluginV2.createNavMesh}. Babylon.js's
@@ -1325,6 +1353,74 @@ declare class Observable<T> {
1325
1353
  */
1326
1354
  declare type ObserverCallback<T> = (eventData: T) => void;
1327
1355
 
1356
+ /**
1357
+ * Babylon.js `ParticleSystem` — the built output of one NPE graph system. Backed
1358
+ * by a Lite `ParticleSystem`; the deterministic prewarm-and-freeze pattern used by
1359
+ * ported parity scenes (seed RNG → `start()` → N × `animate()` → `updateSpeed = 0`)
1360
+ * maps directly onto Lite's `startParticleSystem` / `animateParticleSystem`, with a
1361
+ * camera-facing billboard built and synced once the scene starts.
1362
+ */
1363
+ declare class ParticleSystem {
1364
+ name: string;
1328
1365
  /**
1366
+ * Babylon.js `ParticleSystem.preWarmStepOffset` — the step ratio applied during
1367
+ * prewarm cycles. Multiplies {@link updateSpeed} on every `animate(true)` call,
1368
+ * matching Babylon.js (which uses `updateSpeed * preWarmStepOffset` while
1369
+ * prewarming and the regular animation ratio otherwise).
1370
+ */
1371
+ preWarmStepOffset: number;
1372
+ private _texture;
1373
+ private _billboardScheduled;
1374
+ private _billboardOwnedBySet;
1375
+ private _started;
1376
+ /**
1377
+ * Babylon.js `new ParticleSystem(name, capacity, scene)`. The imperative
1378
+ * construction API (emitters, over-lifetime gradients, `minEmitBox`, a
1379
+ * GPU-compute path) is not backed: Babylon Lite builds particle systems only
1380
+ * from a serialized Node Particle Editor graph. Load a graph via
1381
+ * `NodeParticleSystemSet.Parse` / `ParseFromSnippetAsync` → `buildAsync` and read
1382
+ * its {@link ParticleSystemSet.systems} instead.
1383
+ */
1384
+ constructor();
1329
1385
  getClassName(): string;
1386
+ /** Babylon.js `ParticleSystem.updateSpeed` — simulation advance per frame. Proxies the Lite system. */
1387
+ get updateSpeed(): number;
1388
+ set updateSpeed(value: number);
1389
+ /**
1390
+ * Babylon.js `ParticleSystem.particleTexture` — the sprite texture. Recorded and
1391
+ * bound onto the Lite system when the billboard is built at engine start (the
1392
+ * compat `Texture` loads asynchronously, so its GPU handle is read after the
1393
+ * scene's pending texture loads settle).
1394
+ */
1395
+ get particleTexture(): Texture | null;
1396
+ set particleTexture(value: Texture | null);
1397
+ /**
1398
+ * Babylon.js `ParticleSystem.start()` — begin emission. Forwards to Lite
1399
+ * `startParticleSystem` (which clears the stopped flag and resets the frame
1400
+ * counter, so `start()` → `stop()` → `start()` resumes emission) and schedules
1401
+ * the camera-facing billboard build for engine start. The billboard build is
1402
+ * separately guarded, so it happens exactly once however often `start()` runs.
1403
+ */
1404
+ start(): void;
1405
+ /**
1406
+ * Babylon.js `ParticleSystem.animate(preWarmOnly?)` — advance the simulation by
1407
+ * one deterministic step. Forwards to Lite `animateParticleSystem` with Babylon.js's
1408
+ * step ratio: {@link preWarmStepOffset} while prewarming, otherwise the ratio `1`
1409
+ * used by the parity ports' seeded step loop.
1410
+ */
1411
+ animate(preWarmOnly?: boolean): void;
1412
+ /** Babylon.js `ParticleSystem.stop()` — stop emission; live particles drain. Forwards to Lite `stopParticleSystem`. */
1413
+ stop(): void;
1414
+ /** Babylon.js `ParticleSystem.isStarted()` — whether the system is currently emitting. */
1415
+ isStarted(): boolean;
1416
+ /** Babylon.js `ParticleSystem.dispose()` — stop the system. */
1417
+ dispose(): void;
1330
1418
  /**
1419
+ * Schedule the one-time billboard build. Deferred to engine start (via the
1420
+ * scene's `_deferAdd`, which runs after pending texture loads settle), so the
1421
+ * particle system is already prewarmed/frozen and its texture GPU handle is
1422
+ * ready. Mirrors the native Lite port's build → sync → add sequence.
1423
+ */
1424
+ private _scheduleBillboard;
1425
+ }
1426
+
1331
1427
  /** Babylon.js `PBRAnisotropicConfiguration` — the `pbr.anisotropy` sub-object over Lite `AnisotropyProps`. */
1332
1428
  declare class PBRAnisotropicConfiguration {
1333
1429
  private readonly _props;
@@ -1875,6 +1971,10 @@ declare class Scene extends AbstractScene {
1875
1971
  /** Babylon.js fog-mode constant
1876
1972
  /** Babylon.js `scene.getAnimationGroupByName(name)` — first loaded animation group with a matching name, else `null`. */
1877
1973
  getAnimationGroupByName(name: string): AnimationGroup | null;
1878
1974
  get animatables(): Animatable_2[];
1975
+ /** Babylon.js `scene.skeletons` — loader-produced skeletons currently used by scene meshes. */
1976
+ get skeletons(): Skeleton[];
1977
+ /** Babylon.js `scene.particleSystems` — registered Lite node-particle systems in scene order. */
1978
+ get particleSystems(): ParticleSystem[];
1879
1979
  private readonly _engine;
1880
1980
  private _activeCamera;
1881
1981
  cameraToUseForPointers: Camera | null;
@@ -1896,9 +1996,16 @@ declare class Scene extends AbstractScene {
1896
1996
  /** Babylon.js fog-mode constant
1897
1997
  private readonly _pendingTextures;
1898
1998
  private readonly _pendingGroundBakes;
1899
1999
  private readonly _pendingMorphBuilds;
2000
+ private readonly _ownedMorphTargetManagers;
1900
2001
  private _materialPluginsRequested;
1901
2002
  private readonly _pendingMaterialPluginReconciliations;
1902
- private readonly _runningAnimatables;
1903
2003
  private readonly _animationGroupCache;
1904
2004
  private _ambientColor;
2005
+ private readonly _runningAnimatables;
1905
2006
  private readonly _animationGroupCache;
2007
+ private readonly _skeletonCache;
2008
+ private readonly _skeletons;
2009
+ private readonly _particleSystemCache;
2010
+ private readonly _particleSystems;
2011
+ private readonly _retiredParticleSystems;
2012
+ private _disposed;
1906
2013
  private _ambientColor;
1907
2014
  private _environmentIntensity;
1908
2015
  private _imageProcessingConfiguration;
1909
2016
  /** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
1910
2017
  readonly uniqueId: number;
@@ -2098,6 +2205,17 @@ declare enum ShaderLanguage {
2098
2205
  WGSL = 1
2099
2206
  }
2100
2207
 
2208
+ declare class Skeleton {
2209
+ readonly name: string;
2210
+ readonly id: string;
2211
+ readonly bones: Bone[];
2101
2212
  constructor(_name?: string, _id?: string, _scene?: Scene);
2102
2213
  getBoneIndexByName(name: string): number;
2214
+ getBoneByName(name: string): Bone | null;
2215
+ /** Babylon.js `Skeleton.returnToRest()` — clear every compat bone override. */
2216
+ returnToRest(): void;
2217
+ /** Babylon.js `Skeleton.prepare()` — Lite keeps loaded/evaluated bone matrices ready, so no additional bake is needed. */
2218
+ prepare(_dontCheckFrameId?: boolean): void;
2219
+ }
2220
+
2103
2221
  /**
2104
2222
  * Babylon.js-compatible Misc utilities — the pure-JS subset that has no Babylon
2105
2223
  * Lite or GPU dependency: `SmartArray`, `StringDictionary`, `Tags`,
@@ -2176,6 +2294,47 @@ declare class StandardMaterial extends PushMaterial {
2176
2294
  /** Diffuse colour as
2177
2295
  clone(name: string): StandardMaterial;
2178
2296
  }
2179
2297
 
2298
+ declare class Texture extends BaseTexture {
2299
+ private readonly _ready;
2300
+ private _onLoadObservable;
2301
+ /** Babylon.js sampling-mode constants (numeric parity). */
2302
+ static readonly NEAREST_SAMPLINGMODE = 1;
2303
+ static readonly BILINEAR_SAMPLINGMODE = 2;
2304
+ static readonly TRILINEAR_SAMPLINGMODE = 3;
2305
+ static readonly NEAREST_NEAREST = 8;
2306
+ static readonly LINEAR_LINEAR = 11;
2307
+ /** Babylon.js coordinate-mode constants (numeric parity). */
2308
+ static readonly CLAMP_ADDRESSMODE = 0;
2309
+ static readonly WRAP_ADDRESSMODE = 1;
2310
+ static readonly MIRROR_ADDRESSMODE = 2;
2311
+ /** Babylon.js texture UV tiling (applied to the Lite material at bind time). */
2312
+ uScale: number;
2313
+ vScale: number;
2314
+ uOffset: number;
2315
+ vOffset: number;
2316
+ hasAlpha: boolean;
2317
+ coordinatesIndex: number;
2318
+ /** Babylon.js sampling mode passed at construction (`NEAREST_SAMPLINGMODE` = 1, etc.). */
2319
+ readonly samplingMode: number;
2180
2320
  constructor(url: string, sceneOrEngine: Scene | {
2321
+ _lite: EngineContext;
2322
+ }, noMipmapOrOptions?: unknown, invertY?: boolean, _samplingMode?: number, onLoad?: (() => void) | null);
2181
2323
  private readonly _noMipmap;
2324
+ getClassName(): string;
2325
+ /**
2326
+ * Babylon.js `texture.clone()` — a new `Texture` over the same source URL.
2327
+ * UV tiling/offset and sampling are copied; the clone re-resolves the GPU
2328
+ * handle (tracked against the same scene so it is ready at build).
2329
+ */
2330
+ clone(): Texture;
2331
+ whenReadyAsync(): Promise<void>;
2332
+ /** Babylon.js `Texture.onLoadObservable`, allocated only when code subscribes. */
2333
+ get onLoadObservable(): Observable<Texture>;
2334
+ private _notifyLoadObservable;
2335
+ /** Babylon.js `BaseTexture.isReady()` — true once the GPU handle has resolved. */
2336
+ isReady(): boolean;
2337
+ /** Load a texture and resolve once its GPU handle is available. */
2338
+ static LoadAsync(url: string, scene: Scene): Promise<Texture>;
2339
+ }
2340
+
2182
2341
  declare interface TextureLike {
2183
2342
  _lite?: Texture2D;
2184
2343
  whenReadyAsync?(): Promise<void>;
@@ -2186,22 +2345,29 @@ declare interface TextureLike {
2186
2345
  * Wraps a Lite scene node (`_node`): either a standalone Lite transform node, or
2187
2346
  * (for meshes) the Lite mesh itself, which also carries the transform.
2188
2347
  */
2189
- declare class TransformNode extends Node_2 {
2190
2348
  physicsBody: PhysicsBody | null;
2191
2349
  constructor(name: string, scene?: Scene, liteNode?: SceneNode);
2350
+ declare class TransformNode extends Node_2 {
2192
2351
  physicsBody: PhysicsBody | null;
2352
+ private _rotation;
2353
+ private _rotationBinding;
2354
+ private _rotationQuaternion;
2355
+ private _rotationQuaternionBinding?;
2356
+ private _nativeRotationVersion;
2357
+ private readonly _nativeRotationValues;
2358
+ private _isSyncingRotationFromNative;
2359
+ private _sceneDisposeObserver?;
2193
2360
  constructor(name: string, scene?: Scene, liteNode?: SceneNode);
2194
2361
  getClassName(): string;
2195
2362
  get position(): Vector3;
2196
2363
  set position(value: Vector3);
2197
2364
  get rotation(): Vector3;
2198
2365
  set rotation(value: Vector3);
2199
2366
  get scaling(): Vector3;
2200
- set scaling(value: Vector3);
2201
2367
  /**
2202
- * Babylon.js `rotationQuaternion`. Babylon Lite always drives a node's world
2203
- * matrix from a quaternion (its euler `rotation` is a proxy over the same
2204
- * quaternion), so this reads/writes that quaternion. Returns `null` until
2205
- * explicitly assigned, matching Babylon.js's euler-by-default convention.
2206
- */
2368
+ set scaling(value: Vector3);
2369
+ /** Babylon.js `rotationQuaternion`, kept live while Lite receives translated component writes. */
2207
2370
  get rotationQuaternion(): Quaternion | null;
2208
2371
  set rotationQuaternion(value: Quaternion | null);
2209
- /**
2372
+ private _applyEulerRotation;
2373
+ private _applyQuaternionRotation;
2374
+ private _markNativeRotationSynced;
2375
+ private _syncRotationFromNative;
2210
2376
  /**
2211
2377
  * Babylon.js `getChildTransformNodes(directDescendantsOnly?, predicate?)` — the descendants that are transform nodes
2212
2378
  * (meshes included). As in Babylon.js, `predicate` is called on every evaluated descendant.
2213
2379
  */
@@ -2212,7 +2378,9 @@ declare class TransformNode extends Node_2 {
2212
2378
  physicsBody: PhysicsBody | null
2213
2379
  * setter, which keeps the local transform and lets the world move.
2214
2380
  */
2215
2381
  setParent(parent: Node_2 | null): TransformNode;
2216
- protected _applyParent(parent: Node_2 | null): void;
2382
+ protected _applyParent(parent: Node_2 | null): void;
2217
2383
  private _bindRotationSceneDisposal;
2384
+ protected _retireFromScene(): void;
2385
+ }
2218
2386
 
2219
2387
  declare type TrianglePickingPredicate = (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray, i0: number, i1: number, i2: number) => boolean;
2220
2388
 
package/navigation.js CHANGED
@@ -1,4 +1,4 @@
1
- import { D as registerMeshAtStart, Q as Vector3, b as Mesh } from "./meshes-CTqDBeGc.js";
1
+ import { D as registerMeshAtStart, b as Mesh, et as Vector3 } from "./meshes-C-PkzbPM.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
  // 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.38.1-preview",
3
+ "version": "1.39.0-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": "62063",
51
- "sourceVersion": "454a69495947d41f7298f2aed09f8d5f26c5d7cb",
52
- "builtAgainstLite": "1.38.1"
50
+ "azureBuildId": "62229",
51
+ "sourceVersion": "2dddc888f6695e433ab29ae5918bee221375d86f",
52
+ "builtAgainstLite": "1.39.0"
53
53
  }
54
54
  }