@babylonjs/lite-compat 1.27.0-preview → 1.29.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 +24 -22
- package/index.d.ts +293 -39
- package/index.js +737 -78
- package/index.js.map +1 -1
- package/{meshes-CgaKo90D.js → meshes-C1K63hzW.js} +60 -25
- package/meshes-C1K63hzW.js.map +1 -0
- package/navigation.d.ts +149 -26
- package/navigation.js +1 -1
- package/package.json +4 -4
- package/meshes-CgaKo90D.js.map +0 -1
package/index.d.ts
CHANGED
|
@@ -315,7 +315,6 @@ export declare class AbstractMesh extends TransformNode {
|
|
|
315
315
|
private _material;
|
|
316
316
|
* reset: the supplied matrix is independent of the node transform.
|
|
317
317
|
*/
|
|
318
318
|
bakeTransformIntoVertices(transform: Matrix): this;
|
|
319
|
-
dispose(): void;
|
|
320
319
|
}
|
|
321
320
|
|
|
322
321
|
/** Babylon.js `AbstractNamedAudioNode` — an `AbstractAudioNode` with a mutable name. */
|
|
@@ -1140,7 +1139,13 @@ export declare class BVHFileLoader {
|
|
|
1140
1139
|
}
|
|
1141
1140
|
|
|
1142
1141
|
/** Babylon.js `Camera` — base class for all cameras (derives from `Node`). */
|
|
1143
|
-
export declare abstract class Camera extends Node_2 {
|
|
1144
1142
|
private _detach;
|
|
1143
|
+
export declare abstract class Camera extends Node_2 {
|
|
1144
|
+
static readonly PERSPECTIVE_CAMERA = 0;
|
|
1145
|
+
static readonly ORTHOGRAPHIC_CAMERA = 1;
|
|
1145
1146
|
private _detach;
|
|
1147
|
+
private _orthoLeft;
|
|
1148
|
+
private _orthoRight;
|
|
1149
|
+
private _orthoBottom;
|
|
1150
|
+
private _orthoTop;
|
|
1146
1151
|
protected constructor(name: string, scene?: Scene);
|
|
1147
1152
|
getClassName(): string;
|
|
1148
1153
|
get fov(): number;
|
|
@@ -1149,6 +1154,18 @@ export declare abstract class Camera extends Node_2 {
|
|
|
1149
1154
|
private _detach;
|
|
1150
1155
|
set minZ(value: number);
|
|
1151
1156
|
get maxZ(): number;
|
|
1152
1157
|
set maxZ(value: number);
|
|
1158
|
+
get orthoLeft(): number | null;
|
|
1159
|
+
set orthoLeft(value: number | null);
|
|
1160
|
+
get orthoRight(): number | null;
|
|
1161
|
+
set orthoRight(value: number | null);
|
|
1162
|
+
get orthoBottom(): number | null;
|
|
1163
|
+
set orthoBottom(value: number | null);
|
|
1164
|
+
get orthoTop(): number | null;
|
|
1165
|
+
set orthoTop(value: number | null);
|
|
1166
|
+
get mode(): number;
|
|
1167
|
+
set mode(value: number);
|
|
1168
|
+
get viewport(): Viewport;
|
|
1169
|
+
set viewport(value: Viewport);
|
|
1153
1170
|
/** World-space position of the camera. */
|
|
1154
1171
|
get globalPosition(): Vector3;
|
|
1155
1172
|
/** Babylon.js `camera.getViewMatrix()` — the camera's view matrix. */
|
|
@@ -1186,6 +1203,23 @@ export declare class CascadedShadowGenerator extends ShadowGenerator {
|
|
|
1186
1203
|
getClassName(): string;
|
|
1187
1204
|
}
|
|
1188
1205
|
|
|
1206
|
+
/** Base result shared by Babylon.js physics casting queries. */
|
|
1207
|
+
export declare class CastingResult {
|
|
1208
|
+
protected readonly _hitNormal: Vector3;
|
|
1209
|
+
protected readonly _hitPoint: Vector3;
|
|
1210
|
+
private _hasHit;
|
|
1211
|
+
private _triangleIndex;
|
|
1212
|
+
body?: PhysicsBody;
|
|
1213
|
+
bodyIndex?: number;
|
|
1214
|
+
shape?: PhysicsShape;
|
|
1215
|
+
get hitPoint(): Vector3;
|
|
1216
|
+
get hitNormal(): Vector3;
|
|
1217
|
+
get hasHit(): boolean;
|
|
1218
|
+
get triangleIndex(): number;
|
|
1219
|
+
setHitData(hitNormal: Vec3Like, hitPoint: Vec3Like, triangleIndex?: number): void;
|
|
1220
|
+
reset(): void;
|
|
1221
|
+
}
|
|
1222
|
+
|
|
1189
1223
|
declare interface CellSize {
|
|
1190
1224
|
width: number;
|
|
1191
1225
|
height: number;
|
|
@@ -1752,6 +1786,31 @@ export declare class FBXFileLoader {
|
|
|
1752
1786
|
constructor();
|
|
1753
1787
|
}
|
|
1754
1788
|
|
|
1789
|
+
export declare class FluidRenderer {
|
|
1790
|
+
constructor(_scene: Scene);
|
|
1791
|
+
}
|
|
1792
|
+
|
|
1793
|
+
export declare class FluidRendererSceneComponent {
|
|
1794
|
+
constructor(_scene: Scene);
|
|
1795
|
+
}
|
|
1796
|
+
|
|
1797
|
+
export declare abstract class FluidRenderingObject {
|
|
1798
|
+
static UsePerParticleSizeAttribute: boolean;
|
|
1799
|
+
protected constructor(_scene: Scene, _shaderLanguage?: ShaderLanguage);
|
|
1800
|
+
}
|
|
1801
|
+
|
|
1802
|
+
export declare class FluidRenderingObjectCustomParticles extends FluidRenderingObject {
|
|
1803
|
+
constructor(scene: Scene, _buffers: Record<string, ArrayLike<number>>, _numParticles: number, shaderLanguage?: ShaderLanguage);
|
|
1804
|
+
}
|
|
1805
|
+
|
|
1806
|
+
export declare class FluidRenderingObjectParticleSystem extends FluidRenderingObject {
|
|
1807
|
+
constructor(scene: Scene, _particleSystem: unknown, shaderLanguage?: ShaderLanguage);
|
|
1808
|
+
}
|
|
1809
|
+
|
|
1810
|
+
export declare class FluidRenderingTargetRenderer {
|
|
1811
|
+
constructor(_scene: Scene, _camera?: Camera, _shaderLanguage?: ShaderLanguage);
|
|
1812
|
+
}
|
|
1813
|
+
|
|
1755
1814
|
/** Babylon.js `FlyCamera` — 6-DOF free-flight camera. */
|
|
1756
1815
|
export declare class FlyCamera extends TargetCamera {
|
|
1757
1816
|
constructor(name: string, position: Vector3, scene?: Scene);
|
|
1758
1817
|
get upVector(): Vector3;
|
|
@@ -1916,6 +1975,8 @@ export declare function GetPointsCount(..._args: unknown[]): never;
|
|
|
1916
1975
|
*/
|
|
1917
1976
|
export declare function GetSupportedSimultaneousLights(scene: Scene, maxSimultaneousLights: number): number;
|
|
1918
1977
|
|
|
1978
|
+
export declare function GetWhiteBalanceMatrix(_temperatureKelvin: number, _tint: number): Float32Array | number[];
|
|
1979
|
+
|
|
1919
1980
|
/** Shared base for compat gizmos (Babylon.js `Gizmo`). */
|
|
1920
1981
|
declare abstract class GizmoBase {
|
|
1921
1982
|
protected constructor(layer: UtilityLayerRenderer);
|
|
1922
1983
|
abstract get attachedMesh(): AbstractMesh | null;
|
|
@@ -1950,6 +2011,18 @@ export declare class GlowLayer {
|
|
|
1950
2011
|
constructor();
|
|
1951
2012
|
}
|
|
1952
2013
|
|
|
2014
|
+
export declare namespace GLTF1 {
|
|
2015
|
+
export {
|
|
2016
|
+
RegisterGLTF1Loader,
|
|
2017
|
+
RegisterGLTFBinaryExtension,
|
|
2018
|
+
RegisterGLTFMaterialsCommonExtension,
|
|
2019
|
+
GLTFLoaderBase,
|
|
2020
|
+
GLTFLoader,
|
|
2021
|
+
GLTFBinaryExtension,
|
|
2022
|
+
GLTFMaterialsCommonExtension
|
|
2023
|
+
}
|
|
2024
|
+
}
|
|
2025
|
+
|
|
1953
2026
|
export declare namespace GLTF2 {
|
|
1954
2027
|
export {
|
|
1955
2028
|
OpenPBRMaterialLoadingAdapter
|
|
@@ -2248,8 +2321,23 @@ export declare class HtmlRaycastInteractionManager {
|
|
|
2248
2321
|
constructor();
|
|
2249
2322
|
}
|
|
2250
2323
|
|
|
2251
|
-
|
|
2252
|
-
|
|
2324
|
+
/** Babylon.js `HtmlTexture`, forwarding DOM capture and updates to Babylon Lite. */
|
|
2325
|
+
export declare class HtmlTexture extends BaseTexture {
|
|
2326
|
+
readonly element: HTMLElement;
|
|
2327
|
+
readonly host: HTMLElement | null;
|
|
2328
|
+
readonly onLoadObservable: Observable<HtmlTexture>;
|
|
2329
|
+
private readonly _engine;
|
|
2330
|
+
private readonly _textureMatrix;
|
|
2331
|
+
private readonly _ready;
|
|
2332
|
+
private _htmlTexture;
|
|
2333
|
+
private _disposed;
|
|
2334
|
+
constructor(name: string, element: HTMLElement, options: IHtmlTextureOptions);
|
|
2335
|
+
getTextureMatrix(): Matrix;
|
|
2336
|
+
requestUpdate(): void;
|
|
2337
|
+
update(invertY?: boolean): void;
|
|
2338
|
+
getClassName(): string;
|
|
2339
|
+
whenReadyAsync(): Promise<void>;
|
|
2340
|
+
dispose(): void;
|
|
2253
2341
|
}
|
|
2254
2342
|
|
|
2255
2343
|
/** Babylon.js `IAbstractSoundOptions` (subset). */
|
|
@@ -2385,9 +2473,17 @@ export declare interface IHtmlRaycastInteractionManagerOptions {
|
|
|
2385
2473
|
[key: string]: unknown;
|
|
2386
2474
|
}
|
|
2387
2475
|
|
|
2388
|
-
/** Options accepted by Babylon.js `HtmlTexture
|
|
2476
|
+
/** Options accepted by Babylon.js `HtmlTexture`. */
|
|
2389
2477
|
export declare interface IHtmlTextureOptions {
|
|
2390
|
-
|
|
2478
|
+
width?: number;
|
|
2479
|
+
height?: number;
|
|
2480
|
+
generateMipMaps?: boolean;
|
|
2481
|
+
samplingMode?: number;
|
|
2482
|
+
format?: number;
|
|
2483
|
+
autoUpdate?: boolean;
|
|
2484
|
+
useSvgFallback?: boolean;
|
|
2485
|
+
engine?: AbstractEngine | null;
|
|
2486
|
+
scene?: Scene | null;
|
|
2391
2487
|
}
|
|
2392
2488
|
|
|
2393
2489
|
/** Options accepted by `InstallHtmlInCanvasPolyfill` (shape-only stub). */
|
|
@@ -2396,14 +2492,25 @@ export declare interface IInstallHtmlInCanvasPolyfillOptions {
|
|
|
2396
2492
|
}
|
|
2397
2493
|
|
|
2398
2494
|
/**
|
|
2399
|
-
* Babylon.js `ImageProcessingConfiguration`
|
|
2400
|
-
*
|
|
2401
|
-
* `scene.imageProcessingConfiguration`).
|
|
2495
|
+
* Minimal Babylon.js `ImageProcessingConfiguration` facade over Lite's image
|
|
2496
|
+
* processing state.
|
|
2402
2497
|
*/
|
|
2403
2498
|
export declare class ImageProcessingConfiguration {
|
|
2404
2499
|
static readonly TONEMAPPING_STANDARD = 0;
|
|
2405
2500
|
static readonly TONEMAPPING_ACES = 1;
|
|
2406
2501
|
static readonly TONEMAPPING_KHR_PBR_NEUTRAL = 2;
|
|
2502
|
+
private _backing;
|
|
2407
2503
|
get exposure(): number;
|
|
2504
|
+
set exposure(value: number);
|
|
2505
|
+
get contrast(): number;
|
|
2506
|
+
set contrast(value: number);
|
|
2507
|
+
get toneMappingEnabled(): boolean;
|
|
2508
|
+
set toneMappingEnabled(value: boolean);
|
|
2509
|
+
get whiteBalanceEnabled(): boolean;
|
|
2510
|
+
set whiteBalanceEnabled(value: boolean);
|
|
2511
|
+
get temperature(): number;
|
|
2512
|
+
set temperature(value: number);
|
|
2513
|
+
get tint(): number;
|
|
2514
|
+
set tint(value: number);
|
|
2408
2515
|
}
|
|
2409
2516
|
|
|
2410
2517
|
/** The decoded image sources WebGPU (and therefore Lite) can upload into a layer. */
|
|
@@ -2455,6 +2562,14 @@ export declare class InterpolatingBehavior {
|
|
|
2455
2562
|
constructor();
|
|
2456
2563
|
}
|
|
2457
2564
|
|
|
2565
|
+
/** Babylon.js raycast collision-filter options. */
|
|
2566
|
+
export declare interface IRaycastQuery {
|
|
2567
|
+
membership?: number;
|
|
2568
|
+
collideWith?: number;
|
|
2569
|
+
shouldHitTriggers?: boolean;
|
|
2570
|
+
ignoreBody?: PhysicsBody;
|
|
2571
|
+
}
|
|
2572
|
+
|
|
2458
2573
|
/**
|
|
2459
2574
|
* Babylon.js `ISafeOrbitCameraLimits` — safe-orbit camera limits embedded in a Gaussian
|
|
2460
2575
|
* Splatting file's metadata (Adobe safe-orbit extension). Exposed on the loaded mesh via
|
|
@@ -2489,8 +2604,8 @@ export declare interface ISceneLoaderProgressEvent {
|
|
|
2489
2604
|
/** Babylon.js `IsHtmlInCanvasSupportedNatively` — the HTML-in-canvas feature is unsupported by the compat layer. */
|
|
2490
2605
|
export declare function IsHtmlInCanvasSupportedNatively(): never;
|
|
2491
2606
|
|
|
2492
|
-
/** Babylon.js `IsHtmlInCanvasUploadSupported` —
|
|
2493
|
-
export declare function IsHtmlInCanvasUploadSupported():
|
|
2607
|
+
/** Babylon.js `IsHtmlInCanvasUploadSupported` — kept in lockstep with the unavailable upload helper. */
|
|
2608
|
+
export declare function IsHtmlInCanvasUploadSupported(engine: AbstractEngine): boolean;
|
|
2494
2609
|
|
|
2495
2610
|
/** Babylon.js `ISOGLODMetadata` — SOG LOD octree metadata (shape-only stub for type parity). */
|
|
2496
2611
|
export declare interface ISOGLODMetadata {
|
|
@@ -2637,6 +2752,8 @@ export declare interface IWebAudioEngineOptions extends IAudioEngineV2Options {
|
|
|
2637
2752
|
resumeOnPause: boolean;
|
|
2638
2753
|
/** Retry interval (ms) for `resumeOnPause`. Defaults to `1000`. */
|
|
2639
2754
|
resumeOnPauseRetryInterval: number;
|
|
2755
|
+
/** Disable Babylon.js's iOS ringer-switch workaround. Lite does not install that workaround. */
|
|
2756
|
+
disableIOSRingerSwitchWorkaround?: boolean;
|
|
2640
2757
|
}
|
|
2641
2758
|
|
|
2642
2759
|
/**
|
|
@@ -2668,9 +2785,7 @@ export declare abstract class Light extends Node_2 {
|
|
|
2668
2785
|
protected constructor(n
|
|
2669
2786
|
*/
|
|
2670
2787
|
get intensity(): number;
|
|
2671
2788
|
set intensity(value: number);
|
|
2672
2789
|
/** Detach this light's shadow generator (compat for `light.shadowEnabled = false`). */
|
|
2673
|
-
set shadowEnabled(enabled: boolean);
|
|
2674
|
-
dispose(): void;
|
|
2675
|
-
}
|
|
2790
|
+
set shadowEnabled(enabled: boolean);
|
|
2676
2791
|
|
|
2677
2792
|
export declare class LightGizmo {
|
|
2678
2793
|
private _attached;
|
|
2679
2794
|
constructor(layer: UtilityLayerRenderer);
|
|
@@ -2829,6 +2944,8 @@ export declare class Matrix {
|
|
|
2829
2944
|
constructor();
|
|
2830
2945
|
set(index: number, value: number): this;
|
|
2831
2946
|
copyFrom(source: Matrix): this;
|
|
2947
|
+
/** Set only this matrix's translation components. */
|
|
2948
|
+
setTranslationFromFloats(x: number, y: number, z: number): this;
|
|
2832
2949
|
maximizeInPlace(other: Matrix): this;
|
|
2833
2950
|
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;
|
|
2834
2951
|
clone(): Matrix;
|
|
@@ -2849,7 +2966,7 @@ export declare class Matrix {
|
|
|
2849
2966
|
* TRS matrix into its scale, rotation (quaternion), and translation parts,
|
|
2850
2967
|
* writing into any provided out-params. Returns `false` (matching BJS) when a
|
|
2851
2968
|
* scale axis is zero. The rotation extraction is backed by Lite's
|
|
2852
|
-
* `
|
|
2969
|
+
* `createQuatFromRotationMat4` (via `Quaternion.FromRotationMatrixToRef`); the
|
|
2853
2970
|
* negative-determinant `scale.y` flip matches Babylon.js exactly.
|
|
2854
2971
|
*/
|
|
2855
2972
|
decompose(scale?: Vector3, rotation?: Quaternion, translation?: Vector3): boolean;
|
|
@@ -2881,6 +2998,8 @@ export declare class Matrix {
|
|
|
2881
2998
|
markAsUpdated(): this;
|
|
2882
2999
|
}
|
|
2883
3000
|
|
|
3001
|
+
export declare const MaxTintMagnitude = 150;
|
|
3002
|
+
|
|
2884
3003
|
/** Babylon.js `Mesh` — a concrete renderable mesh with geometry. */
|
|
2885
3004
|
export declare class Mesh extends AbstractMesh {
|
|
2886
3005
|
constructor(name: string, sceneOrLite?: Scene | Mesh_2, scene?: Scene);
|
|
@@ -3016,6 +3135,8 @@ export declare class MeshoptCompression {
|
|
|
3016
3135
|
static get Default(): MeshoptCompression;
|
|
3017
3136
|
}
|
|
3018
3137
|
|
|
3138
|
+
export declare const MinTemperatureKelvin: number;
|
|
3139
|
+
|
|
3019
3140
|
export declare class MirrorTexture {
|
|
3020
3141
|
constructor();
|
|
3021
3142
|
}
|
|
@@ -3198,12 +3319,13 @@ export declare class Observable<T> {
|
|
|
3198
3319
|
private _observers;
|
|
3199
3320
|
private _hasNotified;
|
|
3200
3321
|
private _lastNotifiedValue;
|
|
3322
|
+
private _lastNotifiedMask;
|
|
3201
3323
|
constructor(_onObserverAdded?: ((observer: ObserverCallback<T>) => void) | undefined, notifyIfTriggered?: boolean);
|
|
3202
|
-
add(callback: ObserverCallback<T
|
|
3203
|
-
addOnce(callback: ObserverCallback<T
|
|
3324
|
+
add(callback: ObserverCallback<T>, mask?: number): ObserverCallback<T>;
|
|
3325
|
+
addOnce(callback: ObserverCallback<T>, mask?: number): ObserverCallback<T>;
|
|
3204
3326
|
remove(callback: ObserverCallback<T> | null | undefined): boolean;
|
|
3205
3327
|
removeCallback(callback: ObserverCallback<T>): boolean;
|
|
3206
|
-
notifyObservers(eventData?: T): void;
|
|
3328
|
+
notifyObservers(eventData?: T, mask?: number): void;
|
|
3207
3329
|
hasObservers(): boolean;
|
|
3208
3330
|
clear(): void;
|
|
3209
3331
|
cleanLastNotifiedState(): void;
|
|
@@ -3747,6 +3869,10 @@ export declare class PhysicsEngine {
|
|
|
3747
3869
|
/** Current world gravity. */
|
|
3748
3870
|
setTimeStep(newTimeStep: number): void;
|
|
3749
3871
|
/** Get the fixed timestep. */
|
|
3750
3872
|
getTimeStep(): number;
|
|
3873
|
+
/** Cast a ray through the active Lite Havok world. */
|
|
3874
|
+
raycast(from: Vector3, to: Vector3, query?: IRaycastQuery): PhysicsRaycastResult;
|
|
3875
|
+
/** Cast a ray through the active Lite Havok world and write into `result`. */
|
|
3876
|
+
raycastToRef(from: Vector3, to: Vector3, result: PhysicsRaycastResult, query?: IRaycastQuery): void;
|
|
3751
3877
|
/** Release the underlying physics world. */
|
|
3752
3878
|
dispose(): void;
|
|
3753
3879
|
}
|
|
@@ -3777,6 +3903,21 @@ export declare enum PhysicsPrestepType {
|
|
|
3777
3903
|
ACTION = 2
|
|
3778
3904
|
}
|
|
3779
3905
|
|
|
3906
|
+
/** Babylon.js raycast result backed by Lite's native Havok query result. */
|
|
3907
|
+
export declare class PhysicsRaycastResult extends CastingResult {
|
|
3908
|
+
private _hitDistance;
|
|
3909
|
+
private readonly _rayFromWorld;
|
|
3910
|
+
private readonly _rayToWorld;
|
|
3911
|
+
get hitDistance(): number;
|
|
3912
|
+
get hitNormalWorld(): Vector3;
|
|
3913
|
+
get hitPointWorld(): Vector3;
|
|
3914
|
+
get rayFromWorld(): Vector3;
|
|
3915
|
+
get rayToWorld(): Vector3;
|
|
3916
|
+
setHitDistance(distance: number): void;
|
|
3917
|
+
calculateHitDistance(): void;
|
|
3918
|
+
reset(from?: Vector3, to?: Vector3): void;
|
|
3919
|
+
}
|
|
3920
|
+
|
|
3780
3921
|
/** Babylon.js-shaped collision shape backed by a Babylon Lite physics shape. */
|
|
3781
3922
|
export declare class PhysicsShape {
|
|
3782
3923
|
constructor(options: PhysicShapeOptions, scene: Scene);
|
|
3783
3924
|
getClassName(): string;
|
|
3784
3925
|
get type(): PhysicsShapeType;
|
|
@@ -3885,6 +4026,26 @@ export declare class PointerDragBehavior {
|
|
|
3885
4026
|
constructor();
|
|
3886
4027
|
}
|
|
3887
4028
|
|
|
4029
|
+
/** Babylon.js pointer event masks emitted by `Scene.onPointerObservable`. */
|
|
4030
|
+
export declare class PointerEventTypes {
|
|
4031
|
+
static readonly POINTERDOWN = 1;
|
|
4032
|
+
static readonly POINTERUP = 2;
|
|
4033
|
+
static readonly POINTERMOVE = 4;
|
|
4034
|
+
static readonly POINTERWHEEL = 8;
|
|
4035
|
+
static readonly POINTERPICK = 16;
|
|
4036
|
+
static readonly POINTERTAP = 32;
|
|
4037
|
+
static readonly POINTERDOUBLETAP = 64;
|
|
4038
|
+
}
|
|
4039
|
+
|
|
4040
|
+
/** Babylon.js-shaped payload emitted by `Scene.onPointerObservable`. */
|
|
4041
|
+
export declare class PointerInfo {
|
|
4042
|
+
type: number;
|
|
4043
|
+
event: PointerEvent | WheelEvent;
|
|
4044
|
+
private readonly _pickInfo;
|
|
4045
|
+
constructor(type: number, event: PointerEvent | WheelEvent, _pickInfo: PickingInfo | null);
|
|
4046
|
+
get pickInfo(): PickingInfo | null;
|
|
4047
|
+
}
|
|
4048
|
+
|
|
3888
4049
|
export declare class PointLight extends Light {
|
|
3889
4050
|
constructor(name: string, position: Vector3, scene?: Scene);
|
|
3890
4051
|
getClassName(): string;
|
|
3891
4052
|
get range(): number;
|
|
@@ -4009,7 +4170,7 @@ export declare class Quaternion {
|
|
|
4009
4170
|
conjugate(): Quaternion;
|
|
4010
4171
|
/**
|
|
4011
4172
|
* Babylon.js `Quaternion.fromRotationMatrix` — update this quaternion in place
|
|
4012
|
-
* from the rotation part of `matrix`. Backed by Lite's `
|
|
4173
|
+
* from the rotation part of `matrix`. Backed by Lite's `createQuatFromRotationMat4`.
|
|
4013
4174
|
*/
|
|
4014
4175
|
fromRotationMatrix(matrix: Matrix): this;
|
|
4015
4176
|
/**
|
|
@@ -4024,12 +4185,12 @@ export declare class Quaternion {
|
|
|
4024
4185
|
static Identity(): Quaternion;
|
|
4025
4186
|
/**
|
|
4026
4187
|
* Babylon.js `Quaternion.FromRotationMatrix` — create a new quaternion from the
|
|
4027
|
-
* rotation part of `matrix`. Backed by Lite's `
|
|
4188
|
+
* rotation part of `matrix`. Backed by Lite's `createQuatFromRotationMat4`.
|
|
4028
4189
|
*/
|
|
4029
4190
|
static FromRotationMatrix(matrix: Matrix): Quaternion;
|
|
4030
4191
|
/**
|
|
4031
4192
|
* Babylon.js `Quaternion.FromRotationMatrixToRef` — write the rotation part of
|
|
4032
|
-
* `matrix` into `result`. Backed by Lite's `
|
|
4193
|
+
* `matrix` into `result`. Backed by Lite's `createQuatFromRotationMat4`.
|
|
4033
4194
|
*/
|
|
4034
4195
|
static FromRotationMatrixToRef(matrix: Matrix, result: Quaternion): Quaternion;
|
|
4035
4196
|
static FromEulerAngles(x: number, y: number, z: number): Quaternion;
|
|
@@ -4171,10 +4332,23 @@ export declare class ReflectionProbe {
|
|
|
4171
4332
|
constructor();
|
|
4172
4333
|
}
|
|
4173
4334
|
|
|
4335
|
+
/**
|
|
4336
|
+
* Babylon.js pure-module texture-loader registration hook. Lite dispatches its
|
|
4337
|
+
* supported texture formats directly, so no registration is required.
|
|
4338
|
+
*/
|
|
4339
|
+
export declare function RegisterAbstractEngineTextureLoaders(): void;
|
|
4340
|
+
|
|
4341
|
+
export declare function RegisterFluidRenderer(): void;
|
|
4342
|
+
|
|
4174
4343
|
export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
|
|
4175
4344
|
|
|
4345
|
+
/** Babylon.js pure-module registration hook. */
|
|
4346
|
+
export declare function RegisterImageProcessingConfiguration(): void;
|
|
4347
|
+
|
|
4176
4348
|
export declare function RegisterOpenpbrMaterial(): void;
|
|
4177
4349
|
|
|
4350
|
+
export declare function RegisterUSDFileLoader(): never;
|
|
4351
|
+
|
|
4178
4352
|
/** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
|
|
4179
4353
|
export declare class RenderTargetTexture {
|
|
4180
4354
|
constructor();
|
|
@@ -4239,9 +4413,12 @@ export declare class Scene extends AbstractScene {
|
|
|
4239
4413
|
/** Babylon.js fog-mode c
|
|
4240
4414
|
readonly onBeforeAnimationsObservable: Observable<Scene>;
|
|
4241
4415
|
/** Fires after each scene render. */
|
|
4242
4416
|
readonly onAfterRenderObservable: Observable<Scene>;
|
|
4417
|
+
/** Fires after each Lite Havok simulation step. */
|
|
4418
|
+
readonly onAfterPhysicsObservable: Observable<Scene>;
|
|
4243
4419
|
/** Fires once when the scene is disposed. */
|
|
4244
4420
|
readonly onDisposeObservable: Observable<Scene>;
|
|
4245
|
-
/**
|
|
4421
|
+
/** Babylon.js scene-level pointer events from the engine rendering canvas. */
|
|
4422
|
+
readonly onPointerObservable: Observable<PointerInfo>;
|
|
4246
4423
|
/**
|
|
4247
4424
|
* Babylon.js `scene.animationGroups` / `scene.animatables`. Loaded glTF /
|
|
4248
4425
|
* `.babylon` animation clips live on the Lite scene; `animationGroups` returns
|
|
4249
4426
|
* BJS-shaped `AnimationGroup`s over them (so scenes can `goToFrame`/`pause`/`stop`
|
|
@@ -4254,6 +4431,7 @@ export declare class Scene extends AbstractScene {
|
|
|
4254
4431
|
/** Babylon.js fog-mode c
|
|
4255
4432
|
get animatables(): Animatable_2[];
|
|
4256
4433
|
private readonly _engine;
|
|
4257
4434
|
private _activeCamera;
|
|
4435
|
+
cameraToUseForPointers: Camera | null;
|
|
4258
4436
|
private _defaultMaterial;
|
|
4259
4437
|
private _fogMode;
|
|
4260
4438
|
private _fogStart;
|
|
@@ -4269,9 +4447,12 @@ export declare class Scene extends AbstractScene {
|
|
|
4269
4447
|
/** Babylon.js fog-mode c
|
|
4270
4448
|
private readonly _pendingMorphBuilds;
|
|
4271
4449
|
private readonly _runningAnimatables;
|
|
4272
4450
|
private readonly _animationGroupCache;
|
|
4273
4451
|
private _ambientColor;
|
|
4274
|
-
private _environmentIntensity;
|
|
4275
4452
|
/** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
|
|
4453
|
+
private _environmentIntensity;
|
|
4454
|
+
private _imageProcessingConfiguration;
|
|
4276
4455
|
/** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
|
|
4277
4456
|
readonly uniqueId: number;
|
|
4278
|
-
constructor(engine: WebGPUEngine);
|
|
4279
4457
|
getEngine(): WebGPUEngine;
|
|
4458
|
+
constructor(engine: WebGPUEngine);
|
|
4459
|
+
private _attachPointerEvents;
|
|
4460
|
+
private _detachPointerEvents;
|
|
4280
4461
|
getEngine(): WebGPUEngine;
|
|
4281
4462
|
/** Babylon.js `scene.getClassName()`. */
|
|
4282
4463
|
getClassName(): string;
|
|
4283
4464
|
/** Babylon.js `scene.getUniqueId()` — the process-unique scene id. */
|
|
@@ -4286,12 +4467,12 @@ export declare class Scene extends AbstractScene {
|
|
|
4286
4467
|
/** Babylon.js fog-mode c
|
|
4287
4468
|
get clearColor(): Color4;
|
|
4288
4469
|
set clearColor(value: Color4);
|
|
4289
4470
|
get activeCamera(): Camera | null;
|
|
4290
|
-
set activeCamera(camera: Camera | null);
|
|
4291
4471
|
/** Image-processing exposure proxy (Babylon.js `imageProcessingConfiguration.exposure`). */
|
|
4292
|
-
|
|
4293
|
-
exposure: number;
|
|
4294
|
-
contrast: number;
|
|
4295
|
-
toneMappingEnabled: boolean;
|
|
4296
|
-
};
|
|
4472
|
+
set activeCamera(camera: Camera | null);
|
|
4297
4473
|
/** Babylon.js image-processing facade over the scene's Lite state. */
|
|
4474
|
+
get imageProcessingConfiguration(): ImageProcessingConfiguration;
|
|
4475
|
+
get fluidRenderer(): FluidRenderer | null;
|
|
4476
|
+
set fluidRenderer(value: FluidRenderer | null);
|
|
4477
|
+
enableFluidRenderer(): FluidRenderer | null;
|
|
4478
|
+
disableFluidRenderer(): void;
|
|
4298
4479
|
/** Babylon.js `scene.performancePriority` — accepted for parity; Babylon Lite tunes its own pipeline. */
|
|
4299
4480
|
performancePriority: number;
|
|
4300
4481
|
/**
|
|
@@ -4395,10 +4576,15 @@ export declare class Scene extends AbstractScene {
|
|
|
4395
4576
|
/** Babylon.js fog-mode c
|
|
4396
4577
|
whenReadyAsync(): Promise<void>;
|
|
4397
4578
|
/** Babylon.js synchronous readiness check — always ready in the compat layer. */
|
|
4398
4579
|
isReady(): boolean;
|
|
4399
|
-
/**
|
|
4400
|
-
pick():
|
|
4580
|
+
/** Babylon.js synchronous screen-coordinate picking over Lite's CPU ray picker. */
|
|
4581
|
+
pick(x: number, y: number, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, camera?: Camera | null, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
|
|
4582
|
+
/**
|
|
4583
|
+
* Babylon.js `Scene.createPickingRay` — translate CSS coordinates and camera
|
|
4584
|
+
* transforms into Lite's reverse-Z unprojection helper.
|
|
4585
|
+
*/
|
|
4586
|
+
createPickingRay(x: number, y: number, world?: Matrix | null, camera?: Camera | null, cameraViewSpace?: boolean): Ray;
|
|
4401
4587
|
/** Synchronous CPU ray picking over Babylon Lite's scene-mesh picker. */
|
|
4402
|
-
pickWithRay(ray: Ray, predicate?: (mesh: TransformNode) => boolean, fastCheck?: boolean, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
|
|
4403
4588
|
/**
|
|
4589
|
+
pickWithRay(ray: Ray, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
|
|
4404
4590
|
/**
|
|
4405
4591
|
* Babylon.js `scene.enablePhysics(gravity, plugin)`. Wires the given Havok V2
|
|
4406
4592
|
* {@link HavokPlugin} to this scene, creating the native Lite physics world and
|
|
4407
4593
|
* registering per-frame stepping. The plugin's `useDeltaForWorldStep` flag
|
|
@@ -4499,7 +4685,11 @@ export declare class ShaderMaterial {
|
|
|
4499
4685
|
export declare class ShadowGenerator {
|
|
4500
4686
|
private readonly _mapSize;
|
|
4501
4687
|
private readonly _light;
|
|
4502
|
-
private readonly _casters;
|
|
4503
4688
|
getClassName(): string;
|
|
4689
|
+
private readonly _casters;
|
|
4690
|
+
private readonly _casterDisposeObservers;
|
|
4691
|
+
private _casterSyncScheduled;
|
|
4692
|
+
private _casterSyncDirty;
|
|
4693
|
+
private readonly _disposeBeforeRenderFlush;
|
|
4504
4694
|
getClassName(): string;
|
|
4505
4695
|
/** Percentage-closer filtering. */
|
|
4506
4696
|
usePercentageCloserFiltering: boolean;
|
|
4507
4697
|
/** Contact-hardening (treated as PCF here). */
|
|
@@ -4524,9 +4714,14 @@ export declare class ShadowGenerator {
|
|
|
4524
4714
|
orthoMaxZ: number | undefined;
|
|
4525
4715
|
constructor(mapSize: number, light: Light);
|
|
4526
4716
|
/** Babylon.js `addShadowCaster(mesh, includeDescendants?)`. */
|
|
4527
|
-
addShadowCaster(mesh: AbstractMesh,
|
|
4528
|
-
/** Babylon.js `removeShadowCaster(mesh)`. */
|
|
4529
|
-
removeShadowCaster(mesh: AbstractMesh): ShadowGenerator;
|
|
4717
|
+
addShadowCaster(mesh: AbstractMesh, includeDescendants?: boolean): ShadowGenerator;
|
|
4718
|
+
/** Babylon.js `removeShadowCaster(mesh, includeDescendants?)`. */
|
|
4719
|
+
removeShadowCaster(mesh: AbstractMesh, includeDescendants?: boolean): ShadowGenerator;
|
|
4720
|
+
private _casterTree;
|
|
4721
|
+
private _detachCasterDisposeObserver;
|
|
4722
|
+
private _removeCaster;
|
|
4723
|
+
private _scheduleCasterSync;
|
|
4724
|
+
private _flushCasterSync;
|
|
4530
4725
|
/** Babylon.js `getShadowMap()` — returns a minimal render-list holder for parity. */
|
|
4531
4726
|
getShadowMap(): {
|
|
4532
4727
|
renderList: AbstractMesh[];
|
|
@@ -5023,6 +5218,8 @@ export declare class TargetCamera extends Camera {
|
|
|
5023
5218
|
constructor(name: string,
|
|
5024
5219
|
|
|
5025
5220
|
declare type TaskState = "init" | "running" | "done" | "error";
|
|
5026
5221
|
|
|
5222
|
+
export declare function TemperatureTintToXyz(_temperatureKelvin: number, _tint: number): Vector3;
|
|
5223
|
+
|
|
5027
5224
|
export declare class Texture extends BaseTexture {
|
|
5028
5225
|
private readonly _ready;
|
|
5029
5226
|
private _onLoadObservable;
|
|
@@ -5179,8 +5376,7 @@ export declare class TransformNode extends Node_2 {
|
|
|
5179
5376
|
physicsBody: PhysicsBody
|
|
5180
5377
|
* setter, which keeps the local transform and lets the world move.
|
|
5181
5378
|
*/
|
|
5182
5379
|
setParent(parent: Node_2 | null): TransformNode;
|
|
5183
|
-
protected _applyParent(parent: Node_2 | null): void;
|
|
5184
|
-
}
|
|
5380
|
+
protected _applyParent(parent: Node_2 | null): void;
|
|
5185
5381
|
|
|
5186
5382
|
export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
|
|
5187
5383
|
|
|
@@ -5206,6 +5402,60 @@ export declare function UploadHtmlElementToTexture(): never;
|
|
|
5206
5402
|
*/
|
|
5207
5403
|
export declare function UploadImageToTexture2DArrayLayer(texture: RawTexture2DArray, source: ImageSource, layer: number, options?: IUploadImageToTexture2DArrayLayerOptions): void;
|
|
5208
5404
|
|
|
5405
|
+
export declare type USDBinaryInput = ArrayBuffer | ArrayBufferView;
|
|
5406
|
+
|
|
5407
|
+
export declare class USDFileLoader {
|
|
5408
|
+
constructor(_options?: Partial<USDFileLoaderOptions>);
|
|
5409
|
+
}
|
|
5410
|
+
|
|
5411
|
+
export declare interface USDFileLoaderOptions {
|
|
5412
|
+
rootFileName?: string;
|
|
5413
|
+
files?: USDVirtualFiles;
|
|
5414
|
+
resolveByFileName?: boolean;
|
|
5415
|
+
workerUrl?: string | URL;
|
|
5416
|
+
glueUrl?: string;
|
|
5417
|
+
wasmUrl?: string;
|
|
5418
|
+
dataUrl?: string;
|
|
5419
|
+
onProgress?: (progress: USDLoadProgress) => void;
|
|
5420
|
+
onLog?: (level: "info" | "warning" | "error", message: string) => void;
|
|
5421
|
+
onComplete?: (diagnostics: USDImportDiagnostics) => void;
|
|
5422
|
+
}
|
|
5423
|
+
|
|
5424
|
+
export declare interface USDImportDiagnostics {
|
|
5425
|
+
timings: USDImportTimings;
|
|
5426
|
+
statistics: USDImportStatistics;
|
|
5427
|
+
missingAssets: readonly string[];
|
|
5428
|
+
}
|
|
5429
|
+
|
|
5430
|
+
export declare interface USDImportStatistics {
|
|
5431
|
+
nodes: number;
|
|
5432
|
+
meshes: number;
|
|
5433
|
+
analyticPrimitives: number;
|
|
5434
|
+
instances: number;
|
|
5435
|
+
materials: number;
|
|
5436
|
+
vertices: number;
|
|
5437
|
+
triangles: number;
|
|
5438
|
+
commandBytes: number;
|
|
5439
|
+
dataBytes: number;
|
|
5440
|
+
}
|
|
5441
|
+
|
|
5442
|
+
export declare interface USDImportTimings {
|
|
5443
|
+
totalMs: number;
|
|
5444
|
+
stageOpenMs: number;
|
|
5445
|
+
stageReadMs: number;
|
|
5446
|
+
preparationMs: number;
|
|
5447
|
+
packingMs: number;
|
|
5448
|
+
heapCopyMs: number;
|
|
5449
|
+
materializeMs: number;
|
|
5450
|
+
}
|
|
5451
|
+
|
|
5452
|
+
export declare interface USDLoadProgress {
|
|
5453
|
+
phase: "initializing" | "staging" | "extracting" | "materializing";
|
|
5454
|
+
message: string;
|
|
5455
|
+
}
|
|
5456
|
+
|
|
5457
|
+
export declare type USDVirtualFiles = Readonly<Record<string, USDBinaryInput>>;
|
|
5458
|
+
|
|
5209
5459
|
/** Babylon.js `UtilityLayerRenderer` — the overlay scene gizmos render into. */
|
|
5210
5460
|
export declare class UtilityLayerRenderer {
|
|
5211
5461
|
private _registered;
|
|
5212
5462
|
constructor(scene: Scene);
|
|
5213
5463
|
dispose(): void;
|
|
@@ -5318,6 +5568,10 @@ export declare class Vector3 {
|
|
|
5318
5568
|
static NormalizeToRef<T extends Vector3>(vector: Vector3, result: T): T;
|
|
5319
5569
|
static Minimize(a: Vector3, b: Vector3): Vector3;
|
|
5320
5570
|
static Maximize(a: Vector3, b: Vector3): Vector3;
|
|
5571
|
+
/** Project a world-space point into a Babylon.js viewport. */
|
|
5572
|
+
static Project(vector: Vector3, world: Matrix, transform: Matrix, viewport: Viewport): Vector3;
|
|
5573
|
+
/** Project a world-space point into a Babylon.js viewport, writing into `result`. */
|
|
5574
|
+
static ProjectToRef<T extends Vector3>(vector: Vector3, world: Matrix, transform: Matrix, viewport: Viewport, result: T): T;
|
|
5321
5575
|
/** Transform a coordinate (point) by a matrix using the row-vector convention. */
|
|
5322
5576
|
static TransformCoordinates(vector: Vector3, transformation: Matrix): Vector3;
|
|
5323
5577
|
/** Transform a coordinate (point) by a matrix using the row-vector convention. */
|