@babylonjs/lite-compat 1.31.0-preview → 1.32.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 +13 -12
- package/index.d.ts +480 -63
- package/index.js +1612 -125
- package/index.js.map +1 -1
- package/{meshes-Fu955h5M.js → meshes-Ds66ewr9.js} +66 -7
- package/meshes-Ds66ewr9.js.map +1 -0
- package/navigation.d.ts +70 -18
- package/navigation.js +1 -1
- package/package.json +4 -4
- package/meshes-Fu955h5M.js.map +0 -1
package/index.d.ts
CHANGED
|
@@ -3,6 +3,7 @@ import { AnisotropyProps } from '@babylonjs/lite';
|
|
|
3
3
|
import { AssetContainer as AssetContainer_2 } from '@babylonjs/lite';
|
|
4
4
|
import { AudioGraphHost } from '@babylonjs/lite';
|
|
5
5
|
import { ClearCoatProps } from '@babylonjs/lite';
|
|
6
|
+
import { ComputeShader as ComputeShader_2 } from '@babylonjs/lite';
|
|
6
7
|
import { EngineContext } from '@babylonjs/lite';
|
|
7
8
|
import { EngineOptions } from '@babylonjs/lite';
|
|
8
9
|
import { IridescenceProps } from '@babylonjs/lite';
|
|
@@ -17,8 +18,12 @@ import { PhysicsWorld } from '@babylonjs/lite';
|
|
|
17
18
|
import { RenderCanvas } from '@babylonjs/lite';
|
|
18
19
|
import { SceneNode } from '@babylonjs/lite';
|
|
19
20
|
import { SheenProps } from '@babylonjs/lite';
|
|
21
|
+
import { StorageBuffer as StorageBuffer_2 } from '@babylonjs/lite';
|
|
20
22
|
import { Texture2D } from '@babylonjs/lite';
|
|
21
23
|
import { Texture2DArray } from '@babylonjs/lite';
|
|
24
|
+
import { UniformBuffer as UniformBuffer_2 } from '@babylonjs/lite';
|
|
25
|
+
import { UsdDiagnostics } from '@babylonjs/lite';
|
|
26
|
+
import { UsdProgress } from '@babylonjs/lite';
|
|
22
27
|
|
|
23
28
|
/** Base class for an asset-loading task. Subclasses implement {@link runAsync}. */
|
|
24
29
|
export declare abstract class AbstractAssetTask {
|
|
@@ -217,6 +222,11 @@ export declare abstract class AbstractEngine {
|
|
|
217
222
|
* scoped API cannot reproduce the engine-wide state without a pipeline-owner lifecycle policy.
|
|
218
223
|
*/
|
|
219
224
|
setAlphaToCoverage(_enable: boolean): never;
|
|
225
|
+
/**
|
|
226
|
+
* Babylon.js `engine.isOcclusionQueryVisible(query)` — Lite does not expose
|
|
227
|
+
* occlusion-query allocation, render-pass encoding, or asynchronous result state.
|
|
228
|
+
*/
|
|
229
|
+
isOcclusionQueryVisible(_query: unknown): never;
|
|
220
230
|
/**
|
|
221
231
|
* Babylon.js `engine.updateTextureArrayLayerFromImageSource(texture, source, layer, invertY, premultiplyAlpha)`
|
|
222
232
|
* — the engine extension that uploads a decoded image source into one layer of a 2D array
|
|
@@ -610,9 +620,8 @@ export declare class Angle {
|
|
|
610
620
|
}
|
|
611
621
|
|
|
612
622
|
/**
|
|
613
|
-
* Babylon.js `Animatable`
|
|
614
|
-
*
|
|
615
|
-
* the target's (dotted) property path.
|
|
623
|
+
* Babylon.js `Animatable` facade. Supported direct-animation tracks delegate to a
|
|
624
|
+
* native Lite property group; unsupported tracks retain the compat CPU evaluator.
|
|
616
625
|
*/
|
|
617
626
|
declare class Animatable_2 {
|
|
618
627
|
private readonly _target;
|
|
@@ -620,16 +629,26 @@ declare class Animatable_2 {
|
|
|
620
629
|
private readonly _from;
|
|
621
630
|
private readonly _to;
|
|
622
631
|
private readonly _loop;
|
|
623
|
-
masterFrame: number;
|
|
624
|
-
speedRatio: number;
|
|
632
|
+
masterFrame: number;
|
|
625
633
|
private _speedRatio;
|
|
626
634
|
private _paused;
|
|
627
635
|
private _stopped;
|
|
628
|
-
constructor(_target: unknown, _animations: Animation_2[], _from: number, _to: number, _loop: boolean, speedRatio: number);
|
|
629
636
|
goToFrame(frame: number): void;
|
|
637
|
+
private readonly _nativeManager;
|
|
638
|
+
private readonly _fallbackAnimations;
|
|
639
|
+
private readonly _fallbackFrames;
|
|
640
|
+
private readonly _fallbackElapsedFrames;
|
|
641
|
+
private readonly _fallbackRepeatCounts;
|
|
642
|
+
private readonly _completedFallbackAnimations;
|
|
643
|
+
constructor(target: unknown, animations: Animation_2[], from: number, to: number, loop: boolean, speedRatio: number);
|
|
630
644
|
get speedRatio(): number;
|
|
645
|
+
set speedRatio(value: number);
|
|
631
646
|
goToFrame(frame: number): void;
|
|
632
647
|
pause(): void;
|
|
633
648
|
restart(): void;
|
|
634
649
|
stop(): void;
|
|
635
650
|
get animationStarted(): boolean;
|
|
636
|
-
private
|
|
651
|
+
private _applyFallback;
|
|
652
|
+
private _advanceFallback;
|
|
653
|
+
private _resetFallbackAnimation;
|
|
654
|
+
private _attachLite;
|
|
655
|
+
private _detachLite;
|
|
637
656
|
}
|
|
638
657
|
export { Animatable_2 as Animatable }
|
|
639
658
|
|
|
@@ -644,16 +663,29 @@ declare class Animation_2 {
|
|
|
644
663
|
static readonly ANIMATIONTYPE_QUATERNION: 2;
|
|
645
664
|
static readonly ANIMATIONTYPE_MATRIX: 3;
|
|
646
665
|
static readonly ANIMATIONTYPE_COLOR3: 4;
|
|
666
|
+
static readonly ANIMATIONTYPE_VECTOR2: 5;
|
|
667
|
+
static readonly ANIMATIONTYPE_COLOR4: 6;
|
|
647
668
|
static readonly ANIMATIONLOOPMODE_RELATIVE: 0;
|
|
648
669
|
static readonly ANIMATIONLOOPMODE_CYCLE: 1;
|
|
649
670
|
static readonly ANIMATIONLOOPMODE_CONSTANT: 2;
|
|
650
671
|
private _keys;
|
|
672
|
+
private _easingFunction;
|
|
651
673
|
constructor(name: string, targetProperty: string, framePerSecond: number, dataType?: number, loopMode?: number);
|
|
652
674
|
setKeys(keys: IAnimationKey[]): void;
|
|
653
675
|
getKeys(): IAnimationKey[];
|
|
654
676
|
getHighestFrame(): number;
|
|
655
|
-
/**
|
|
656
|
-
|
|
677
|
+
/**
|
|
678
|
+
* Assigns the easing function used to transform each non-STEP segment's normalized progress.
|
|
679
|
+
* @param easingFunction - A Babylon.js-shaped easing object, or `null` to restore linear progress.
|
|
680
|
+
*/
|
|
681
|
+
setEasingFunction(easingFunction: IEasingFunction | null): void;
|
|
682
|
+
/**
|
|
683
|
+
* Gets the easing function currently assigned to this animation.
|
|
684
|
+
* @returns The assigned easing object, or `null` when interpolation uses linear progress.
|
|
685
|
+
*/
|
|
686
|
+
getEasingFunction(): IEasingFunction | null;
|
|
687
|
+
/** Evaluate the animated value at `frame`, clamped to the key range. */
|
|
688
|
+
evaluate(frame: number): AnimationValue;
|
|
657
689
|
/** Babylon.js helper: build a one-shot float animation between two values. */
|
|
658
690
|
static CreateAndStartAnimation(name: string, _target: unknown, targetProperty: string, framePerSecond: number, totalFrame: number, from: number, to: number): Animation_2;
|
|
659
691
|
}
|
|
@@ -762,6 +794,8 @@ export declare const AnimationTypes: {
|
|
|
762
794
|
readonly ANIMATIONTYPE_COLOR4: 6;
|
|
763
795
|
};
|
|
764
796
|
|
|
797
|
+
export declare type AnimationValue = number | number[] | IAnimationVectorValue;
|
|
798
|
+
|
|
765
799
|
export declare interface AppendOptions extends ISceneLoaderOptions {
|
|
766
800
|
}
|
|
767
801
|
|
|
@@ -794,7 +828,9 @@ export declare class ArcRotateCamera extends Camera {
|
|
|
794
828
|
constructor(name: stri
|
|
795
829
|
set panningSensibility(value: number);
|
|
796
830
|
attachControl(canvas: HTMLCanvasElement, noPreventDefault?: boolean): void;
|
|
797
831
|
|
|
798
|
-
export declare class AssetContainer {
|
|
799
832
|
constructor(lite: AssetContainer_2);
|
|
833
|
+
export declare class AssetContainer {
|
|
800
834
|
private readonly _dispose;
|
|
801
835
|
private _sceneDisposeObserver;
|
|
836
|
+
private _disposed;
|
|
837
|
+
constructor(lite: AssetContainer_2, dispose?: () => void, ownedMeshes?: readonly Mesh_2[]);
|
|
802
838
|
get animationGroups(): AnimationGroup_2[];
|
|
803
839
|
/**
|
|
804
840
|
* Flat list of the loaded meshes as canonical, stable-identity compat `Mesh`
|
|
@@ -805,8 +841,10 @@ export declare class AssetContainer {
|
|
|
805
841
|
constructor(lite: AssetContainer_2);
|
|
806
842
|
get meshes(): Mesh[];
|
|
807
843
|
get skeletons(): Skeleton[];
|
|
808
844
|
/** Add every entity, animation group, camera, and clear colour to the scene. */
|
|
809
|
-
addAllToScene(scene: Scene): void;
|
|
810
|
-
dispose(): void;
|
|
845
|
+
addAllToScene(scene: Scene): void;
|
|
811
846
|
dispose(): void;
|
|
847
|
+
private _detachFromScene;
|
|
848
|
+
private _retireMeshWrappers;
|
|
849
|
+
private _disposeOnce;
|
|
812
850
|
}
|
|
813
851
|
|
|
814
852
|
export declare class AssetsManager {
|
|
@@ -984,7 +1022,7 @@ export declare class AxisScaleGizmo extends GizmoBase {
|
|
|
984
1022
|
private _attached;
|
|
985
1023
|
}
|
|
986
1024
|
|
|
987
1025
|
export declare class BackEase extends EasingFunction {
|
|
988
|
-
|
|
1026
|
+
amplitude: number;
|
|
989
1027
|
constructor(amplitude?: number);
|
|
990
1028
|
easeInCore(gradient: number): number;
|
|
991
1029
|
}
|
|
@@ -1020,6 +1058,18 @@ export declare interface Behavior<T> {
|
|
|
1020
1058
|
detach(): void;
|
|
1021
1059
|
}
|
|
1022
1060
|
|
|
1061
|
+
/**
|
|
1062
|
+
* Babylon.js-compatible cubic Bezier easing class.
|
|
1063
|
+
*/
|
|
1064
|
+
export declare class BezierCurveEase extends EasingFunction {
|
|
1065
|
+
x1: number;
|
|
1066
|
+
y1: number;
|
|
1067
|
+
x2: number;
|
|
1068
|
+
y2: number;
|
|
1069
|
+
constructor(x1?: number, y1?: number, x2?: number, y2?: number);
|
|
1070
|
+
easeInCore(gradient: number): number;
|
|
1071
|
+
}
|
|
1072
|
+
|
|
1023
1073
|
export declare const BlackAndWhitePostProcess: new () => never;
|
|
1024
1074
|
|
|
1025
1075
|
export declare const BloomEffect: new () => never;
|
|
@@ -1039,8 +1089,8 @@ export declare class Bone {
|
|
|
1039
1089
|
}
|
|
1040
1090
|
|
|
1041
1091
|
export declare class BounceEase extends EasingFunction {
|
|
1042
|
-
|
|
1043
|
-
|
|
1092
|
+
bounces: number;
|
|
1093
|
+
bounciness: number;
|
|
1044
1094
|
constructor(bounces?: number, bounciness?: number);
|
|
1045
1095
|
easeInCore(gradient: number): number;
|
|
1046
1096
|
}
|
|
@@ -1349,6 +1399,12 @@ export declare class Color3 {
|
|
|
1349
1399
|
static Lerp(start: Color3, end: Color3, amount: number): Color3;
|
|
1350
1400
|
}
|
|
1351
1401
|
|
|
1402
|
+
declare interface Color3Like {
|
|
1403
|
+
readonly r: number;
|
|
1404
|
+
readonly g: number;
|
|
1405
|
+
readonly b: number;
|
|
1406
|
+
}
|
|
1407
|
+
|
|
1352
1408
|
export declare class Color4 {
|
|
1353
1409
|
r: number;
|
|
1354
1410
|
g: number;
|
|
@@ -1366,6 +1422,10 @@ export declare class Color4 {
|
|
|
1366
1422
|
static FromInts(r: number, g: number, b: number, a: number): Color4;
|
|
1367
1423
|
}
|
|
1368
1424
|
|
|
1425
|
+
declare interface Color4Like extends Color3Like {
|
|
1426
|
+
readonly a: number;
|
|
1427
|
+
}
|
|
1428
|
+
|
|
1369
1429
|
/** An RGBA color bound to a [0, 1] position (Babylon.js `ColorGradient`). */
|
|
1370
1430
|
export declare class ColorGradient {
|
|
1371
1431
|
gradient: number;
|
|
@@ -1382,9 +1442,66 @@ export declare function CompleteGreasedLineColorTable(..._args: unknown[]): neve
|
|
|
1382
1442
|
|
|
1383
1443
|
export declare function CompleteGreasedLineWidthTable(..._args: unknown[]): never;
|
|
1384
1444
|
|
|
1445
|
+
export declare interface ComputeBindingLocation {
|
|
1446
|
+
group: number;
|
|
1447
|
+
binding: number;
|
|
1448
|
+
}
|
|
1449
|
+
|
|
1450
|
+
export declare type ComputeBindingMapping = Record<string, ComputeBindingLocation>;
|
|
1451
|
+
|
|
1452
|
+
declare type ComputeEffect = ComputeShader_2;
|
|
1453
|
+
|
|
1385
1454
|
/** Babylon.js `ComputeOverlayCssTransform` — HTML overlay interaction is unsupported by the compat layer. */
|
|
1386
1455
|
export declare function ComputeOverlayCssTransform(): never;
|
|
1387
1456
|
|
|
1457
|
+
/** Babylon.js ComputeShader adapted to Lite's public buffer-backed compute graph. */
|
|
1458
|
+
export declare class ComputeShader {
|
|
1459
|
+
private readonly _engine;
|
|
1460
|
+
private readonly _shaderPath;
|
|
1461
|
+
static readonly Parse: typeof ComputeShaderParse;
|
|
1462
|
+
readonly uniqueId: number;
|
|
1463
|
+
name: string;
|
|
1464
|
+
fastMode: boolean;
|
|
1465
|
+
onCompiled: ((effect: ComputeEffect) => void) | null;
|
|
1466
|
+
onError: ((effect: ComputeEffect, errors: string) => void) | null;
|
|
1467
|
+
readonly gpuTimeInFrame: undefined;
|
|
1468
|
+
triggerContextRebuild: boolean;
|
|
1469
|
+
private readonly _source;
|
|
1470
|
+
private readonly _bindings;
|
|
1471
|
+
private _shader;
|
|
1472
|
+
private _bindingSet;
|
|
1473
|
+
private _bindingsDirty;
|
|
1474
|
+
private _shaderDirty;
|
|
1475
|
+
private _compiled;
|
|
1476
|
+
constructor(name: string, _engine: AbstractEngine, _shaderPath: IComputeShaderPath | string, options?: Partial<IComputeShaderOptions>);
|
|
1477
|
+
private readonly _options;
|
|
1478
|
+
get options(): IComputeShaderOptions;
|
|
1479
|
+
get shaderPath(): string | IComputeShaderPath;
|
|
1480
|
+
getClassName(): string;
|
|
1481
|
+
setTexture(_name: string, _texture: BaseTexture, _bindSampler?: boolean): never;
|
|
1482
|
+
setInternalTexture(_name: string, _texture: unknown): never;
|
|
1483
|
+
setStorageTexture(_name: string, _texture: BaseTexture): never;
|
|
1484
|
+
setExternalTexture(_name: string, _texture: unknown): never;
|
|
1485
|
+
setVideoTexture(_name: string, _texture: unknown): false;
|
|
1486
|
+
setUniformBuffer(name: string, buffer: UniformBuffer | UniformBuffer_2): void;
|
|
1487
|
+
setStorageBuffer(name: string, buffer: StorageBuffer | StorageBuffer_2): void;
|
|
1488
|
+
setTextureSampler(_name: string, _sampler: unknown): never;
|
|
1489
|
+
isReady(): boolean;
|
|
1490
|
+
dispatch(x: number, y?: number, z?: number): boolean;
|
|
1491
|
+
dispatchIndirect(buffer: StorageBuffer | StorageBuffer_2, offset?: number): boolean;
|
|
1492
|
+
dispatchWhenReady(x: number, y?: number, z?: number, delay?: number): Promise<void>;
|
|
1493
|
+
serialize(): Record<string, unknown>;
|
|
1494
|
+
private _createGraph;
|
|
1495
|
+
private _createShader;
|
|
1496
|
+
private _createBindingSet;
|
|
1497
|
+
private _submit;
|
|
1498
|
+
private _invalidateBindings;
|
|
1499
|
+
}
|
|
1500
|
+
|
|
1501
|
+
export declare function ComputeShaderParse(source: Record<string, unknown>, scene: {
|
|
1502
|
+
getEngine(): AbstractEngine;
|
|
1503
|
+
}, _rootUrl: string): ComputeShader;
|
|
1504
|
+
|
|
1388
1505
|
/** Base class for action conditions. */
|
|
1389
1506
|
export declare abstract class Condition {
|
|
1390
1507
|
abstract isValid(): boolean;
|
|
@@ -1417,6 +1534,14 @@ export declare const Constants: {
|
|
|
1417
1534
|
readonly TEXTURE_TRILINEAR_SAMPLINGMODE: 3;
|
|
1418
1535
|
readonly TEXTUREFORMAT_RGBA: 5;
|
|
1419
1536
|
readonly TEXTURETYPE_UNSIGNED_BYTE: 0;
|
|
1537
|
+
readonly BUFFER_CREATIONFLAG_READ: 1;
|
|
1538
|
+
readonly BUFFER_CREATIONFLAG_WRITE: 2;
|
|
1539
|
+
readonly BUFFER_CREATIONFLAG_READWRITE: 3;
|
|
1540
|
+
readonly BUFFER_CREATIONFLAG_UNIFORM: 4;
|
|
1541
|
+
readonly BUFFER_CREATIONFLAG_VERTEX: 8;
|
|
1542
|
+
readonly BUFFER_CREATIONFLAG_INDEX: 16;
|
|
1543
|
+
readonly BUFFER_CREATIONFLAG_STORAGE: 32;
|
|
1544
|
+
readonly BUFFER_CREATIONFLAG_INDIRECT: 64;
|
|
1420
1545
|
};
|
|
1421
1546
|
|
|
1422
1547
|
/** Babylon.js `CreateAudioBusAsync`. */
|
|
@@ -1634,6 +1759,8 @@ declare interface DashedLinesBuilderOptions {
|
|
|
1634
1759
|
material?: unknown;
|
|
1635
1760
|
}
|
|
1636
1761
|
|
|
1762
|
+
export declare type DataArray = number[] | ArrayBufferLike | ArrayBufferView;
|
|
1763
|
+
|
|
1637
1764
|
declare interface DefaultEnvironmentOptions {
|
|
1638
1765
|
createSkybox?: boolean;
|
|
1639
1766
|
createGround?: boolean;
|
|
@@ -1749,7 +1876,7 @@ export declare class DynamicTexture extends BaseTexture {
|
|
|
1749
1876
|
whenReadyAsync(): Promise<void>;
|
|
1750
1877
|
}
|
|
1751
1878
|
|
|
1752
|
-
export declare abstract class EasingFunction {
|
|
1879
|
+
export declare abstract class EasingFunction implements IEasingFunction {
|
|
1753
1880
|
static readonly EASINGMODE_EASEIN = 0;
|
|
1754
1881
|
static readonly EASINGMODE_EASEOUT = 1;
|
|
1755
1882
|
static readonly EASINGMODE_EASEINOUT = 2;
|
|
@@ -1762,10 +1889,10 @@ export declare abstract class EasingFunction {
|
|
|
1762
1889
|
}
|
|
1763
1890
|
|
|
1764
1891
|
/**
|
|
1765
|
-
* Babylon.js-compatible easing functions
|
|
1892
|
+
* Babylon.js-compatible easing functions over Babylon Lite's functional curves.
|
|
1766
1893
|
*
|
|
1767
|
-
* These
|
|
1768
|
-
*
|
|
1894
|
+
* These retain Babylon.js's class hierarchy and easing modes for porting while
|
|
1895
|
+
* delegating curve math to tree-shakable native Lite functions.
|
|
1769
1896
|
*/
|
|
1770
1897
|
export declare const EASINGMODE_EASEIN = 0;
|
|
1771
1898
|
|
|
@@ -1782,8 +1909,8 @@ export declare class EffectLayer {
|
|
|
1782
1909
|
}
|
|
1783
1910
|
|
|
1784
1911
|
export declare class ElasticEase extends EasingFunction {
|
|
1785
|
-
|
|
1786
|
-
|
|
1912
|
+
oscillations: number;
|
|
1913
|
+
springiness: number;
|
|
1787
1914
|
constructor(oscillations?: number, springiness?: number);
|
|
1788
1915
|
easeInCore(gradient: number): number;
|
|
1789
1916
|
}
|
|
@@ -1808,7 +1935,7 @@ export declare class ExecuteCodeAction extends Action {
|
|
|
1808
1935
|
}
|
|
1809
1936
|
|
|
1810
1937
|
export declare class ExponentialEase extends EasingFunction {
|
|
1811
|
-
|
|
1938
|
+
exponent: number;
|
|
1812
1939
|
constructor(exponent?: number);
|
|
1813
1940
|
easeInCore(gradient: number): number;
|
|
1814
1941
|
}
|
|
@@ -1943,6 +2070,8 @@ export declare interface FBXLoaderWarning {
|
|
|
1943
2070
|
|
|
1944
2071
|
export declare type FBXNormalMapCoordinateSystem = "y-up" | "y-down";
|
|
1945
2072
|
|
|
2073
|
+
declare type FloatArray = number[] | Float32Array;
|
|
2074
|
+
|
|
1946
2075
|
export declare enum FlowGraphValidationSeverity {
|
|
1947
2076
|
Error = 0,
|
|
1948
2077
|
Warning = 1
|
|
@@ -2610,11 +2739,21 @@ export declare interface IAbstractSoundOptions extends Partial<IVolumeAudioOptio
|
|
|
2610
2739
|
|
|
2611
2740
|
export declare interface IAnimationKey {
|
|
2612
2741
|
frame: number;
|
|
2613
|
-
value:
|
|
2742
|
+
value: AnimationValue;
|
|
2614
2743
|
/** Babylon.js per-key interpolation hint (`AnimationKeyInterpolation`). */
|
|
2615
2744
|
interpolation?: number;
|
|
2616
2745
|
}
|
|
2617
2746
|
|
|
2747
|
+
/** Structural vector/quaternion value accepted by Babylon.js animation keys. */
|
|
2748
|
+
export declare interface IAnimationVectorValue {
|
|
2749
|
+
readonly x: number;
|
|
2750
|
+
readonly y: number;
|
|
2751
|
+
readonly z?: number;
|
|
2752
|
+
readonly w?: number;
|
|
2753
|
+
clone(): IAnimationVectorValue;
|
|
2754
|
+
asArray(): number[];
|
|
2755
|
+
}
|
|
2756
|
+
|
|
2618
2757
|
/** Babylon.js `IAudioAnalyzerOptions`. */
|
|
2619
2758
|
export declare interface IAudioAnalyzerOptions {
|
|
2620
2759
|
/** Build the analyzer immediately. Defaults to `false`. */
|
|
@@ -2668,6 +2807,20 @@ export declare interface ICharacterControllerCollisionEvent {
|
|
|
2668
2807
|
impulsePosition: Vector3;
|
|
2669
2808
|
}
|
|
2670
2809
|
|
|
2810
|
+
export declare interface IComputeShaderOptions {
|
|
2811
|
+
bindingsMapping: ComputeBindingMapping;
|
|
2812
|
+
defines?: string[];
|
|
2813
|
+
entryPoint?: string;
|
|
2814
|
+
processFinalCode?: ((code: string) => string) | null;
|
|
2815
|
+
useExplicitComputePipelineLayout?: boolean;
|
|
2816
|
+
}
|
|
2817
|
+
|
|
2818
|
+
export declare interface IComputeShaderPath {
|
|
2819
|
+
computeSource?: string;
|
|
2820
|
+
compute?: string;
|
|
2821
|
+
computeElement?: string;
|
|
2822
|
+
}
|
|
2823
|
+
|
|
2671
2824
|
/** Babylon.js `ICreateTexture2DArrayFromImageUrlsOptions`. */
|
|
2672
2825
|
export declare interface ICreateTexture2DArrayFromImageUrlsOptions extends IUploadImageToTexture2DArrayLayerOptions {
|
|
2673
2826
|
/** Generate a full mip chain (true by default). */
|
|
@@ -2695,6 +2848,20 @@ export declare interface IDitheredTileFadeBounds {
|
|
|
2695
2848
|
upperBound: number;
|
|
2696
2849
|
}
|
|
2697
2850
|
|
|
2851
|
+
/**
|
|
2852
|
+
* Contract implemented by Babylon.js easing functions.
|
|
2853
|
+
*
|
|
2854
|
+
* Custom easing objects only need to transform a normalized segment gradient.
|
|
2855
|
+
*/
|
|
2856
|
+
export declare interface IEasingFunction {
|
|
2857
|
+
/**
|
|
2858
|
+
* Transform a segment-local gradient.
|
|
2859
|
+
* @param gradient - Linear progress through the current keyframe segment.
|
|
2860
|
+
* @returns The progress used for interpolation. Values are not clamped.
|
|
2861
|
+
*/
|
|
2862
|
+
ease(gradient: number): number;
|
|
2863
|
+
}
|
|
2864
|
+
|
|
2698
2865
|
export declare interface IFlowGraphValidationIssue {
|
|
2699
2866
|
severity: FlowGraphValidationSeverity;
|
|
2700
2867
|
message: string;
|
|
@@ -2870,6 +3037,22 @@ export declare interface IRaycastQuery {
|
|
|
2870
3037
|
ignoreBody?: PhysicsBody;
|
|
2871
3038
|
}
|
|
2872
3039
|
|
|
3040
|
+
export declare interface IRootMotionClipOptions {
|
|
3041
|
+
rootNode?: TransformNode | Bone;
|
|
3042
|
+
characterNode?: TransformNode;
|
|
3043
|
+
contactNodes?: Array<TransformNode | Bone>;
|
|
3044
|
+
source?: RootMotionSource;
|
|
3045
|
+
extractRotation?: boolean;
|
|
3046
|
+
samplesPerSecond?: number;
|
|
3047
|
+
minimumTravel?: number;
|
|
3048
|
+
minimumTurn?: number;
|
|
3049
|
+
directionSnapAngle?: number;
|
|
3050
|
+
extractLateralMotion?: boolean;
|
|
3051
|
+
upAxis?: Vector3;
|
|
3052
|
+
name?: string;
|
|
3053
|
+
cloneAnimations?: boolean;
|
|
3054
|
+
}
|
|
3055
|
+
|
|
2873
3056
|
/**
|
|
2874
3057
|
* Babylon.js `ISafeOrbitCameraLimits` — safe-orbit camera limits embedded in a Gaussian
|
|
2875
3058
|
* Splatting file's metadata (Adobe safe-orbit extension). Exposed on the loaded mesh via
|
|
@@ -2892,6 +3075,8 @@ export declare interface ISceneLoaderOptions {
|
|
|
2892
3075
|
preprocessUrlAsync?: (url: string) => Promise<string>;
|
|
2893
3076
|
[option: string]: unknown;
|
|
2894
3077
|
};
|
|
3078
|
+
splat?: Partial<Readonly<SPLATLoadingOptions>>;
|
|
3079
|
+
usd?: Partial<USDFileLoaderOptions>;
|
|
2895
3080
|
};
|
|
2896
3081
|
}
|
|
2897
3082
|
|
|
@@ -3372,6 +3557,11 @@ export declare class Matrix {
|
|
|
3372
3557
|
markAsUpdated(): this;
|
|
3373
3558
|
}
|
|
3374
3559
|
|
|
3560
|
+
declare interface MatrixLike {
|
|
3561
|
+
asArray(): ArrayLike<number>;
|
|
3562
|
+
readonly updateFlag?: number;
|
|
3563
|
+
}
|
|
3564
|
+
|
|
3375
3565
|
export { MaxTintMagnitude }
|
|
3376
3566
|
|
|
3377
3567
|
/** Babylon.js `Mesh` — a concrete renderable mesh with geometry. */
|
|
@@ -3752,8 +3942,7 @@ export declare class Observable<T> {
|
|
|
3752
3942
|
addOnce(callback: ObserverCallback<T>, mask?: number): ObserverCallback<T>;
|
|
3753
3943
|
remove(callback: ObserverCallback<T> | null | undefined): boolean;
|
|
3754
3944
|
removeCallback(callback: ObserverCallback<T>): boolean;
|
|
3755
|
-
notifyObservers(eventData?: T, mask?: number): void;
|
|
3756
|
-
hasObservers(): boolean;
|
|
3945
|
+
notifyObservers(eventData?: T, mask?: number): void;
|
|
3757
3946
|
hasObservers(): boolean;
|
|
3758
3947
|
clear(): void;
|
|
3759
3948
|
cleanLastNotifiedState(): void;
|
|
3760
3949
|
}
|
|
@@ -4557,6 +4746,15 @@ export declare class PostProcess {
|
|
|
4557
4746
|
constructor();
|
|
4558
4747
|
}
|
|
4559
4748
|
|
|
4749
|
+
/**
|
|
4750
|
+
* Babylon.js-compatible power easing class.
|
|
4751
|
+
*/
|
|
4752
|
+
export declare class PowerEase extends EasingFunction {
|
|
4753
|
+
power: number;
|
|
4754
|
+
constructor(power?: number);
|
|
4755
|
+
easeInCore(gradient: number): number;
|
|
4756
|
+
}
|
|
4757
|
+
|
|
4560
4758
|
/** Babylon.js `PrecisionDate` — high-resolution timestamp source. */
|
|
4561
4759
|
export declare const PrecisionDate: {
|
|
4562
4760
|
readonly Now: number;
|
|
@@ -4778,6 +4976,8 @@ export declare function RegisterAbstractEngineTextureLoaders(): void;
|
|
|
4778
4976
|
*/
|
|
4779
4977
|
export declare function registerBuiltInLoaders(): void;
|
|
4780
4978
|
|
|
4979
|
+
export declare function RegisterComputeShader(): void;
|
|
4980
|
+
|
|
4781
4981
|
/** Pure-build registration shim; compat wires the Lite array upload directly. */
|
|
4782
4982
|
export declare function RegisterEnginesExtensionsEngineTexture2DArrayImageSource(): void;
|
|
4783
4983
|
|
|
@@ -4795,13 +4995,60 @@ export declare function RegisterMeshBlendingPostProcessBlock(): never;
|
|
|
4795
4995
|
|
|
4796
4996
|
export declare function RegisterOpenpbrMaterial(): void;
|
|
4797
4997
|
|
|
4798
|
-
export declare function
|
|
4998
|
+
export declare function RegisterSPLATFileLoader(): void;
|
|
4999
|
+
|
|
5000
|
+
export declare function RegisterUSDFileLoader(): void;
|
|
4799
5001
|
|
|
4800
5002
|
/** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
|
|
4801
5003
|
export declare class RenderTargetTexture {
|
|
4802
5004
|
constructor();
|
|
4803
5005
|
}
|
|
4804
5006
|
|
|
5007
|
+
export declare class RootMotionClip {
|
|
5008
|
+
constructor(_animationGroup: AnimationGroup, _options?: IRootMotionClipOptions);
|
|
5009
|
+
get sourceAnimationGroup(): AnimationGroup;
|
|
5010
|
+
get animationGroup(): AnimationGroup;
|
|
5011
|
+
get controller(): RootMotionController | null;
|
|
5012
|
+
get source(): RootMotionSource;
|
|
5013
|
+
get rootNode(): TransformNode | null;
|
|
5014
|
+
get characterNode(): TransformNode;
|
|
5015
|
+
get contactNodes(): ReadonlyArray<TransformNode>;
|
|
5016
|
+
get upAxis(): Vector3;
|
|
5017
|
+
get fromFrame(): number;
|
|
5018
|
+
get toFrame(): number;
|
|
5019
|
+
get travelDirection(): Vector3;
|
|
5020
|
+
get cycleOffset(): Vector3;
|
|
5021
|
+
get cycleDistance(): number;
|
|
5022
|
+
get cycleRotation(): number;
|
|
5023
|
+
get extractsRotation(): boolean;
|
|
5024
|
+
get duration(): number;
|
|
5025
|
+
get averageSpeed(): number;
|
|
5026
|
+
get characterHeight(): number;
|
|
5027
|
+
getOffsetAtFrame(_frame: number, _result: Vector3): Vector3;
|
|
5028
|
+
getRotationAtFrame(_frame: number): number;
|
|
5029
|
+
dispose(): void;
|
|
5030
|
+
}
|
|
5031
|
+
|
|
5032
|
+
export declare class RootMotionController {
|
|
5033
|
+
applyToCharacter: boolean;
|
|
5034
|
+
readonly onRootMotionObservable: Observable<RootMotionController>;
|
|
5035
|
+
constructor(_characterNode: TransformNode, _clips?: RootMotionClip[]);
|
|
5036
|
+
get characterNode(): TransformNode;
|
|
5037
|
+
get clips(): ReadonlyArray<RootMotionClip>;
|
|
5038
|
+
get deltaPosition(): Vector3;
|
|
5039
|
+
get deltaRotation(): number;
|
|
5040
|
+
addClip(_clip: RootMotionClip): void;
|
|
5041
|
+
removeClip(_clip: RootMotionClip): void;
|
|
5042
|
+
reset(): void;
|
|
5043
|
+
dispose(): void;
|
|
5044
|
+
}
|
|
5045
|
+
|
|
5046
|
+
export declare enum RootMotionSource {
|
|
5047
|
+
None = 0,
|
|
5048
|
+
Root = 1,
|
|
5049
|
+
FootContact = 2
|
|
5050
|
+
}
|
|
5051
|
+
|
|
4805
5052
|
export declare class RotationGizmo extends GizmoBase {
|
|
4806
5053
|
private _attached;
|
|
4807
5054
|
private _xGizmo;
|
|
4808
5055
|
private _yGizmo;
|
|
@@ -4874,8 +5121,8 @@ export declare class Scene extends AbstractScene {
|
|
|
4874
5121
|
/** Babylon.js fog-mode c
|
|
4875
5122
|
* Babylon.js `scene.animationGroups` / `scene.animatables`. Loaded glTF /
|
|
4876
5123
|
* `.babylon` animation clips live on the Lite scene; `animationGroups` returns
|
|
4877
5124
|
* BJS-shaped `AnimationGroup`s over them (so scenes can `goToFrame`/`pause`/`stop`
|
|
4878
|
-
* to freeze a model at a deterministic frame). `animatables` surfaces the
|
|
4879
|
-
*
|
|
5125
|
+
* to freeze a model at a deterministic frame). `animatables` surfaces the
|
|
5126
|
+
* native-backed and fallback `Animatable`s started through the scene.
|
|
4880
5127
|
*/
|
|
4881
5128
|
get animationGroups(): AnimationGroup[];
|
|
4882
5129
|
/** Babylon.js `scene.getAnimationGroupByName(name)` — first loaded animation group with a matching name, else `null`. */
|
|
@@ -4899,8 +5146,7 @@ export declare class Scene extends AbstractScene {
|
|
|
4899
5146
|
/** Babylon.js fog-mode c
|
|
4900
5147
|
private readonly _pendingMorphBuilds;
|
|
4901
5148
|
private _materialPluginsRequested;
|
|
4902
5149
|
private readonly _pendingMaterialPluginReconciliations;
|
|
4903
|
-
private readonly _runningAnimatables;
|
|
4904
|
-
private readonly _animationGroupCache;
|
|
4905
5150
|
private _ambientColor;
|
|
5151
|
+
private readonly _runningAnimatables;
|
|
4906
5152
|
private readonly _animationGroupCache;
|
|
4907
5153
|
private _ambientColor;
|
|
4908
5154
|
private _environmentIntensity;
|
|
4909
5155
|
private _imageProcessingConfiguration;
|
|
4910
5156
|
/** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
|
|
4911
5157
|
readonly uniqueId: number;
|
|
@@ -5062,8 +5308,9 @@ export declare class Scene extends AbstractScene {
|
|
|
5062
5308
|
/** Babylon.js fog-mode c
|
|
5063
5309
|
disablePhysicsEngine(): void;
|
|
5064
5310
|
/**
|
|
5065
5311
|
* Babylon.js `scene.beginDirectAnimation(target, animations, from, to, loop, speedRatio?)`.
|
|
5066
|
-
*
|
|
5067
|
-
*
|
|
5312
|
+
* Delegates supported tracks to Babylon Lite property animation and retains
|
|
5313
|
+
* explicit compat evaluation only for unsupported tracks. Returns one facade
|
|
5314
|
+
* coordinating both subsets.
|
|
5068
5315
|
*/
|
|
5069
5316
|
beginDirectAnimation(target: unknown, animations: Animation_2[], from: number, to: number, loop?: boolean, speedRatio?: number): Animatable_2;
|
|
5070
5317
|
/**
|
|
5071
5318
|
* Babylon.js `scene.beginAnimation(target, from, to, loop, speedRatio?)`. Runs
|
|
@@ -5355,6 +5602,60 @@ export declare class Spherical {
|
|
|
5355
5602
|
static FromArray(array: number[]): Spherical;
|
|
5356
5603
|
}
|
|
5357
5604
|
|
|
5605
|
+
export declare class SPLATFileLoader {
|
|
5606
|
+
readonly name = "splat";
|
|
5607
|
+
readonly extensions: {
|
|
5608
|
+
readonly ".splat": {
|
|
5609
|
+
readonly isBinary: true;
|
|
5610
|
+
};
|
|
5611
|
+
readonly ".ply": {
|
|
5612
|
+
readonly isBinary: true;
|
|
5613
|
+
};
|
|
5614
|
+
readonly ".spz": {
|
|
5615
|
+
readonly isBinary: true;
|
|
5616
|
+
};
|
|
5617
|
+
readonly ".json": {
|
|
5618
|
+
readonly isBinary: false;
|
|
5619
|
+
};
|
|
5620
|
+
readonly ".sog": {
|
|
5621
|
+
readonly isBinary: true;
|
|
5622
|
+
};
|
|
5623
|
+
};
|
|
5624
|
+
private readonly _loadingOptions;
|
|
5625
|
+
constructor(loadingOptions?: Partial<Readonly<SPLATLoadingOptions>>);
|
|
5626
|
+
createPlugin(options: {
|
|
5627
|
+
splat?: Partial<Readonly<SPLATLoadingOptions>>;
|
|
5628
|
+
}): SPLATFileLoader;
|
|
5629
|
+
importMeshAsync(_meshesNames: unknown, scene: Scene, data: unknown, _rootUrl: string, _onProgress?: (event: ISceneLoaderProgressEvent) => void, _fileName?: string): Promise<SPLATImportResult>;
|
|
5630
|
+
loadAsync(scene: Scene, data: unknown, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<void>;
|
|
5631
|
+
loadAssetContainerAsync(_scene: Scene, _data: string, _rootUrl: string): Promise<AssetContainer>;
|
|
5358
5632
|
private _load;
|
|
5633
|
+
private _loadReserved;
|
|
5634
|
+
private _adoptLoaded;
|
|
5635
|
+
}
|
|
5636
|
+
|
|
5637
|
+
declare interface SPLATImportResult {
|
|
5638
|
+
meshes: GaussianSplattingMesh[];
|
|
5639
|
+
particleSystems: unknown[];
|
|
5640
|
+
skeletons: unknown[];
|
|
5641
|
+
animationGroups: unknown[];
|
|
5642
|
+
transformNodes: unknown[];
|
|
5643
|
+
geometries: unknown[];
|
|
5644
|
+
lights: unknown[];
|
|
5645
|
+
spriteManagers: unknown[];
|
|
5646
|
+
}
|
|
5647
|
+
|
|
5648
|
+
export declare type SPLATLoadingOptions = {
|
|
5649
|
+
keepInRam?: boolean;
|
|
5650
|
+
flipY?: boolean;
|
|
5651
|
+
deflateURL?: string;
|
|
5652
|
+
fflate?: unknown;
|
|
5653
|
+
disableAutoCameraLimits?: boolean;
|
|
5654
|
+
gaussianSplattingMesh?: GaussianSplattingMesh;
|
|
5655
|
+
needsRotationScaleTextures?: boolean;
|
|
5656
|
+
useSogTextures?: boolean;
|
|
5657
|
+
spzLibraryUrl?: string;
|
|
5658
|
+
};
|
|
5659
|
+
|
|
5359
5660
|
export declare class SpotLight extends Light {
|
|
5360
5661
|
constructor(name: string, position: Vector3, direction: Vector3, angle: number, exponent: number, scene?: Scene);
|
|
5361
5662
|
getClassName(): string;
|
|
5362
5663
|
get angle(): number;
|
|
@@ -5432,7 +5733,9 @@ export declare class SpriteManager {
|
|
|
5432
5733
|
disableDepthWrite: boolean;
|
|
5433
5734
|
/** Babylon.js `manager.blendMode` (`Constants.ALPHA_*`). Mapped to a Lite billboard blend at build. */
|
|
5434
5735
|
blendMode: number;
|
|
5435
5736
|
private _atlas?;
|
|
5436
|
-
constructor(name: string, url: string, capacity: number, cellSize: CellSize, scene: Scene, _epsilon?: number, samplingMode?: number);
|
|
5737
|
+
constructor(name: string, url: string, capacity: number, cellSize: CellSize, scene: Scene, _epsilon?: number, samplingMode?: number);
|
|
5738
|
+
/** Babylon.js `SpriteManager.isReady()` — an empty manager is ready without renderer preparation. */
|
|
5739
|
+
isReady(): boolean;
|
|
5437
5740
|
|
|
5438
5741
|
export declare class SpriteMap {
|
|
5439
5742
|
constructor();
|
|
@@ -5478,7 +5781,9 @@ export declare class SpriteRenderer {
|
|
|
5478
5781
|
private _built;
|
|
5479
5782
|
private readonly _indices;
|
|
5480
5783
|
private _sprites;
|
|
5481
|
-
constructor(engine: WebGPUEngine, capacity?: number, _epsilon?: number, _scene?: unknown);
|
|
5482
5784
|
/**
|
|
5785
|
+
constructor(engine: WebGPUEngine, capacity?: number, _epsilon?: number, _scene?: unknown);
|
|
5786
|
+
/** Babylon.js `SpriteRenderer.isReady()` — the next render can build once its atlas is loaded. */
|
|
5787
|
+
isReady(): boolean;
|
|
5483
5788
|
/**
|
|
5484
5789
|
* Babylon.js `renderer.render(sprites, deltaTime, viewMatrix, projectionMatrix)`.
|
|
5485
5790
|
* The matrices are owned by Babylon Lite's pixel-space sprite pass, so they are
|
|
5486
5791
|
* accepted for API parity but not consumed. First call builds + registers the
|
|
@@ -5610,6 +5915,18 @@ export declare class STLFileLoader {
|
|
|
5610
5915
|
constructor();
|
|
5611
5916
|
}
|
|
5612
5917
|
|
|
5918
|
+
/** Babylon.js-shaped wrapper over Lite's public opaque storage allocation. */
|
|
5919
|
+
export declare class StorageBuffer {
|
|
5920
|
+
private readonly _engine;
|
|
5613
5921
|
private readonly _copyReadable;
|
|
5922
|
+
private readonly _copyWritable;
|
|
5923
|
+
constructor(_engine: WebGPUEngine, size: number, creationFlags?: number, label?: string);
|
|
5614
5924
|
getBuffer(): StorageBuffer_2 | null;
|
|
5925
|
+
clear(byteOffset?: number, byteLength?: number): void;
|
|
5926
|
+
update(data: DataArray, byteOffset?: number, byteLength?: number): void;
|
|
5927
|
+
read(offset?: number, size?: number, buffer?: ArrayBufferView, noDelay?: boolean): Promise<ArrayBufferView>;
|
|
5928
|
+
dispose(): void;
|
|
5615
5929
|
private _requireBuffer;
|
|
5930
|
+
private _assertCopyWritable;
|
|
5931
|
+
}
|
|
5932
|
+
|
|
5616
5933
|
/** Babylon.js `StreamingSound` — a media-element-backed sound. */
|
|
5617
5934
|
export declare class StreamingSound extends AbstractSound {
|
|
5618
5935
|
private readonly _autoplay;
|
|
5619
5936
|
private _loop;
|
|
@@ -5857,6 +6174,83 @@ export declare class TransformNode extends Node_2 {
|
|
|
5857
6174
|
physicsBody: PhysicsBody
|
|
5858
6175
|
|
|
5859
6176
|
export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
|
|
5860
6177
|
|
|
6178
|
+
/** Minimum Babylon.js UniformBuffer surface needed to author compute bindings. */
|
|
6179
|
+
export declare class UniformBuffer {
|
|
6180
|
+
private readonly _engine;
|
|
6181
|
+
private readonly _data;
|
|
6182
|
+
private readonly _dynamic;
|
|
6183
|
+
private readonly _uniformLocations;
|
|
6184
|
+
private readonly _uniformSizes;
|
|
6185
|
+
private readonly _uniformArraySizes;
|
|
6186
|
+
private readonly _uniformNames;
|
|
6187
|
+
private _uniformLocationPointer;
|
|
6188
|
+
private _bufferData;
|
|
6189
|
+
private _buffer;
|
|
6190
|
+
private _needSync;
|
|
6191
|
+
private _name;
|
|
6192
|
+
constructor(_engine: AbstractEngine, data?: number[], dynamic?: boolean, name?: string, forceNoUniformBuffer?: boolean, _trackUBOsInFrame?: boolean);
|
|
6193
|
+
readonly updateMatrix3x3: (name: string, matrix: Float32Array) => void;
|
|
6194
|
+
readonly updateMatrix2x2: (name: string, matrix: Float32Array) => void;
|
|
6195
|
+
readonly updateFloat: (name: string, x: number, _suffix?: string) => void;
|
|
6196
|
+
readonly updateFloat2: (name: string, x: number, y: number, _suffix?: string) => void;
|
|
6197
|
+
readonly updateFloat3: (name: string, x: number, y: number, z: number, _suffix?: string) => void;
|
|
6198
|
+
readonly updateFloat4: (name: string, x: number, y: number, z: number, w: number, _suffix?: string) => void;
|
|
6199
|
+
readonly updateFloatArray: (name: string, array: Float32Array, _suffix?: string) => void;
|
|
6200
|
+
readonly updateArray: (name: string, array: number[]) => void;
|
|
6201
|
+
readonly updateIntArray: (name: string, array: Int32Array) => void;
|
|
6202
|
+
readonly updateUIntArray: (name: string, array: Uint32Array) => void;
|
|
6203
|
+
readonly updateMatrix: (name: string, matrix: MatrixLike) => void;
|
|
6204
|
+
readonly updateMatrices: (name: string, matrices: Float32Array) => void;
|
|
6205
|
+
readonly updateVector3: (name: string, vector: Vector3Like) => void;
|
|
6206
|
+
readonly updateVector4: (name: string, vector: Vector4Like) => void;
|
|
6207
|
+
readonly updateColor3: (name: string, color: Color3Like, suffix?: string) => void;
|
|
6208
|
+
readonly updateColor4: (name: string, color: Color3Like, alpha: number, suffix?: string) => void;
|
|
6209
|
+
readonly updateDirectColor4: (name: string, color: Color4Like, suffix?: string) => void;
|
|
6210
|
+
readonly updateInt: (name: string, x: number, _suffix?: string) => void;
|
|
6211
|
+
readonly updateInt2: (name: string, x: number, y: number, _suffix?: string) => void;
|
|
6212
|
+
readonly updateInt3: (name: string, x: number, y: number, z: number, _suffix?: string) => void;
|
|
6213
|
+
readonly updateInt4: (name: string, x: number, y: number, z: number, w: number, _suffix?: string) => void;
|
|
6214
|
+
readonly updateUInt: (name: string, x: number, _suffix?: string) => void;
|
|
6215
|
+
readonly updateUInt2: (name: string, x: number, y: number, _suffix?: string) => void;
|
|
6216
|
+
readonly updateUInt3: (name: string, x: number, y: number, z: number, _suffix?: string) => void;
|
|
6217
|
+
readonly updateUInt4: (name: string, x: number, y: number, z: number, w: number, _suffix?: string) => void;
|
|
6218
|
+
get useUbo(): boolean;
|
|
6219
|
+
get isSync(): boolean;
|
|
6220
|
+
isDynamic(): boolean;
|
|
6221
|
+
getData(): Float32Array;
|
|
6222
|
+
getBuffer(): UniformBuffer_2 | null;
|
|
6223
|
+
getUniformNames(): string[];
|
|
6224
|
+
addUniform(name: string, sizeOrData: number | number[], arraySize?: number): void;
|
|
6225
|
+
addMatrix(name: string, matrix: MatrixLike): void;
|
|
6226
|
+
addFloat2(name: string, x: number, y: number): void;
|
|
6227
|
+
addFloat3(name: string, x: number, y: number, z: number): void;
|
|
6228
|
+
addColor3(name: string, color: Color3Like): void;
|
|
6229
|
+
addColor4(name: string, color: Color3Like, alpha: number): void;
|
|
6230
|
+
addVector3(name: string, vector: Vector3Like): void;
|
|
6231
|
+
addMatrix3x3(name: string): void;
|
|
6232
|
+
addMatrix2x2(name: string): void;
|
|
6233
|
+
create(): void;
|
|
5861
6234
|
get name(): string;
|
|
6235
|
+
set name(value: string);
|
|
6236
|
+
get currentEffect(): unknown | null;
|
|
6237
|
+
update(): void;
|
|
6238
|
+
updateUniform(uniformName: string, data: FloatArray, size: number): void;
|
|
6239
|
+
updateUniformArray(uniformName: string, data: FloatArray, size: number): void;
|
|
6240
|
+
setTexture(_name: string, _texture: BaseTexture | null): never;
|
|
6241
|
+
setTextureArray(_name: string, _textures: BaseTexture[]): never;
|
|
6242
|
+
bindTexture(_name: string, _texture: unknown | null): never;
|
|
6243
|
+
updateUniformDirectly(uniformName: string, data: FloatArray): void;
|
|
6244
|
+
bindToEffect(_effect: unknown, _name: string): never;
|
|
6245
|
+
bindUniformBuffer(): never;
|
|
6246
|
+
unbindEffect(): void;
|
|
6247
|
+
setDataBuffer(dataBuffer: UniformBuffer_2): boolean;
|
|
6248
|
+
has(name: string): boolean;
|
|
6249
|
+
dispose(): void;
|
|
6250
|
+
private _align;
|
|
6251
|
+
private _updateIntegerUniform;
|
|
6252
|
+
private _updateIntegerUniformArray;
|
|
6253
|
+
private _setInteger;
|
|
6254
|
+
}
|
|
6255
|
+
|
|
5862
6256
|
/** Babylon.js `UninstallHtmlInCanvasPolyfill` — the HTML-in-canvas polyfill is unsupported by the compat layer. */
|
|
5863
6257
|
export declare function UninstallHtmlInCanvasPolyfill(): never;
|
|
5864
6258
|
|
|
@@ -5884,7 +6278,34 @@ export declare function UploadImageToTexture2DArrayLayer(texture: RawTexture2DAr
|
|
|
5884
6278
|
export declare type USDBinaryInput = ArrayBuffer | ArrayBufferView;
|
|
5885
6279
|
|
|
5886
6280
|
export declare class USDFileLoader {
|
|
5887
|
-
|
|
6281
|
+
static get DefaultConfiguration(): Required<Pick<USDFileLoaderOptions, "workerUrl" | "glueUrl" | "wasmUrl" | "dataUrl">>;
|
|
6282
|
+
static set DefaultConfiguration(configuration: Required<Pick<USDFileLoaderOptions, "workerUrl" | "glueUrl" | "wasmUrl" | "dataUrl">>);
|
|
6283
|
+
readonly name = "usd";
|
|
6284
|
+
readonly extensions: {
|
|
6285
|
+
readonly ".usd": {
|
|
6286
|
+
readonly isBinary: true;
|
|
6287
|
+
};
|
|
6288
|
+
readonly ".usda": {
|
|
6289
|
+
readonly isBinary: true;
|
|
6290
|
+
};
|
|
6291
|
+
readonly ".usdc": {
|
|
6292
|
+
readonly isBinary: true;
|
|
6293
|
+
};
|
|
6294
|
+
readonly ".usdz": {
|
|
6295
|
+
readonly isBinary: true;
|
|
6296
|
+
};
|
|
6297
|
+
};
|
|
6298
|
+
private readonly _options;
|
|
6299
|
+
private readonly _activeLoads;
|
|
6300
|
+
constructor(options?: Partial<USDFileLoaderOptions>);
|
|
6301
|
+
createPlugin(options: {
|
|
6302
|
+
usd?: Partial<USDFileLoaderOptions>;
|
|
6303
|
+
}): USDFileLoader;
|
|
6304
|
+
importMeshAsync(_meshNames: string | readonly string[] | null | undefined, scene: Scene, data: unknown, _rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<USDImportResult>;
|
|
6305
|
+
loadAsync(scene: Scene, data: unknown, _rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<void>;
|
|
6306
|
+
loadAssetContainerAsync(scene: Scene, data: unknown, _rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<AssetContainer>;
|
|
6307
|
+
dispose(): void;
|
|
6308
|
+
private _load;
|
|
5888
6309
|
}
|
|
5889
6310
|
|
|
5890
6311
|
export declare interface USDFileLoaderOptions {
|
|
@@ -5900,38 +6321,24 @@ export declare interface USDFileLoaderOptions {
|
|
|
5900
6321
|
onComplete?: (diagnostics: USDImportDiagnostics) => void;
|
|
5901
6322
|
}
|
|
5902
6323
|
|
|
5903
|
-
export declare
|
|
5904
|
-
timings: USDImportTimings;
|
|
5905
|
-
statistics: USDImportStatistics;
|
|
5906
|
-
missingAssets: readonly string[];
|
|
5907
|
-
}
|
|
6324
|
+
export declare type USDImportDiagnostics = UsdDiagnostics;
|
|
5908
6325
|
|
|
5909
|
-
|
|
5910
|
-
|
|
5911
|
-
|
|
5912
|
-
|
|
5913
|
-
|
|
5914
|
-
|
|
5915
|
-
|
|
5916
|
-
triangles: number;
|
|
5917
|
-
commandBytes: number;
|
|
5918
|
-
dataBytes: number;
|
|
6326
|
+
declare interface USDImportResult {
|
|
6327
|
+
meshes: Mesh[];
|
|
6328
|
+
particleSystems: unknown[];
|
|
6329
|
+
skeletons: Skeleton[];
|
|
6330
|
+
animationGroups: AnimationGroup_2[];
|
|
6331
|
+
transformNodes: unknown[];
|
|
6332
|
+
lights: unknown[];
|
|
5919
6333
|
}
|
|
5920
6334
|
|
|
5921
|
-
export declare
|
|
5922
|
-
totalMs: number;
|
|
5923
|
-
stageOpenMs: number;
|
|
5924
|
-
stageReadMs: number;
|
|
5925
|
-
preparationMs: number;
|
|
5926
|
-
packingMs: number;
|
|
5927
|
-
heapCopyMs: number;
|
|
5928
|
-
materializeMs: number;
|
|
5929
|
-
}
|
|
6335
|
+
export declare type USDImportStatistics = UsdDiagnostics["statistics"];
|
|
5930
6336
|
|
|
5931
|
-
export declare
|
|
5932
|
-
|
|
5933
|
-
|
|
5934
|
-
|
|
6337
|
+
export declare type USDImportTimings = UsdDiagnostics["timings"];
|
|
6338
|
+
|
|
6339
|
+
export declare type USDLoadProgress = Omit<UsdProgress, "phase"> & {
|
|
6340
|
+
phase: Exclude<UsdProgress["phase"], "fetching">;
|
|
6341
|
+
};
|
|
5935
6342
|
|
|
5936
6343
|
export declare type USDVirtualFiles = Readonly<Record<string, USDBinaryInput>>;
|
|
5937
6344
|
|
|
@@ -6065,6 +6472,12 @@ export declare class Vector3 {
|
|
|
6065
6472
|
static TransformNormalToRef<T extends Vector3>(vector: Vector3, transformation: Matrix, result: T): T;
|
|
6066
6473
|
}
|
|
6067
6474
|
|
|
6475
|
+
declare interface Vector3Like {
|
|
6476
|
+
readonly x: number;
|
|
6477
|
+
readonly y: number;
|
|
6478
|
+
readonly z: number;
|
|
6479
|
+
}
|
|
6480
|
+
|
|
6068
6481
|
export declare class Vector4 {
|
|
6069
6482
|
x: number;
|
|
6070
6483
|
y: number;
|
|
@@ -6082,6 +6495,10 @@ export declare class Vector4 {
|
|
|
6082
6495
|
static Zero(): Vector4;
|
|
6083
6496
|
}
|
|
6084
6497
|
|
|
6498
|
+
declare interface Vector4Like extends Vector3Like {
|
|
6499
|
+
readonly w: number;
|
|
6500
|
+
}
|
|
6501
|
+
|
|
6085
6502
|
/**
|
|
6086
6503
|
* Babylon.js `VertexBuffer` — the per-attribute geometry buffer. Only the `kind`
|
|
6087
6504
|
* string constants are surfaced (used with `mesh.getVerticesData` /
|