@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/README.md +64 -32
- package/index.d.ts +219 -19
- package/index.js +790 -545
- package/index.js.map +1 -1
- package/{meshes-CTqDBeGc.js → meshes-C-PkzbPM.js} +456 -22
- package/meshes-C-PkzbPM.js.map +1 -0
- package/navigation.d.ts +185 -17
- package/navigation.js +1 -1
- package/package.json +4 -4
- package/meshes-CTqDBeGc.js.map +0 -1
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
|
-
|
|
2203
|
-
|
|
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,
|
|
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.
|
|
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": "
|
|
51
|
-
"sourceVersion": "
|
|
52
|
-
"builtAgainstLite": "1.
|
|
50
|
+
"azureBuildId": "62229",
|
|
51
|
+
"sourceVersion": "2dddc888f6695e433ab29ae5918bee221375d86f",
|
|
52
|
+
"builtAgainstLite": "1.39.0"
|
|
53
53
|
}
|
|
54
54
|
}
|