@babylonjs/lite-compat 1.37.0-preview → 1.37.2-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 +113 -4
- package/index.d.ts +397 -19
- package/index.js +1584 -1023
- package/index.js.map +1 -1
- package/{meshes-zeNif9yt.js → meshes-sOWGK4P8.js} +40 -13
- package/meshes-sOWGK4P8.js.map +1 -0
- package/navigation.d.ts +42 -9
- package/navigation.js +1 -1
- package/package.json +4 -4
- package/meshes-zeNif9yt.js.map +0 -1
package/index.d.ts
CHANGED
|
@@ -5,7 +5,7 @@ import { AudioGraphHost } from '@babylonjs/lite';
|
|
|
5
5
|
import { ClearCoatProps } from '@babylonjs/lite';
|
|
6
6
|
import { ComputeShader as ComputeShader_2 } from '@babylonjs/lite';
|
|
7
7
|
import { EngineContext } from '@babylonjs/lite';
|
|
8
|
-
import { EngineOptions } from '@babylonjs/lite';
|
|
8
|
+
import { EngineOptions as EngineOptions_2 } from '@babylonjs/lite';
|
|
9
9
|
import { IridescenceProps } from '@babylonjs/lite';
|
|
10
10
|
import { LineMaterial } from '@babylonjs/lite';
|
|
11
11
|
import { MaxTintMagnitude } from '@babylonjs/lite';
|
|
@@ -125,6 +125,7 @@ export declare abstract class AbstractEngine {
|
|
|
125
125
|
protected readonly _scenes: Scene[];
|
|
126
126
|
protected readonly _loopCallbacks: Array<() => void>;
|
|
127
127
|
protected _initialized: boolean;
|
|
128
|
+
private _disposed;
|
|
128
129
|
private _startupComplete;
|
|
129
130
|
private _startPromise;
|
|
130
131
|
/**
|
|
131
132
|
* Babylon.js `engine.useReverseDepthBuffer`. Babylon Lite owns its depth
|
|
@@ -243,12 +244,19 @@ export declare abstract class AbstractEngine {
|
|
|
243
244
|
private _ensureInitialized;
|
|
244
245
|
}
|
|
245
246
|
|
|
247
|
+
/** Babylon.js `AbstractEngineOptions` subset accepted by the compat engine. */
|
|
248
|
+
export declare interface AbstractEngineOptions extends EngineOptions_2 {
|
|
249
|
+
antialias?: boolean;
|
|
250
|
+
adaptToDeviceRatio?: boolean;
|
|
251
|
+
useLargeWorldRendering?: boolean;
|
|
252
|
+
useReverseDepthBuffer?: boolean;
|
|
253
|
+
}
|
|
254
|
+
|
|
246
255
|
/**
|
|
247
256
|
* Babylon.js `AbstractMesh` — a renderable transform node with a material,
|
|
248
257
|
* visibility, and shadow-receipt. Concrete meshes derive from this.
|
|
249
258
|
*/
|
|
250
|
-
export declare class AbstractMesh extends TransformNode {
|
|
251
259
|
private _material;
|
|
252
|
-
|
|
260
|
+
export declare class AbstractMesh extends TransformNode {
|
|
253
261
|
private _material;
|
|
254
262
|
private _meshBlendingTag;
|
|
255
263
|
protected _visible: boolean;
|
|
256
264
|
constructor(name: string, lite: Mesh_2, scene?: Scene);
|
|
257
265
|
getClassName(): string;
|
|
258
266
|
get material(): CompatMaterial | null;
|
|
@@ -811,6 +819,7 @@ export declare class ArcRotateCamera extends Camera {
|
|
|
811
819
|
constructor(name: stri
|
|
812
820
|
set beta(value: number);
|
|
813
821
|
get radius(): number;
|
|
814
822
|
set radius(value: number);
|
|
823
|
+
/** Live, as in Babylon.js: `camera.target.x = …` and in-place vector math move the target. */
|
|
815
824
|
get target(): Vector3;
|
|
816
825
|
set target(value: Vector3);
|
|
817
826
|
/** Babylon.js `setTarget` — point the arc-rotate camera at a world-space target. */
|
|
@@ -830,6 +839,21 @@ export declare class ArcRotateCamera extends Camera {
|
|
|
830
839
|
constructor(name: stri
|
|
831
840
|
set panningSensibility(value: number);
|
|
832
841
|
attachControl(canvas: HTMLCanvasElement, noPreventDefault?: boolean): void;
|
|
833
842
|
|
|
843
|
+
/** Babylon.js `AreaLight` hierarchy node shared by rectangular area lights. */
|
|
844
|
+
export declare abstract class AreaLight extends Light {
|
|
845
|
+
protected constructor(name: string, scene?: Scene, dontAddToScene?: boolean);
|
|
846
|
+
abstract get position(): Vector3;
|
|
847
|
+
abstract set position(value: Vector3);
|
|
848
|
+
}
|
|
849
|
+
|
|
850
|
+
/** Babylon.js `AreaLightTextureTools` forwarding to Lite's native emission-image processor. */
|
|
851
|
+
export declare class AreaLightTextureTools {
|
|
834
852
|
constructor(engine: AbstractEngine);
|
|
853
|
+
get shaderLanguage(): ShaderLanguage;
|
|
854
|
+
isReady(): boolean;
|
|
855
|
+
processAsync(source: BaseTexture): Promise<BaseTexture | null>;
|
|
856
|
+
dispose(): void;
|
|
857
|
+
}
|
|
858
|
+
|
|
835
859
|
export declare class AssetContainer {
|
|
836
860
|
private readonly _dispose;
|
|
837
861
|
private _sceneDisposeObserver;
|
|
838
862
|
private _disposed;
|
|
839
863
|
constructor(lite: AssetContainer_2, dispose?: () => void, ownedMeshes?: readonly Mesh_2[]);
|
|
@@ -1708,6 +1732,11 @@ export declare class CubeTexture extends BaseTexture {
|
|
|
1708
1732
|
gammaSpace: boolean;
|
|
1709
1733
|
level: number;
|
|
1710
1734
|
/** Fires when the cube map is "ready" (resolved on a microtask in this compat layer). */
|
|
1711
1735
|
readonly onLoadObservable: Observable<CubeTexture>;
|
|
1736
|
+
/**
|
|
1737
|
+
* Babylon.js `CubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
|
|
1738
|
+
* texture as its `environmentTexture` turns its image-based lighting with it (see `Scene.environmentTexture`).
|
|
1739
|
+
*/
|
|
1740
|
+
rotationY: number;
|
|
1712
1741
|
private _ready;
|
|
1713
1742
|
private readonly _readyPromise;
|
|
1714
1743
|
constructor(url: string, _scene?: unknown, _extensions?: unknown, _noMipmap?: boolean, _files?: unknown, onLoad?: (() => void) | null, _onError?: unknown, _format?: unknown, _prefiltered?: boolean);
|
|
@@ -1785,17 +1814,57 @@ export declare class DefaultRenderingPipeline {
|
|
|
1785
1814
|
constructor();
|
|
1786
1815
|
}
|
|
1787
1816
|
|
|
1817
|
+
export declare function defaultValueParseFunction(_key: string, _serializationObject: any, _assetsContainer: AssetContainer, _scene: Scene): any;
|
|
1818
|
+
|
|
1788
1819
|
export declare const DepthOfFieldEffect: new () => never;
|
|
1789
1820
|
|
|
1790
1821
|
export declare class DepthRenderer {
|
|
1791
1822
|
constructor();
|
|
1792
1823
|
}
|
|
1793
1824
|
|
|
1825
|
+
export declare type DeviceInput<T extends DeviceType> = T extends DeviceType.Keyboard | DeviceType.Generic ? number : T extends DeviceType.Mouse | DeviceType.Touch ? Exclude<PointerInput, PointerInput.Move | PointerInput.MouseWheelX | PointerInput.MouseWheelY | PointerInput.MouseWheelZ> : T extends DeviceType.DualShock ? DualShockInput : T extends DeviceType.Xbox ? XboxInput : T extends DeviceType.Switch ? SwitchInput : T extends DeviceType.DualSense ? DualSenseInput : never;
|
|
1826
|
+
|
|
1827
|
+
export declare const enum DeviceInputEventType {
|
|
1828
|
+
PointerMove = 0,
|
|
1829
|
+
PointerDown = 1,
|
|
1830
|
+
PointerUp = 2
|
|
1831
|
+
}
|
|
1832
|
+
|
|
1794
1833
|
/** Babylon.js `DeviceOrientationCamera` — device-orientation input is not available in Babylon Lite. */
|
|
1795
1834
|
export declare class DeviceOrientationCamera {
|
|
1796
1835
|
constructor();
|
|
1797
1836
|
}
|
|
1798
1837
|
|
|
1838
|
+
export declare class DeviceSource<T extends DeviceType> {
|
|
1839
|
+
readonly deviceType: T;
|
|
1840
|
+
readonly deviceSlot: number;
|
|
1841
|
+
readonly onInputChangedObservable: Observable<DeviceSourceEvent<T>>;
|
|
1842
|
+
constructor(_deviceInputSystem: unknown, deviceType: T, deviceSlot?: number);
|
|
1843
|
+
getInput(_inputIndex: DeviceInput<T>): number;
|
|
1844
|
+
}
|
|
1845
|
+
|
|
1846
|
+
export declare type DeviceSourceEvent<T extends DeviceType> = T extends DeviceType.Keyboard ? IKeyboardEvent : T extends DeviceType.Mouse ? IWheelEvent | IPointerEvent : T extends DeviceType.Touch ? IPointerEvent : never;
|
|
1847
|
+
|
|
1848
|
+
export declare class DeviceSourceManager {
|
|
1849
|
+
readonly onDeviceConnectedObservable: Observable<DeviceSource<DeviceType>>;
|
|
1850
|
+
readonly onDeviceDisconnectedObservable: Observable<DeviceSource<DeviceType>>;
|
|
1851
|
+
constructor(_engine: AbstractEngine);
|
|
1852
|
+
getDeviceSource<T extends DeviceType>(_deviceType: T, _deviceSlot?: number): DeviceSource<T> | null;
|
|
1853
|
+
getDeviceSources<T extends DeviceType>(_deviceType: T): ReadonlyArray<DeviceSource<T>>;
|
|
1854
|
+
dispose(): void;
|
|
1855
|
+
}
|
|
1856
|
+
|
|
1857
|
+
export declare enum DeviceType {
|
|
1858
|
+
Generic = 0,
|
|
1859
|
+
Keyboard = 1,
|
|
1860
|
+
Mouse = 2,
|
|
1861
|
+
Touch = 3,
|
|
1862
|
+
DualShock = 4,
|
|
1863
|
+
Xbox = 5,
|
|
1864
|
+
Switch = 6,
|
|
1865
|
+
DualSense = 7
|
|
1866
|
+
}
|
|
1867
|
+
|
|
1799
1868
|
export declare class DirectionalLight extends Light {
|
|
1800
1869
|
constructor(name: string, direction: Vector3, scene?: Scene);
|
|
1801
1870
|
getClassName(): string;
|
|
1802
1871
|
get direction(): Vector3;
|
|
@@ -1849,6 +1918,56 @@ export { DragEvent_2 as DragEvent }
|
|
|
1849
1918
|
/** Babylon.js drag start/end payload. */
|
|
1850
1919
|
export declare type DragStartEndEvent = Pick<DragEvent_2, "dragPlanePoint" | "pointerId" | "pointerInfo">;
|
|
1851
1920
|
|
|
1921
|
+
export declare const enum DualSenseInput {
|
|
1922
|
+
Cross = 0,
|
|
1923
|
+
Circle = 1,
|
|
1924
|
+
Square = 2,
|
|
1925
|
+
Triangle = 3,
|
|
1926
|
+
L1 = 4,
|
|
1927
|
+
R1 = 5,
|
|
1928
|
+
L2 = 6,
|
|
1929
|
+
R2 = 7,
|
|
1930
|
+
Create = 8,
|
|
1931
|
+
Options = 9,
|
|
1932
|
+
L3 = 10,
|
|
1933
|
+
R3 = 11,
|
|
1934
|
+
DPadUp = 12,
|
|
1935
|
+
DPadDown = 13,
|
|
1936
|
+
DPadLeft = 14,
|
|
1937
|
+
DPadRight = 15,
|
|
1938
|
+
Home = 16,
|
|
1939
|
+
TouchPad = 17,
|
|
1940
|
+
LStickXAxis = 18,
|
|
1941
|
+
LStickYAxis = 19,
|
|
1942
|
+
RStickXAxis = 20,
|
|
1943
|
+
RStickYAxis = 21
|
|
1944
|
+
}
|
|
1945
|
+
|
|
1946
|
+
export declare const enum DualShockInput {
|
|
1947
|
+
Cross = 0,
|
|
1948
|
+
Circle = 1,
|
|
1949
|
+
Square = 2,
|
|
1950
|
+
Triangle = 3,
|
|
1951
|
+
L1 = 4,
|
|
1952
|
+
R1 = 5,
|
|
1953
|
+
L2 = 6,
|
|
1954
|
+
R2 = 7,
|
|
1955
|
+
Share = 8,
|
|
1956
|
+
Options = 9,
|
|
1957
|
+
L3 = 10,
|
|
1958
|
+
R3 = 11,
|
|
1959
|
+
DPadUp = 12,
|
|
1960
|
+
DPadDown = 13,
|
|
1961
|
+
DPadLeft = 14,
|
|
1962
|
+
DPadRight = 15,
|
|
1963
|
+
Home = 16,
|
|
1964
|
+
TouchPad = 17,
|
|
1965
|
+
LStickXAxis = 18,
|
|
1966
|
+
LStickYAxis = 19,
|
|
1967
|
+
RStickXAxis = 20,
|
|
1968
|
+
RStickYAxis = 21
|
|
1969
|
+
}
|
|
1970
|
+
|
|
1852
1971
|
/**
|
|
1853
1972
|
* Babylon.js `DynamicTexture` — a canvas-backed texture. Draw into
|
|
1854
1973
|
* `getContext()`, then call `update()` to upload the canvas pixels to the GPU.
|
|
@@ -1976,11 +2095,22 @@ export declare class ElasticEase extends EasingFunction {
|
|
|
1976
2095
|
* Lite WebGPU context; this class exists to mirror Babylon.js's name + hierarchy.
|
|
1977
2096
|
*/
|
|
1978
2097
|
export declare class Engine extends ThinEngine {
|
|
2098
|
+
constructor(canvas: RenderCanvas, antialiasOrOptions?: boolean | EngineOptions, options?: EngineOptions, adaptToDeviceRatio?: boolean);
|
|
2099
|
+
}
|
|
2100
|
+
|
|
2101
|
+
/** Babylon.js `EngineOptions` subset accepted by the compat engine. */
|
|
2102
|
+
export declare interface EngineOptions extends AbstractEngineOptions {
|
|
1979
2103
|
}
|
|
1980
2104
|
|
|
1981
2105
|
/** Babylon.js-compatible scalar helpers and a small set of math constants. */
|
|
1982
2106
|
export declare const Epsilon = 0.001;
|
|
1983
2107
|
|
|
2108
|
+
export declare class EventConstants {
|
|
2109
|
+
static DOM_DELTA_PIXEL: number;
|
|
2110
|
+
static DOM_DELTA_LINE: number;
|
|
2111
|
+
static DOM_DELTA_PAGE: number;
|
|
2112
|
+
}
|
|
2113
|
+
|
|
1984
2114
|
/** Runs a user callback when triggered. */
|
|
1985
2115
|
export declare class ExecuteCodeAction extends Action {
|
|
1986
2116
|
private readonly _func;
|
|
@@ -2143,6 +2273,15 @@ export declare type FBXNormalMapCoordinateSystem = "y-up" | "y-down";
|
|
|
2143
2273
|
|
|
2144
2274
|
declare type FloatArray = number[] | Float32Array;
|
|
2145
2275
|
|
|
2276
|
+
export declare interface FlowGraphContext {
|
|
2277
|
+
_getGlobalContextVariable<T>(name: string, defaultValue: T): T;
|
|
2278
|
+
_setGlobalContextVariable<T>(name: string, value: T): void;
|
|
2279
|
+
}
|
|
2280
|
+
|
|
2281
|
+
export declare interface FlowGraphPlayAnimationBlock {
|
|
2282
|
+
getClassName(): string;
|
|
2283
|
+
}
|
|
2284
|
+
|
|
2146
2285
|
export declare enum FlowGraphValidationSeverity {
|
|
2147
2286
|
Error = 0,
|
|
2148
2287
|
Warning = 1
|
|
@@ -2425,6 +2564,10 @@ export declare class GaussianSplattingStream extends GaussianSplattingMesh {
|
|
|
2425
2564
|
get debugLodSource(): never;
|
|
2426
2565
|
set debugLodSource(_value: GaussianSplattingStreamDebugLodSource);
|
|
2427
2566
|
evaluateOptimalLods(_camera?: unknown): never;
|
|
2567
|
+
getSourceRange(_fileId: number): Readonly<IGaussianSplattingStreamSourceRange> | null;
|
|
2568
|
+
isSplitPage(_fileId: number): boolean;
|
|
2569
|
+
cancelRangeLoads(_files: readonly number[], _keepSources?: readonly number[]): void;
|
|
2570
|
+
get rangeResidencyStats(): Readonly<IGaussianSplattingStreamRangeResidencyStats>;
|
|
2428
2571
|
}
|
|
2429
2572
|
|
|
2430
2573
|
export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
|
|
@@ -2592,6 +2735,8 @@ export declare namespace GLTF2 {
|
|
|
2592
2735
|
IKHRInteractivityTypeMapping,
|
|
2593
2736
|
gltfTypeToBabylonType,
|
|
2594
2737
|
IFlowGraphEventReferenceBlockConfiguration,
|
|
2738
|
+
IFlowGraphDelayReferenceBlockConfiguration,
|
|
2739
|
+
FlowGraphDelayReferenceBlock,
|
|
2595
2740
|
FlowGraphEventReferenceBlock,
|
|
2596
2741
|
IFlowGraphGLTFDataProviderBlockConfiguration,
|
|
2597
2742
|
FlowGraphGLTFDataProvider,
|
|
@@ -2880,6 +3025,11 @@ export declare class HDRCubeTexture extends BaseTexture {
|
|
|
2880
3025
|
gammaSpace: boolean;
|
|
2881
3026
|
level: number;
|
|
2882
3027
|
/** Fires when the HDR environment is "ready" (resolved on a microtask). */
|
|
2883
3028
|
readonly onLoadObservable: Observable<HDRCubeTexture>;
|
|
3029
|
+
/**
|
|
3030
|
+
* Babylon.js `HDRCubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
|
|
3031
|
+
* texture as its `environmentTexture` turns its image-based lighting with it (see `Scene.environmentTexture`).
|
|
3032
|
+
*/
|
|
3033
|
+
rotationY: number;
|
|
2884
3034
|
private _ready;
|
|
2885
3035
|
private readonly _readyPromise;
|
|
2886
3036
|
constructor(url: string, _sceneOrEngine?: unknown, size?: number, _noMipmap?: boolean, _generateHarmonics?: boolean, _gammaSpace?: boolean, _prefilterOnLoad?: boolean, onLoad?: (() => void) | null);
|
|
@@ -3091,6 +3241,14 @@ export declare interface IEasingFunction {
|
|
|
3091
3241
|
ease(gradient: number): number;
|
|
3092
3242
|
}
|
|
3093
3243
|
|
|
3244
|
+
export declare interface IFlowGraphAnimationObserverSet {
|
|
3245
|
+
block: FlowGraphPlayAnimationBlock;
|
|
3246
|
+
groupEnd: Observer<AnimationGroup>;
|
|
3247
|
+
animationEnd: Observer<any>;
|
|
3248
|
+
animationLoop: Observer<any>;
|
|
3249
|
+
groupLoop: Observer<AnimationGroup>;
|
|
3250
|
+
}
|
|
3251
|
+
|
|
3094
3252
|
export declare interface IFlowGraphValidationIssue {
|
|
3095
3253
|
severity: FlowGraphValidationSeverity;
|
|
3096
3254
|
message: string;
|
|
@@ -3186,6 +3344,28 @@ export declare interface IGaussianSplattingStreamOptions {
|
|
|
3186
3344
|
hostCompound?: GaussianSplattingMesh;
|
|
3187
3345
|
decodeSh?: boolean;
|
|
3188
3346
|
needsRotationScale?: boolean;
|
|
3347
|
+
rangeResidency?: boolean;
|
|
3348
|
+
rangePack?: (source: Readonly<IGaussianSplattingStreamSourceRange>, sourceData: SOGRootData) => IGaussianSplattingStreamRangePack | null;
|
|
3349
|
+
}
|
|
3350
|
+
|
|
3351
|
+
export declare interface IGaussianSplattingStreamRangePack {
|
|
3352
|
+
sogData: SOGRootData;
|
|
3353
|
+
subRootUrl: string;
|
|
3354
|
+
}
|
|
3355
|
+
|
|
3356
|
+
export declare interface IGaussianSplattingStreamRangeResidencyStats {
|
|
3357
|
+
enabled: boolean;
|
|
3358
|
+
pages: number;
|
|
3359
|
+
sourcePackLoads: number;
|
|
3360
|
+
sourcePackReuses: number;
|
|
3361
|
+
splitPackLoads: number;
|
|
3362
|
+
cachedSourceSplats: number;
|
|
3363
|
+
}
|
|
3364
|
+
|
|
3365
|
+
export declare interface IGaussianSplattingStreamSourceRange {
|
|
3366
|
+
file: number;
|
|
3367
|
+
offset: number;
|
|
3368
|
+
count: number;
|
|
3189
3369
|
}
|
|
3190
3370
|
|
|
3191
3371
|
/** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
|
|
@@ -3233,6 +3413,18 @@ export declare interface IInstallHtmlInCanvasPolyfillOptions {
|
|
|
3233
3413
|
[key: string]: unknown;
|
|
3234
3414
|
}
|
|
3235
3415
|
|
|
3416
|
+
export declare interface IKeyboardEvent extends IUIEvent {
|
|
3417
|
+
altKey: boolean;
|
|
3418
|
+
charCode?: number;
|
|
3419
|
+
code: string;
|
|
3420
|
+
ctrlKey: boolean;
|
|
3421
|
+
key: string;
|
|
3422
|
+
keyCode: number;
|
|
3423
|
+
metaKey: boolean;
|
|
3424
|
+
shiftKey: boolean;
|
|
3425
|
+
repeat?: boolean;
|
|
3426
|
+
}
|
|
3427
|
+
|
|
3236
3428
|
/**
|
|
3237
3429
|
* Minimal Babylon.js `ImageProcessingConfiguration` facade over Lite's image
|
|
3238
3430
|
* processing state.
|
|
@@ -3288,6 +3480,33 @@ export declare interface IMeshBlendRadiusDefinition {
|
|
|
3288
3480
|
minimumProjectedRadius: number;
|
|
3289
3481
|
}
|
|
3290
3482
|
|
|
3483
|
+
export declare interface IMouseEvent extends IUIEvent {
|
|
3484
|
+
inputIndex: Exclude<PointerInput, PointerInput.Horizontal | PointerInput.Vertical>;
|
|
3485
|
+
altKey: boolean;
|
|
3486
|
+
button: number;
|
|
3487
|
+
buttons: number;
|
|
3488
|
+
clientX: number;
|
|
3489
|
+
clientY: number;
|
|
3490
|
+
ctrlKey: boolean;
|
|
3491
|
+
detail?: number;
|
|
3492
|
+
metaKey: boolean;
|
|
3493
|
+
movementX: number;
|
|
3494
|
+
movementY: number;
|
|
3495
|
+
mozMovementX?: number;
|
|
3496
|
+
mozMovementY?: number;
|
|
3497
|
+
msMovementX?: number;
|
|
3498
|
+
msMovementY?: number;
|
|
3499
|
+
offsetX: number;
|
|
3500
|
+
offsetY: number;
|
|
3501
|
+
pageX: number;
|
|
3502
|
+
pageY: number;
|
|
3503
|
+
shiftKey: boolean;
|
|
3504
|
+
webkitMovementX?: number;
|
|
3505
|
+
webkitMovementY?: number;
|
|
3506
|
+
x: number;
|
|
3507
|
+
y: number;
|
|
3508
|
+
}
|
|
3509
|
+
|
|
3291
3510
|
/** Babylon.js `ImportMeshAsync(source, scene, options?)` — imports an asset into the scene. */
|
|
3292
3511
|
export declare function ImportMeshAsync(source: string, scene: Scene, options?: ImportMeshOptions): Promise<ImportResult>;
|
|
3293
3512
|
|
|
@@ -3330,6 +3549,12 @@ export declare class InterpolatingBehavior {
|
|
|
3330
3549
|
constructor();
|
|
3331
3550
|
}
|
|
3332
3551
|
|
|
3552
|
+
export declare interface IPointerEvent extends IMouseEvent {
|
|
3553
|
+
inputIndex: Exclude<PointerInput, PointerInput.Horizontal | PointerInput.Vertical | PointerInput.MouseWheelX | PointerInput.MouseWheelY | PointerInput.MouseWheelZ>;
|
|
3554
|
+
pointerId: number;
|
|
3555
|
+
pointerType: string;
|
|
3556
|
+
}
|
|
3557
|
+
|
|
3333
3558
|
/** Babylon.js raycast collision-filter options. */
|
|
3334
3559
|
export declare interface IRaycastQuery {
|
|
3335
3560
|
membership?: number;
|
|
@@ -3536,6 +3761,15 @@ export declare interface IThinMeshBlendingPostProcessOptions extends IMeshBlendC
|
|
|
3536
3761
|
[key: string]: unknown;
|
|
3537
3762
|
}
|
|
3538
3763
|
|
|
3764
|
+
export declare interface IUIEvent {
|
|
3765
|
+
inputIndex: number;
|
|
3766
|
+
currentTarget?: any;
|
|
3767
|
+
srcElement?: any;
|
|
3768
|
+
type: string;
|
|
3769
|
+
target: any;
|
|
3770
|
+
preventDefault: () => void;
|
|
3771
|
+
}
|
|
3772
|
+
|
|
3539
3773
|
/** Babylon.js `IUploadImageToTexture2DArrayLayerOptions`. */
|
|
3540
3774
|
export declare interface IUploadImageToTexture2DArrayLayerOptions {
|
|
3541
3775
|
/** Store the source with the Y axis inverted (false by default). */
|
|
@@ -3564,6 +3798,15 @@ export declare interface IWebAudioEngineOptions extends IAudioEngineV2Options {
|
|
|
3564
3798
|
disableIOSRingerSwitchWorkaround?: boolean;
|
|
3565
3799
|
}
|
|
3566
3800
|
|
|
3801
|
+
export declare interface IWheelEvent extends IMouseEvent {
|
|
3802
|
+
inputIndex: PointerInput.MouseWheelX | PointerInput.MouseWheelY | PointerInput.MouseWheelZ;
|
|
3803
|
+
deltaMode: number;
|
|
3804
|
+
deltaX: number;
|
|
3805
|
+
deltaY: number;
|
|
3806
|
+
deltaZ: number;
|
|
3807
|
+
wheelDelta?: number;
|
|
3808
|
+
}
|
|
3809
|
+
|
|
3567
3810
|
/**
|
|
3568
3811
|
* Babylon.js `KHR_materials_variants` extension helpers. Mirrors the static
|
|
3569
3812
|
* surface ported code calls (`SelectVariant` / `GetAvailableVariants` / `Reset`)
|
|
@@ -3586,7 +3829,7 @@ export declare class Layer {
|
|
|
3586
3829
|
}
|
|
3587
3830
|
|
|
3588
3831
|
/** Babylon.js `Light` — base class for all lights (derives from `Node`). */
|
|
3589
|
-
export declare abstract class Light extends Node_2 {
|
|
3590
3832
|
protected constructor(name: string, scene?: Scene);
|
|
3833
|
+
export declare abstract class Light extends Node_2 {
|
|
3591
3834
|
protected constructor(name: string, scene?: Scene, dontAddToScene?: boolean);
|
|
3592
3835
|
getClassName(): string;
|
|
3593
3836
|
/**
|
|
3594
3837
|
* Babylon.js `light.intensity`. While the light is disabled the Lite light
|
|
3595
3838
|
* carries `0`, but the getter still returns the logical value the caller set.
|
|
@@ -3836,6 +4079,7 @@ export declare class Matrix {
|
|
|
3836
4079
|
multiplyToRef(other: Matrix, result: Matrix): Matrix;
|
|
3837
4080
|
transpose(): Matrix;
|
|
3838
4081
|
determinant(): number;
|
|
4082
|
+
/** Babylon.js `invert`: inverts this matrix in place and returns it. */
|
|
3839
4083
|
invert(): Matrix;
|
|
3840
4084
|
invertToRef(result: Matrix): Matrix;
|
|
3841
4085
|
getTranslation(): Vector3;
|
|
@@ -4289,6 +4533,14 @@ export declare class Observable<T> {
|
|
|
4289
4533
|
cleanLastNotifiedState(): void;
|
|
4290
4534
|
}
|
|
4291
4535
|
|
|
4536
|
+
export declare interface Observer<T> {
|
|
4537
|
+
callback: (eventData: T, eventState: unknown) => void;
|
|
4538
|
+
mask: number;
|
|
4539
|
+
scope: any;
|
|
4540
|
+
unregisterOnNextCall: boolean;
|
|
4541
|
+
remove(defer?: boolean): void;
|
|
4542
|
+
}
|
|
4543
|
+
|
|
4292
4544
|
/**
|
|
4293
4545
|
* Minimal Babylon.js-compatible `Observable`.
|
|
4294
4546
|
*
|
|
@@ -5004,11 +5256,27 @@ export declare class PointerEventTypes {
|
|
|
5004
5256
|
export declare class PointerInfo {
|
|
5005
5257
|
type: number;
|
|
5006
5258
|
event: PointerEvent | WheelEvent;
|
|
5007
|
-
private
|
|
5008
|
-
|
|
5259
|
+
private _pickInfo;
|
|
5260
|
+
private _pick;
|
|
5261
|
+
constructor(type: number, event: PointerEvent | WheelEvent, _pickInfo: PickingInfo | null, _pick?: (() => PickingInfo) | null);
|
|
5262
|
+
/** Like Babylon.js lazy picking: without a precomputed pick, `_pick` runs on the first read only. */
|
|
5009
5263
|
get pickInfo(): PickingInfo | null;
|
|
5010
5264
|
}
|
|
5011
5265
|
|
|
5266
|
+
export declare enum PointerInput {
|
|
5267
|
+
Horizontal = 0,
|
|
5268
|
+
Vertical = 1,
|
|
5269
|
+
LeftClick = 2,
|
|
5270
|
+
MiddleClick = 3,
|
|
5271
|
+
RightClick = 4,
|
|
5272
|
+
BrowserBack = 5,
|
|
5273
|
+
BrowserForward = 6,
|
|
5274
|
+
MouseWheelX = 7,
|
|
5275
|
+
MouseWheelY = 8,
|
|
5276
|
+
MouseWheelZ = 9,
|
|
5277
|
+
Move = 12
|
|
5278
|
+
}
|
|
5279
|
+
|
|
5012
5280
|
export declare class PointLight extends Light {
|
|
5013
5281
|
constructor(name: string, position: Vector3, scene?: Scene);
|
|
5014
5282
|
getClassName(): string;
|
|
5015
5283
|
get range(): number;
|
|
@@ -5102,8 +5370,12 @@ export declare class PositionGizmo extends GizmoBase {
|
|
|
5102
5370
|
private _attached;
|
|
5103
5371
|
set updateGizmoRotationToMatchAttachedMesh(value: boolean);
|
|
5104
5372
|
get attachedMesh(): AbstractMesh | null;
|
|
5105
5373
|
set attachedMesh(value: AbstractMesh | null);
|
|
5106
|
-
|
|
5107
|
-
|
|
5374
|
+
/**
|
|
5375
|
+
* Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
|
|
5376
|
+
* Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
|
|
5377
|
+
*/
|
|
5378
|
+
get attachedNode(): Node_2 | null;
|
|
5379
|
+
set attachedNode(value: Node_2 | null);
|
|
5108
5380
|
dispose(): void;
|
|
5109
5381
|
}
|
|
5110
5382
|
|
|
@@ -5160,6 +5432,7 @@ export declare class Quaternion {
|
|
|
5160
5432
|
constructor(x?: number, y?: number, z?: number, w?: number);
|
|
5161
5433
|
set(x: number, y: number, z: number, w: number): this;
|
|
5162
5434
|
copyFrom(source: Quaternion): this;
|
|
5435
|
+
/** Babylon.js `multiply`: the product `this · other` as a new quaternion. */
|
|
5163
5436
|
multiply(other: Quaternion): Quaternion;
|
|
5164
5437
|
length(): number;
|
|
5165
5438
|
normalize(): this;
|
|
@@ -5329,9 +5602,22 @@ export declare class RecastJSPlugin {
|
|
|
5329
5602
|
constructor();
|
|
5330
5603
|
}
|
|
5331
5604
|
|
|
5332
|
-
|
|
5333
|
-
|
|
5334
|
-
}
|
|
5605
|
+
/** Babylon.js `RectAreaLight` over Lite's native LTC-backed rectangular emitter. */
|
|
5606
|
+
export declare class RectAreaLight extends AreaLight {
|
|
5335
5607
|
constructor(name: string, position: Vector3, width: number, height: number, scene?: Scene, dontAddToScene?: boolean);
|
|
5608
|
+
getClassName(): string;
|
|
5609
|
+
getTypeID(): number;
|
|
5610
|
+
get position(): Vector3;
|
|
5611
|
+
set position(value: Vector3);
|
|
5612
|
+
get width(): number;
|
|
5613
|
+
set width(value: number);
|
|
5614
|
+
get height(): number;
|
|
5615
|
+
set height(value: number);
|
|
5616
|
+
get diffuse(): Color3;
|
|
5617
|
+
set diffuse(value: Color3);
|
|
5618
|
+
get specular(): Color3;
|
|
5619
|
+
set specular(value: Color3);
|
|
5620
|
+
get emissionTexture(): BaseTexture | null;
|
|
5621
|
+
set emissionTexture(value: BaseTexture | null);
|
|
5336
5622
|
|
|
5337
5623
|
export declare class ReflectionProbe {
|
|
5338
5624
|
constructor();
|
|
@@ -5394,6 +5680,8 @@ export declare function RegisterSPLATFileLoader(): void;
|
|
|
5394
5680
|
|
|
5395
5681
|
export declare function RegisterUSDFileLoader(): void;
|
|
5396
5682
|
|
|
5683
|
+
export declare function RemoveFlowGraphAnimationGroupObservers(_context: FlowGraphContext, _animationGroup: AnimationGroup): FlowGraphPlayAnimationBlock | undefined;
|
|
5684
|
+
|
|
5397
5685
|
/** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
|
|
5398
5686
|
export declare class RenderTargetTexture {
|
|
5399
5687
|
constructor();
|
|
@@ -5461,8 +5749,12 @@ export declare class RotationGizmo extends GizmoBase {
|
|
|
5461
5749
|
private _attached;
|
|
5462
5750
|
set updateGizmoRotationToMatchAttachedMesh(value: boolean);
|
|
5463
5751
|
get attachedMesh(): AbstractMesh | null;
|
|
5464
5752
|
set attachedMesh(value: AbstractMesh | null);
|
|
5465
|
-
|
|
5466
|
-
|
|
5753
|
+
/**
|
|
5754
|
+
* Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
|
|
5755
|
+
* Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
|
|
5756
|
+
*/
|
|
5757
|
+
get attachedNode(): Node_2 | null;
|
|
5758
|
+
set attachedNode(value: Node_2 | null);
|
|
5467
5759
|
dispose(): void;
|
|
5468
5760
|
}
|
|
5469
5761
|
|
|
@@ -5491,8 +5783,12 @@ export declare class ScaleGizmo extends GizmoBase {
|
|
|
5491
5783
|
private _attached;
|
|
5492
5784
|
set updateGizmoRotationToMatchAttachedMesh(value: boolean);
|
|
5493
5785
|
get attachedMesh(): AbstractMesh | null;
|
|
5494
5786
|
set attachedMesh(value: AbstractMesh | null);
|
|
5495
|
-
|
|
5496
|
-
|
|
5787
|
+
/**
|
|
5788
|
+
* Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
|
|
5789
|
+
* Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
|
|
5790
|
+
*/
|
|
5791
|
+
get attachedNode(): Node_2 | null;
|
|
5792
|
+
set attachedNode(value: Node_2 | null);
|
|
5497
5793
|
dispose(): void;
|
|
5498
5794
|
}
|
|
5499
5795
|
|
|
@@ -5526,6 +5822,9 @@ export declare class Scene extends AbstractScene {
|
|
|
5526
5822
|
/** Babylon.js fog-mode c
|
|
5527
5823
|
private readonly _engine;
|
|
5528
5824
|
private _activeCamera;
|
|
5529
5825
|
cameraToUseForPointers: Camera | null;
|
|
5826
|
+
/** Babylon.js `scene.pointerX` / `pointerY`: the last pointer position in CSS pixels relative to the canvas. */
|
|
5827
|
+
pointerX: number;
|
|
5828
|
+
pointerY: number;
|
|
5530
5829
|
private _defaultMaterial;
|
|
5531
5830
|
private _fogMode;
|
|
5532
5831
|
private _fogStart;
|
|
@@ -5533,6 +5832,8 @@ export declare class Scene extends AbstractScene {
|
|
|
5533
5832
|
/** Babylon.js fog-mode c
|
|
5534
5833
|
private _fogDensity;
|
|
5535
5834
|
private _fogColor;
|
|
5536
5835
|
private _started;
|
|
5537
5836
|
private _envTexture;
|
|
5837
|
+
/** Environment lighting rotation last forwarded to Lite. */
|
|
5838
|
+
private _envRotation;
|
|
5538
5839
|
private _brdfTexture;
|
|
5539
5840
|
private _defaultEnvOptions;
|
|
5540
5841
|
private readonly _shadowGenerators;
|
|
@@ -5622,6 +5923,13 @@ export declare class Scene extends AbstractScene {
|
|
|
5622
5923
|
/** Babylon.js fog-mode c
|
|
5623
5924
|
set clipPlane(value: Plane | null);
|
|
5624
5925
|
get environmentTexture(): CubeTexture | HDRCubeTexture | null;
|
|
5625
5926
|
set environmentTexture(value: CubeTexture | HDRCubeTexture | null);
|
|
5927
|
+
/**
|
|
5928
|
+
* Forward the environment texture's `rotationY` to the image-based lighting only. As in Babylon.js, a skybox keeps the
|
|
5929
|
+
* orientation it was created with (see {@link createDefaultSkybox}) and the `createDefaultEnvironment` background never
|
|
5930
|
+
* turns. Also runs every frame, so the texture needs no link back to the scenes that use it. A scene whose
|
|
5931
|
+
* environment is never rotated never calls Lite.
|
|
5932
|
+
*/
|
|
5933
|
+
private _syncEnvironmentRotation;
|
|
5626
5934
|
/**
|
|
5627
5935
|
* Babylon.js `scene.environmentBRDFTexture` — the BRDF lookup used by PBR materials.
|
|
5628
5936
|
* Babylon.js defaults this to an embedded Base64 LUT and lets apps swap in one of the
|
|
@@ -5885,6 +6193,28 @@ export declare class SmartArray<T> {
|
|
|
5885
6193
|
dispose(): void;
|
|
5886
6194
|
}
|
|
5887
6195
|
|
|
6196
|
+
declare interface SOGDataFile {
|
|
6197
|
+
shape: number[];
|
|
6198
|
+
dtype: string;
|
|
6199
|
+
mins?: number | number[];
|
|
6200
|
+
maxs?: number | number[];
|
|
6201
|
+
codebook?: number[];
|
|
6202
|
+
encoding?: string;
|
|
6203
|
+
quantization?: number;
|
|
6204
|
+
files: string[];
|
|
6205
|
+
bands?: number;
|
|
6206
|
+
}
|
|
6207
|
+
|
|
6208
|
+
declare interface SOGRootData {
|
|
6209
|
+
version?: number;
|
|
6210
|
+
means: SOGDataFile;
|
|
6211
|
+
scales: SOGDataFile;
|
|
6212
|
+
quats: SOGDataFile;
|
|
6213
|
+
sh0: SOGDataFile;
|
|
6214
|
+
shN?: SOGDataFile;
|
|
6215
|
+
count?: number;
|
|
6216
|
+
}
|
|
6217
|
+
|
|
5888
6218
|
export declare class SolidParticleSystem {
|
|
5889
6219
|
constructor();
|
|
5890
6220
|
}
|
|
@@ -6205,6 +6535,8 @@ export declare class StandardMaterial extends PushMaterial {
|
|
|
6205
6535
|
/** Diffuse col
|
|
6206
6536
|
set diffuseColor(value: Color3);
|
|
6207
6537
|
get specularColor(): Color3;
|
|
6208
6538
|
set specularColor(value: Color3);
|
|
6539
|
+
get roughness(): number;
|
|
6540
|
+
set roughness(value: number);
|
|
6209
6541
|
get emissiveColor(): Color3;
|
|
6210
6542
|
set emissiveColor(value: Color3);
|
|
6211
6543
|
get ambientColor(): Color3;
|
|
@@ -6372,6 +6704,31 @@ export declare class SurfaceMagnetismBehavior {
|
|
|
6372
6704
|
constructor();
|
|
6373
6705
|
}
|
|
6374
6706
|
|
|
6707
|
+
export declare const enum SwitchInput {
|
|
6708
|
+
B = 0,
|
|
6709
|
+
A = 1,
|
|
6710
|
+
Y = 2,
|
|
6711
|
+
X = 3,
|
|
6712
|
+
L = 4,
|
|
6713
|
+
R = 5,
|
|
6714
|
+
ZL = 6,
|
|
6715
|
+
ZR = 7,
|
|
6716
|
+
Minus = 8,
|
|
6717
|
+
Plus = 9,
|
|
6718
|
+
LS = 10,
|
|
6719
|
+
RS = 11,
|
|
6720
|
+
DPadUp = 12,
|
|
6721
|
+
DPadDown = 13,
|
|
6722
|
+
DPadLeft = 14,
|
|
6723
|
+
DPadRight = 15,
|
|
6724
|
+
Home = 16,
|
|
6725
|
+
Capture = 17,
|
|
6726
|
+
LStickXAxis = 18,
|
|
6727
|
+
LStickYAxis = 19,
|
|
6728
|
+
RStickXAxis = 20,
|
|
6729
|
+
RStickYAxis = 21
|
|
6730
|
+
}
|
|
6731
|
+
|
|
6375
6732
|
declare interface Taggable {
|
|
6376
6733
|
_tags?: Record<string, true>;
|
|
6377
6734
|
}
|
|
@@ -6958,10 +7315,7 @@ export declare class WebGPUEngine extends AbstractEngine {
|
|
|
6958
7315
|
}
|
|
6959
7316
|
|
|
6960
7317
|
/** Babylon.js `WebGPUEngineOptions` subset accepted by the compat engine. */
|
|
6961
|
-
export declare interface WebGPUEngineOptions extends
|
|
6962
|
-
antialias?: boolean;
|
|
6963
|
-
adaptToDeviceRatio?: boolean;
|
|
6964
|
-
useLargeWorldRendering?: boolean;
|
|
7318
|
+
export declare interface WebGPUEngineOptions extends AbstractEngineOptions {
|
|
6965
7319
|
canvasToneMapping?: GPUCanvasToneMapping;
|
|
6966
7320
|
canvasColorSpace?: PredefinedColorSpace;
|
|
6967
7321
|
}
|
|
@@ -6975,4 +7329,28 @@ export declare class WeightedSound {
|
|
|
6975
7329
|
constructor();
|
|
6976
7330
|
}
|
|
6977
7331
|
|
|
7332
|
+
export declare const enum XboxInput {
|
|
7333
|
+
A = 0,
|
|
7334
|
+
B = 1,
|
|
7335
|
+
X = 2,
|
|
7336
|
+
Y = 3,
|
|
7337
|
+
LB = 4,
|
|
7338
|
+
RB = 5,
|
|
7339
|
+
LT = 6,
|
|
7340
|
+
RT = 7,
|
|
7341
|
+
Back = 8,
|
|
7342
|
+
Start = 9,
|
|
7343
|
+
LS = 10,
|
|
7344
|
+
RS = 11,
|
|
7345
|
+
DPadUp = 12,
|
|
7346
|
+
DPadDown = 13,
|
|
7347
|
+
DPadLeft = 14,
|
|
7348
|
+
DPadRight = 15,
|
|
7349
|
+
Home = 16,
|
|
7350
|
+
LStickXAxis = 17,
|
|
7351
|
+
LStickYAxis = 18,
|
|
7352
|
+
RStickXAxis = 19,
|
|
7353
|
+
RStickYAxis = 20
|
|
7354
|
+
}
|
|
7355
|
+
|
|
6978
7356
|
export { }
|