@babylonjs/lite-compat 1.30.0-preview → 1.31.1-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 +33 -31
- package/index.d.ts +758 -36
- package/index.js +1908 -155
- package/index.js.map +1 -1
- package/{meshes-DJ46g22_.js → meshes-Fu955h5M.js} +155 -24
- package/meshes-Fu955h5M.js.map +1 -0
- package/navigation.d.ts +199 -18
- package/navigation.js +3 -10
- package/navigation.js.map +1 -1
- package/package.json +4 -4
- package/meshes-DJ46g22_.js.map +0 -1
package/index.d.ts
CHANGED
|
@@ -3,11 +3,14 @@ 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';
|
|
9
10
|
import { LineMaterial } from '@babylonjs/lite';
|
|
11
|
+
import { MaxTintMagnitude } from '@babylonjs/lite';
|
|
10
12
|
import { Mesh as Mesh_2 } from '@babylonjs/lite';
|
|
13
|
+
import { MinTemperatureKelvin } from '@babylonjs/lite';
|
|
11
14
|
import { PhysicsMassProperties } from '@babylonjs/lite';
|
|
12
15
|
import { PhysicsShape as PhysicsShape_2 } from '@babylonjs/lite';
|
|
13
16
|
import { PhysicsShapeParameters } from '@babylonjs/lite';
|
|
@@ -15,8 +18,10 @@ import { PhysicsWorld } from '@babylonjs/lite';
|
|
|
15
18
|
import { RenderCanvas } from '@babylonjs/lite';
|
|
16
19
|
import { SceneNode } from '@babylonjs/lite';
|
|
17
20
|
import { SheenProps } from '@babylonjs/lite';
|
|
21
|
+
import { StorageBuffer as StorageBuffer_2 } from '@babylonjs/lite';
|
|
18
22
|
import { Texture2D } from '@babylonjs/lite';
|
|
19
23
|
import { Texture2DArray } from '@babylonjs/lite';
|
|
24
|
+
import { UniformBuffer as UniformBuffer_2 } from '@babylonjs/lite';
|
|
20
25
|
|
|
21
26
|
/** Base class for an asset-loading task. Subclasses implement {@link runAsync}. */
|
|
22
27
|
export declare abstract class AbstractAssetTask {
|
|
@@ -215,6 +220,11 @@ export declare abstract class AbstractEngine {
|
|
|
215
220
|
* scoped API cannot reproduce the engine-wide state without a pipeline-owner lifecycle policy.
|
|
216
221
|
*/
|
|
217
222
|
setAlphaToCoverage(_enable: boolean): never;
|
|
223
|
+
/**
|
|
224
|
+
* Babylon.js `engine.isOcclusionQueryVisible(query)` — Lite does not expose
|
|
225
|
+
* occlusion-query allocation, render-pass encoding, or asynchronous result state.
|
|
226
|
+
*/
|
|
227
|
+
isOcclusionQueryVisible(_query: unknown): never;
|
|
218
228
|
/**
|
|
219
229
|
* Babylon.js `engine.updateTextureArrayLayerFromImageSource(texture, source, layer, invertY, premultiplyAlpha)`
|
|
220
230
|
* — the engine extension that uploads a decoded image source into one layer of a 2D array
|
|
@@ -236,6 +246,7 @@ export declare abstract class AbstractEngine {
|
|
|
236
246
|
* visibility, and shadow-receipt. Concrete meshes derive from this.
|
|
237
247
|
*/
|
|
238
248
|
export declare class AbstractMesh extends TransformNode {
|
|
239
249
|
private _material;
|
|
250
|
+
private _meshBlendingTag;
|
|
240
251
|
protected _visible: boolean;
|
|
241
252
|
constructor(name: string, lite: Mesh_2, scene?: Scene);
|
|
242
253
|
getClassName(): string;
|
|
243
254
|
get material(): CompatMaterial | null;
|
|
@@ -246,6 +257,8 @@ export declare class AbstractMesh extends TransformNode {
|
|
|
246
257
|
private _material;
|
|
247
258
|
set isPickable(value: boolean);
|
|
248
259
|
get receiveShadows(): boolean;
|
|
249
260
|
set receiveShadows(value: boolean);
|
|
261
|
+
get meshBlendingTag(): number;
|
|
262
|
+
set meshBlendingTag(value: number);
|
|
250
263
|
protected _onEffectiveEnabledStateChanged(enabled: boolean): void;
|
|
251
264
|
/**
|
|
252
265
|
* Babylon.js `mesh.getBoundingInfo()` — the mesh's AABB. `minimum`/`maximum`
|
|
253
266
|
* are the local-space bounds; the returned `BoundingInfo`'s world members
|
|
@@ -605,9 +618,8 @@ export declare class Angle {
|
|
|
605
618
|
}
|
|
606
619
|
|
|
607
620
|
/**
|
|
608
|
-
* Babylon.js `Animatable`
|
|
609
|
-
*
|
|
610
|
-
* the target's (dotted) property path.
|
|
621
|
+
* Babylon.js `Animatable` facade. Supported direct-animation tracks delegate to a
|
|
622
|
+
* native Lite property group; unsupported tracks retain the compat CPU evaluator.
|
|
611
623
|
*/
|
|
612
624
|
declare class Animatable_2 {
|
|
613
625
|
private readonly _target;
|
|
@@ -615,16 +627,26 @@ declare class Animatable_2 {
|
|
|
615
627
|
private readonly _from;
|
|
616
628
|
private readonly _to;
|
|
617
629
|
private readonly _loop;
|
|
618
|
-
masterFrame: number;
|
|
619
|
-
speedRatio: number;
|
|
630
|
+
masterFrame: number;
|
|
620
631
|
private _speedRatio;
|
|
621
632
|
private _paused;
|
|
622
633
|
private _stopped;
|
|
623
|
-
constructor(_target: unknown, _animations: Animation_2[], _from: number, _to: number, _loop: boolean, speedRatio: number);
|
|
624
634
|
goToFrame(frame: number): void;
|
|
635
|
+
private readonly _nativeManager;
|
|
636
|
+
private readonly _fallbackAnimations;
|
|
637
|
+
private readonly _fallbackFrames;
|
|
638
|
+
private readonly _fallbackElapsedFrames;
|
|
639
|
+
private readonly _fallbackRepeatCounts;
|
|
640
|
+
private readonly _completedFallbackAnimations;
|
|
641
|
+
constructor(target: unknown, animations: Animation_2[], from: number, to: number, loop: boolean, speedRatio: number);
|
|
625
642
|
get speedRatio(): number;
|
|
643
|
+
set speedRatio(value: number);
|
|
626
644
|
goToFrame(frame: number): void;
|
|
627
645
|
pause(): void;
|
|
628
646
|
restart(): void;
|
|
629
647
|
stop(): void;
|
|
630
648
|
get animationStarted(): boolean;
|
|
631
|
-
private
|
|
649
|
+
private _applyFallback;
|
|
650
|
+
private _advanceFallback;
|
|
651
|
+
private _resetFallbackAnimation;
|
|
652
|
+
private _attachLite;
|
|
653
|
+
private _detachLite;
|
|
632
654
|
}
|
|
633
655
|
export { Animatable_2 as Animatable }
|
|
634
656
|
|
|
@@ -639,16 +661,29 @@ declare class Animation_2 {
|
|
|
639
661
|
static readonly ANIMATIONTYPE_QUATERNION: 2;
|
|
640
662
|
static readonly ANIMATIONTYPE_MATRIX: 3;
|
|
641
663
|
static readonly ANIMATIONTYPE_COLOR3: 4;
|
|
664
|
+
static readonly ANIMATIONTYPE_VECTOR2: 5;
|
|
665
|
+
static readonly ANIMATIONTYPE_COLOR4: 6;
|
|
642
666
|
static readonly ANIMATIONLOOPMODE_RELATIVE: 0;
|
|
643
667
|
static readonly ANIMATIONLOOPMODE_CYCLE: 1;
|
|
644
668
|
static readonly ANIMATIONLOOPMODE_CONSTANT: 2;
|
|
645
669
|
private _keys;
|
|
670
|
+
private _easingFunction;
|
|
646
671
|
constructor(name: string, targetProperty: string, framePerSecond: number, dataType?: number, loopMode?: number);
|
|
647
672
|
setKeys(keys: IAnimationKey[]): void;
|
|
648
673
|
getKeys(): IAnimationKey[];
|
|
649
674
|
getHighestFrame(): number;
|
|
650
|
-
/**
|
|
651
|
-
|
|
675
|
+
/**
|
|
676
|
+
* Assigns the easing function used to transform each non-STEP segment's normalized progress.
|
|
677
|
+
* @param easingFunction - A Babylon.js-shaped easing object, or `null` to restore linear progress.
|
|
678
|
+
*/
|
|
679
|
+
setEasingFunction(easingFunction: IEasingFunction | null): void;
|
|
680
|
+
/**
|
|
681
|
+
* Gets the easing function currently assigned to this animation.
|
|
682
|
+
* @returns The assigned easing object, or `null` when interpolation uses linear progress.
|
|
683
|
+
*/
|
|
684
|
+
getEasingFunction(): IEasingFunction | null;
|
|
685
|
+
/** Evaluate the animated value at `frame`, clamped to the key range. */
|
|
686
|
+
evaluate(frame: number): AnimationValue;
|
|
652
687
|
/** Babylon.js helper: build a one-shot float animation between two values. */
|
|
653
688
|
static CreateAndStartAnimation(name: string, _target: unknown, targetProperty: string, framePerSecond: number, totalFrame: number, from: number, to: number): Animation_2;
|
|
654
689
|
}
|
|
@@ -757,6 +792,8 @@ export declare const AnimationTypes: {
|
|
|
757
792
|
readonly ANIMATIONTYPE_COLOR4: 6;
|
|
758
793
|
};
|
|
759
794
|
|
|
795
|
+
export declare type AnimationValue = number | number[] | IAnimationVectorValue;
|
|
796
|
+
|
|
760
797
|
export declare interface AppendOptions extends ISceneLoaderOptions {
|
|
761
798
|
}
|
|
762
799
|
|
|
@@ -979,7 +1016,7 @@ export declare class AxisScaleGizmo extends GizmoBase {
|
|
|
979
1016
|
private _attached;
|
|
980
1017
|
}
|
|
981
1018
|
|
|
982
1019
|
export declare class BackEase extends EasingFunction {
|
|
983
|
-
|
|
1020
|
+
amplitude: number;
|
|
984
1021
|
constructor(amplitude?: number);
|
|
985
1022
|
easeInCore(gradient: number): number;
|
|
986
1023
|
}
|
|
@@ -1015,6 +1052,18 @@ export declare interface Behavior<T> {
|
|
|
1015
1052
|
detach(): void;
|
|
1016
1053
|
}
|
|
1017
1054
|
|
|
1055
|
+
/**
|
|
1056
|
+
* Babylon.js-compatible cubic Bezier easing class.
|
|
1057
|
+
*/
|
|
1058
|
+
export declare class BezierCurveEase extends EasingFunction {
|
|
1059
|
+
x1: number;
|
|
1060
|
+
y1: number;
|
|
1061
|
+
x2: number;
|
|
1062
|
+
y2: number;
|
|
1063
|
+
constructor(x1?: number, y1?: number, x2?: number, y2?: number);
|
|
1064
|
+
easeInCore(gradient: number): number;
|
|
1065
|
+
}
|
|
1066
|
+
|
|
1018
1067
|
export declare const BlackAndWhitePostProcess: new () => never;
|
|
1019
1068
|
|
|
1020
1069
|
export declare const BloomEffect: new () => never;
|
|
@@ -1034,8 +1083,8 @@ export declare class Bone {
|
|
|
1034
1083
|
}
|
|
1035
1084
|
|
|
1036
1085
|
export declare class BounceEase extends EasingFunction {
|
|
1037
|
-
|
|
1038
|
-
|
|
1086
|
+
bounces: number;
|
|
1087
|
+
bounciness: number;
|
|
1039
1088
|
constructor(bounces?: number, bounciness?: number);
|
|
1040
1089
|
easeInCore(gradient: number): number;
|
|
1041
1090
|
}
|
|
@@ -1344,6 +1393,12 @@ export declare class Color3 {
|
|
|
1344
1393
|
static Lerp(start: Color3, end: Color3, amount: number): Color3;
|
|
1345
1394
|
}
|
|
1346
1395
|
|
|
1396
|
+
declare interface Color3Like {
|
|
1397
|
+
readonly r: number;
|
|
1398
|
+
readonly g: number;
|
|
1399
|
+
readonly b: number;
|
|
1400
|
+
}
|
|
1401
|
+
|
|
1347
1402
|
export declare class Color4 {
|
|
1348
1403
|
r: number;
|
|
1349
1404
|
g: number;
|
|
@@ -1361,6 +1416,10 @@ export declare class Color4 {
|
|
|
1361
1416
|
static FromInts(r: number, g: number, b: number, a: number): Color4;
|
|
1362
1417
|
}
|
|
1363
1418
|
|
|
1419
|
+
declare interface Color4Like extends Color3Like {
|
|
1420
|
+
readonly a: number;
|
|
1421
|
+
}
|
|
1422
|
+
|
|
1364
1423
|
/** An RGBA color bound to a [0, 1] position (Babylon.js `ColorGradient`). */
|
|
1365
1424
|
export declare class ColorGradient {
|
|
1366
1425
|
gradient: number;
|
|
@@ -1377,9 +1436,66 @@ export declare function CompleteGreasedLineColorTable(..._args: unknown[]): neve
|
|
|
1377
1436
|
|
|
1378
1437
|
export declare function CompleteGreasedLineWidthTable(..._args: unknown[]): never;
|
|
1379
1438
|
|
|
1439
|
+
export declare interface ComputeBindingLocation {
|
|
1440
|
+
group: number;
|
|
1441
|
+
binding: number;
|
|
1442
|
+
}
|
|
1443
|
+
|
|
1444
|
+
export declare type ComputeBindingMapping = Record<string, ComputeBindingLocation>;
|
|
1445
|
+
|
|
1446
|
+
declare type ComputeEffect = ComputeShader_2;
|
|
1447
|
+
|
|
1380
1448
|
/** Babylon.js `ComputeOverlayCssTransform` — HTML overlay interaction is unsupported by the compat layer. */
|
|
1381
1449
|
export declare function ComputeOverlayCssTransform(): never;
|
|
1382
1450
|
|
|
1451
|
+
/** Babylon.js ComputeShader adapted to Lite's public buffer-backed compute graph. */
|
|
1452
|
+
export declare class ComputeShader {
|
|
1453
|
+
private readonly _engine;
|
|
1454
|
+
private readonly _shaderPath;
|
|
1455
|
+
static readonly Parse: typeof ComputeShaderParse;
|
|
1456
|
+
readonly uniqueId: number;
|
|
1457
|
+
name: string;
|
|
1458
|
+
fastMode: boolean;
|
|
1459
|
+
onCompiled: ((effect: ComputeEffect) => void) | null;
|
|
1460
|
+
onError: ((effect: ComputeEffect, errors: string) => void) | null;
|
|
1461
|
+
readonly gpuTimeInFrame: undefined;
|
|
1462
|
+
triggerContextRebuild: boolean;
|
|
1463
|
+
private readonly _source;
|
|
1464
|
+
private readonly _bindings;
|
|
1465
|
+
private _shader;
|
|
1466
|
+
private _bindingSet;
|
|
1467
|
+
private _bindingsDirty;
|
|
1468
|
+
private _shaderDirty;
|
|
1469
|
+
private _compiled;
|
|
1470
|
+
constructor(name: string, _engine: AbstractEngine, _shaderPath: IComputeShaderPath | string, options?: Partial<IComputeShaderOptions>);
|
|
1471
|
+
private readonly _options;
|
|
1472
|
+
get options(): IComputeShaderOptions;
|
|
1473
|
+
get shaderPath(): string | IComputeShaderPath;
|
|
1474
|
+
getClassName(): string;
|
|
1475
|
+
setTexture(_name: string, _texture: BaseTexture, _bindSampler?: boolean): never;
|
|
1476
|
+
setInternalTexture(_name: string, _texture: unknown): never;
|
|
1477
|
+
setStorageTexture(_name: string, _texture: BaseTexture): never;
|
|
1478
|
+
setExternalTexture(_name: string, _texture: unknown): never;
|
|
1479
|
+
setVideoTexture(_name: string, _texture: unknown): false;
|
|
1480
|
+
setUniformBuffer(name: string, buffer: UniformBuffer | UniformBuffer_2): void;
|
|
1481
|
+
setStorageBuffer(name: string, buffer: StorageBuffer | StorageBuffer_2): void;
|
|
1482
|
+
setTextureSampler(_name: string, _sampler: unknown): never;
|
|
1483
|
+
isReady(): boolean;
|
|
1484
|
+
dispatch(x: number, y?: number, z?: number): boolean;
|
|
1485
|
+
dispatchIndirect(buffer: StorageBuffer | StorageBuffer_2, offset?: number): boolean;
|
|
1486
|
+
dispatchWhenReady(x: number, y?: number, z?: number, delay?: number): Promise<void>;
|
|
1487
|
+
serialize(): Record<string, unknown>;
|
|
1488
|
+
private _createGraph;
|
|
1489
|
+
private _createShader;
|
|
1490
|
+
private _createBindingSet;
|
|
1491
|
+
private _submit;
|
|
1492
|
+
private _invalidateBindings;
|
|
1493
|
+
}
|
|
1494
|
+
|
|
1495
|
+
export declare function ComputeShaderParse(source: Record<string, unknown>, scene: {
|
|
1496
|
+
getEngine(): AbstractEngine;
|
|
1497
|
+
}, _rootUrl: string): ComputeShader;
|
|
1498
|
+
|
|
1383
1499
|
/** Base class for action conditions. */
|
|
1384
1500
|
export declare abstract class Condition {
|
|
1385
1501
|
abstract isValid(): boolean;
|
|
@@ -1412,6 +1528,14 @@ export declare const Constants: {
|
|
|
1412
1528
|
readonly TEXTURE_TRILINEAR_SAMPLINGMODE: 3;
|
|
1413
1529
|
readonly TEXTUREFORMAT_RGBA: 5;
|
|
1414
1530
|
readonly TEXTURETYPE_UNSIGNED_BYTE: 0;
|
|
1531
|
+
readonly BUFFER_CREATIONFLAG_READ: 1;
|
|
1532
|
+
readonly BUFFER_CREATIONFLAG_WRITE: 2;
|
|
1533
|
+
readonly BUFFER_CREATIONFLAG_READWRITE: 3;
|
|
1534
|
+
readonly BUFFER_CREATIONFLAG_UNIFORM: 4;
|
|
1535
|
+
readonly BUFFER_CREATIONFLAG_VERTEX: 8;
|
|
1536
|
+
readonly BUFFER_CREATIONFLAG_INDEX: 16;
|
|
1537
|
+
readonly BUFFER_CREATIONFLAG_STORAGE: 32;
|
|
1538
|
+
readonly BUFFER_CREATIONFLAG_INDIRECT: 64;
|
|
1415
1539
|
};
|
|
1416
1540
|
|
|
1417
1541
|
/** Babylon.js `CreateAudioBusAsync`. */
|
|
@@ -1429,6 +1553,8 @@ export declare function CreateCylinder(name: string, options: CylinderOptions, s
|
|
|
1429
1553
|
/** Babylon.js `CreateDashedLines(name, options, scene)` (linesBuilder). */
|
|
1430
1554
|
export declare function CreateDashedLines(name: string, options: DashedLinesBuilderOptions, scene?: Scene | null): LinesMesh;
|
|
1431
1555
|
|
|
1556
|
+
export declare function CreateDefaultMeshBlendRadiusDefinitions(): MeshBlendRadiusDefinitions;
|
|
1557
|
+
|
|
1432
1558
|
/** Babylon.js `CreateDisc(name, options, scene)` (discBuilder). */
|
|
1433
1559
|
export declare function CreateDisc(name: string, options: object, scene: Scene): Mesh;
|
|
1434
1560
|
|
|
@@ -1627,6 +1753,8 @@ declare interface DashedLinesBuilderOptions {
|
|
|
1627
1753
|
material?: unknown;
|
|
1628
1754
|
}
|
|
1629
1755
|
|
|
1756
|
+
export declare type DataArray = number[] | ArrayBufferLike | ArrayBufferView;
|
|
1757
|
+
|
|
1630
1758
|
declare interface DefaultEnvironmentOptions {
|
|
1631
1759
|
createSkybox?: boolean;
|
|
1632
1760
|
createGround?: boolean;
|
|
@@ -1671,6 +1799,29 @@ export declare class DistanceConstraint extends PhysicsConstraint {
|
|
|
1671
1799
|
constructor(maxDistance: number, scene: Scene);
|
|
1672
1800
|
}
|
|
1673
1801
|
|
|
1802
|
+
export declare class DitheredTileFadeMaterialPlugin extends MaterialPluginBase {
|
|
1803
|
+
static readonly Name = "DitheredTileFade";
|
|
1674
1804
|
constructor(material: DitheredTileFadeSupportedMaterial);
|
|
1805
|
+
static GetOrCreate(_material: DitheredTileFadeSupportedMaterial): DitheredTileFadeMaterialPlugin;
|
|
1806
|
+
get isEnabled(): boolean;
|
|
1807
|
+
set isEnabled(_value: boolean);
|
|
1808
|
+
setFadeBounds(_mesh: DitheredTileFadeMesh, _lowerBound: number, _upperBound: number): void;
|
|
1809
|
+
setFadeLowerBound(_mesh: DitheredTileFadeMesh, _lowerBound: number): void;
|
|
1810
|
+
setFadeUpperBound(_mesh: DitheredTileFadeMesh, _upperBound: number): void;
|
|
1811
|
+
getFadeBoundsToRef(_mesh: DitheredTileFadeMesh, _result: IDitheredTileFadeBounds): boolean;
|
|
1812
|
+
resetFade(_mesh: DitheredTileFadeMesh): void;
|
|
1813
|
+
setThinInstanceFadeBounds(_mesh: Mesh, _index: number, _lowerBound: number, _upperBound: number, _refresh?: boolean): void;
|
|
1814
|
+
setThinInstanceFadeBoundsBuffer(_mesh: Mesh, _bounds: Float32Array): void;
|
|
1815
|
+
commitThinInstanceFadeBounds(_mesh: Mesh): void;
|
|
1816
|
+
resetThinInstanceFade(_mesh: Mesh, _index: number, _refresh?: boolean): void;
|
|
1817
|
+
reset(): void;
|
|
1818
|
+
copyToMaterial(_material: DitheredTileFadeSupportedMaterial): DitheredTileFadeMaterialPlugin;
|
|
1819
|
+
getClassName(): string;
|
|
1820
|
+
}
|
|
1821
|
+
|
|
1822
|
+
export declare type DitheredTileFadeMesh = Mesh | InstancedMesh;
|
|
1823
|
+
|
|
1824
|
+
export declare type DitheredTileFadeSupportedMaterial = StandardMaterial | PBRMaterial;
|
|
1825
|
+
|
|
1675
1826
|
/** Babylon.js drag move payload. */
|
|
1676
1827
|
declare type DragEvent_2 = {
|
|
1677
1828
|
delta: Vector3;
|
|
@@ -1719,7 +1870,7 @@ export declare class DynamicTexture extends BaseTexture {
|
|
|
1719
1870
|
whenReadyAsync(): Promise<void>;
|
|
1720
1871
|
}
|
|
1721
1872
|
|
|
1722
|
-
export declare abstract class EasingFunction {
|
|
1873
|
+
export declare abstract class EasingFunction implements IEasingFunction {
|
|
1723
1874
|
static readonly EASINGMODE_EASEIN = 0;
|
|
1724
1875
|
static readonly EASINGMODE_EASEOUT = 1;
|
|
1725
1876
|
static readonly EASINGMODE_EASEINOUT = 2;
|
|
@@ -1732,10 +1883,10 @@ export declare abstract class EasingFunction {
|
|
|
1732
1883
|
}
|
|
1733
1884
|
|
|
1734
1885
|
/**
|
|
1735
|
-
* Babylon.js-compatible easing functions
|
|
1886
|
+
* Babylon.js-compatible easing functions over Babylon Lite's functional curves.
|
|
1736
1887
|
*
|
|
1737
|
-
* These
|
|
1738
|
-
*
|
|
1888
|
+
* These retain Babylon.js's class hierarchy and easing modes for porting while
|
|
1889
|
+
* delegating curve math to tree-shakable native Lite functions.
|
|
1739
1890
|
*/
|
|
1740
1891
|
export declare const EASINGMODE_EASEIN = 0;
|
|
1741
1892
|
|
|
@@ -1752,8 +1903,8 @@ export declare class EffectLayer {
|
|
|
1752
1903
|
}
|
|
1753
1904
|
|
|
1754
1905
|
export declare class ElasticEase extends EasingFunction {
|
|
1755
|
-
|
|
1756
|
-
|
|
1906
|
+
oscillations: number;
|
|
1907
|
+
springiness: number;
|
|
1757
1908
|
constructor(oscillations?: number, springiness?: number);
|
|
1758
1909
|
easeInCore(gradient: number): number;
|
|
1759
1910
|
}
|
|
@@ -1778,7 +1929,7 @@ export declare class ExecuteCodeAction extends Action {
|
|
|
1778
1929
|
}
|
|
1779
1930
|
|
|
1780
1931
|
export declare class ExponentialEase extends EasingFunction {
|
|
1781
|
-
|
|
1932
|
+
exponent: number;
|
|
1782
1933
|
constructor(exponent?: number);
|
|
1783
1934
|
easeInCore(gradient: number): number;
|
|
1784
1935
|
}
|
|
@@ -1796,8 +1947,128 @@ export declare class FadeInOutBehavior {
|
|
|
1796
1947
|
constructor();
|
|
1797
1948
|
}
|
|
1798
1949
|
|
|
1950
|
+
export declare class FBXConstraintBehavior {
|
|
1951
|
+
readonly constraint: FBXConstraintData;
|
|
1952
|
+
readonly name: string;
|
|
1953
|
+
attachedNode: TransformNode | null;
|
|
1954
|
+
enabled: boolean;
|
|
1955
|
+
constructor(constraint: FBXConstraintData, _options: FBXConstraintBehaviorOptions);
|
|
1956
|
+
init(): void;
|
|
1957
|
+
attach(_target: TransformNode): void;
|
|
1958
|
+
detach(): void;
|
|
1959
|
+
captureBase(): void;
|
|
1960
|
+
restoreBase(): void;
|
|
1961
|
+
dependencyNodes(): Array<Node_2 | null>;
|
|
1962
|
+
evaluate(): void;
|
|
1963
|
+
}
|
|
1964
|
+
|
|
1965
|
+
export declare interface FBXConstraintBehaviorOptions {
|
|
1966
|
+
root: TransformNode;
|
|
1967
|
+
targets: FBXConstraintBehaviorTarget[];
|
|
1968
|
+
upNode: TransformNode | null;
|
|
1969
|
+
sceneUp: Vector3;
|
|
1970
|
+
}
|
|
1971
|
+
|
|
1972
|
+
export declare interface FBXConstraintBehaviorTarget {
|
|
1973
|
+
node: TransformNode;
|
|
1974
|
+
weight: number;
|
|
1975
|
+
offset: Matrix;
|
|
1976
|
+
}
|
|
1977
|
+
|
|
1978
|
+
declare type FBXConstraintBoolean3 = [boolean, boolean, boolean];
|
|
1979
|
+
|
|
1980
|
+
export declare interface FBXConstraintData {
|
|
1981
|
+
id: number;
|
|
1982
|
+
name: string;
|
|
1983
|
+
type: FBXConstraintType;
|
|
1984
|
+
typeName: string;
|
|
1985
|
+
nodeId?: number;
|
|
1986
|
+
targets: FBXConstraintTarget[];
|
|
1987
|
+
weight: number;
|
|
1988
|
+
active: boolean;
|
|
1989
|
+
affectTranslation: FBXConstraintBoolean3;
|
|
1990
|
+
affectRotation: FBXConstraintBoolean3;
|
|
1991
|
+
affectScale: FBXConstraintBoolean3;
|
|
1992
|
+
offsetTranslation: FBXConstraintVector3;
|
|
1993
|
+
offsetRotation: FBXConstraintVector3;
|
|
1994
|
+
offsetScale: FBXConstraintVector3;
|
|
1995
|
+
aimVector: FBXConstraintVector3;
|
|
1996
|
+
upVector: FBXConstraintVector3;
|
|
1997
|
+
worldUpVector: FBXConstraintVector3;
|
|
1998
|
+
worldUpType: number;
|
|
1999
|
+
worldUpNodeId?: number;
|
|
2000
|
+
ikFirstJointId?: number;
|
|
2001
|
+
ikEndJointId?: number;
|
|
2002
|
+
ikEffectorId?: number;
|
|
2003
|
+
ikPoleVector: FBXConstraintVector3;
|
|
2004
|
+
}
|
|
2005
|
+
|
|
2006
|
+
export declare class FBXConstraintSolver {
|
|
2007
|
+
private constructor();
|
|
2008
|
+
static Get(_scene: Scene): FBXConstraintSolver | undefined;
|
|
2009
|
+
static GetOrCreate(_scene: Scene): FBXConstraintSolver;
|
|
2010
|
+
get constraints(): readonly FBXConstraintBehavior[];
|
|
2011
|
+
get cyclicConstraints(): readonly FBXConstraintBehavior[];
|
|
2012
|
+
register(_behavior: FBXConstraintBehavior): void;
|
|
2013
|
+
unregister(_behavior: FBXConstraintBehavior): void;
|
|
2014
|
+
invalidateOrder(): void;
|
|
2015
|
+
beginFrame(): void;
|
|
2016
|
+
solve(): void;
|
|
2017
|
+
}
|
|
2018
|
+
|
|
2019
|
+
export declare interface FBXConstraintTarget {
|
|
2020
|
+
modelId: number;
|
|
2021
|
+
weight: number;
|
|
2022
|
+
offsetTranslation: FBXConstraintVector3;
|
|
2023
|
+
offsetRotation: FBXConstraintVector3;
|
|
2024
|
+
offsetScale: FBXConstraintVector3;
|
|
2025
|
+
}
|
|
2026
|
+
|
|
2027
|
+
export declare type FBXConstraintType = "aim" | "parent" | "position" | "rotation" | "scale" | "singleChainIK" | "unknown";
|
|
2028
|
+
|
|
2029
|
+
declare type FBXConstraintVector3 = [number, number, number];
|
|
2030
|
+
|
|
1799
2031
|
export declare class FBXFileLoader {
|
|
1800
|
-
constructor();
|
|
2032
|
+
constructor(_options?: Partial<FBXFileLoaderOptions>);
|
|
2033
|
+
}
|
|
2034
|
+
|
|
2035
|
+
export declare const FBXFileLoaderMetadata: {
|
|
2036
|
+
readonly name: "fbx";
|
|
2037
|
+
readonly extensions: {
|
|
2038
|
+
readonly ".fbx": {
|
|
2039
|
+
readonly isBinary: true;
|
|
2040
|
+
};
|
|
2041
|
+
};
|
|
2042
|
+
};
|
|
2043
|
+
|
|
2044
|
+
export declare interface FBXFileLoaderOptions {
|
|
2045
|
+
preset?: "compatible" | "full";
|
|
2046
|
+
normalMapCoordinateSystem?: FBXNormalMapCoordinateSystem;
|
|
2047
|
+
materials?: "auto" | "standard" | "pbr";
|
|
2048
|
+
unitScale?: "preserve" | "meters" | number;
|
|
2049
|
+
shareGeometry?: boolean;
|
|
2050
|
+
onWarning?: (warning: FBXLoaderWarning) => void;
|
|
2051
|
+
nurbsSubdivision?: number;
|
|
2052
|
+
curves?: "lines" | "skip";
|
|
2053
|
+
constraints?: "apply" | "metadata";
|
|
2054
|
+
rebaseAnimations?: boolean;
|
|
2055
|
+
attachCamerasAndLights?: boolean;
|
|
2056
|
+
}
|
|
2057
|
+
|
|
2058
|
+
export declare interface FBXLoaderWarning {
|
|
2059
|
+
source: "scene" | "model" | "geometry" | "skin" | "rig" | "animation" | "blendShape" | "camera" | "light";
|
|
2060
|
+
message: string;
|
|
2061
|
+
objectName?: string;
|
|
2062
|
+
details?: unknown;
|
|
2063
|
+
}
|
|
2064
|
+
|
|
2065
|
+
export declare type FBXNormalMapCoordinateSystem = "y-up" | "y-down";
|
|
2066
|
+
|
|
2067
|
+
declare type FloatArray = number[] | Float32Array;
|
|
2068
|
+
|
|
2069
|
+
export declare enum FlowGraphValidationSeverity {
|
|
2070
|
+
Error = 0,
|
|
2071
|
+
Warning = 1
|
|
1801
2072
|
}
|
|
1802
2073
|
|
|
1803
2074
|
export declare class FluidRenderer {
|
|
@@ -1851,6 +2122,10 @@ export declare class FollowCamera extends TargetCamera {
|
|
|
1851
2122
|
private _follow;
|
|
1852
2123
|
}
|
|
1853
2124
|
|
|
2125
|
+
export declare class FrameGraphMeshBlendingTask {
|
|
2126
|
+
constructor(..._args: unknown[]);
|
|
2127
|
+
}
|
|
2128
|
+
|
|
1854
2129
|
/** Frames an `ArcRotateCamera` on a target by setting its radius (no zoom tween). */
|
|
1855
2130
|
export declare class FramingBehavior implements Behavior<ArcRotateCamera> {
|
|
1856
2131
|
readonly name = "Framing";
|
|
@@ -1933,6 +2208,7 @@ export declare class GaussianSplattingMesh extends TransformNode {
|
|
|
1933
2208
|
/**
|
|
1934
2209
|
|
|
1935
2210
|
export declare class GaussianSplattingStream {
|
|
1936
2211
|
constructor(..._args: unknown[]);
|
|
2212
|
+
get minimumResidentSplats(): never;
|
|
1937
2213
|
}
|
|
1938
2214
|
|
|
1939
2215
|
/** Babylon.js `GaussianSplattingStreamDebugLodSource` — LOD debug source selector (shape-only stub for type parity). */
|
|
@@ -2001,7 +2277,7 @@ export declare function GetPointsCount(..._args: unknown[]): never;
|
|
|
2001
2277
|
*/
|
|
2002
2278
|
export declare function GetSupportedSimultaneousLights(scene: Scene, maxSimultaneousLights: number): number;
|
|
2003
2279
|
|
|
2004
|
-
export declare function GetWhiteBalanceMatrix(
|
|
2280
|
+
export declare function GetWhiteBalanceMatrix(temperatureKelvin: number, tint: number): Float32Array;
|
|
2005
2281
|
|
|
2006
2282
|
/** Shared base for compat gizmos (Babylon.js `Gizmo`). */
|
|
2007
2283
|
declare abstract class GizmoBase {
|
|
2008
2284
|
protected constructor(layer: UtilityLayerRenderer);
|
|
@@ -2051,7 +2327,82 @@ export declare namespace GLTF1 {
|
|
|
2051
2327
|
|
|
2052
2328
|
export declare namespace GLTF2 {
|
|
2053
2329
|
export {
|
|
2054
|
-
OpenPBRMaterialLoadingAdapter
|
|
2330
|
+
OpenPBRMaterialLoadingAdapter,
|
|
2331
|
+
ParseDebugLogTemplate,
|
|
2332
|
+
getMappingForFullOperationName,
|
|
2333
|
+
getMappingForDeclaration,
|
|
2334
|
+
getNoOpMappingForDeclaration,
|
|
2335
|
+
addNewInteractivityFlowGraphMapping,
|
|
2336
|
+
getAllSupportedNativeNodeTypes,
|
|
2337
|
+
HasDefaultInteractivityFlowInput,
|
|
2338
|
+
NormalizeInteractivityEventDataConfiguration,
|
|
2339
|
+
GetInteractivityOperationRegistry,
|
|
2340
|
+
GetInteractivityObjectReference,
|
|
2341
|
+
_NormalizeKHRInteractivityRuntimeValue,
|
|
2342
|
+
_CreateKHRInteractivityRuntimeValueSnapshot,
|
|
2343
|
+
CloneKHRInteractivityGraph,
|
|
2344
|
+
CreateEffectiveKHRInteractivityGraph,
|
|
2345
|
+
CreateKHRInteractivityGraphModel,
|
|
2346
|
+
CreateKHRInteractivityDocument,
|
|
2347
|
+
_CaptureKHRInteractivityRuntimeInputDefaults,
|
|
2348
|
+
CreateKHRInteractivityExportPlan,
|
|
2349
|
+
InitializeInteractivityNodeState,
|
|
2350
|
+
GetInteractivityNodeState,
|
|
2351
|
+
SetInteractivityNodeState,
|
|
2352
|
+
KHRInteractivitySignature,
|
|
2353
|
+
IKHRInteractivityNode,
|
|
2354
|
+
IKHRInteractivityGraph,
|
|
2355
|
+
IKHRInteractivityDeclaration,
|
|
2356
|
+
IKHRInteractivityType,
|
|
2357
|
+
IKHRInteractivityVariable,
|
|
2358
|
+
IKHRInteractivityEvent,
|
|
2359
|
+
IKHRInteractivityOutputSocketReference,
|
|
2360
|
+
IKHRInteractivityOutputFlow,
|
|
2361
|
+
IKHRInteractivityConfiguration,
|
|
2362
|
+
IGLTF,
|
|
2363
|
+
ISerializedFlowGraphConnection,
|
|
2364
|
+
ISerializedFlowGraphBlock,
|
|
2365
|
+
ISerializedFlowGraphContext,
|
|
2366
|
+
ISerializedFlowGraph,
|
|
2367
|
+
IGLTFToFlowGraphMappingObject,
|
|
2368
|
+
IGLTFToFlowGraphMapping,
|
|
2369
|
+
IKHRInteractivityOperationRegistryEntry,
|
|
2370
|
+
IDebugLogTemplateParseResult,
|
|
2371
|
+
KHRInteractivityFlowGraphType,
|
|
2372
|
+
IKHRInteractivityTypeMapping,
|
|
2373
|
+
gltfTypeToBabylonType,
|
|
2374
|
+
IFlowGraphEventReferenceBlockConfiguration,
|
|
2375
|
+
FlowGraphEventReferenceBlock,
|
|
2376
|
+
IFlowGraphGLTFDataProviderBlockConfiguration,
|
|
2377
|
+
FlowGraphGLTFDataProvider,
|
|
2378
|
+
FlowGraphObjectReferenceBlock,
|
|
2379
|
+
IFlowGraphUnsupportedInteractivitySocket,
|
|
2380
|
+
IFlowGraphUnsupportedInteractivityBlockConfiguration,
|
|
2381
|
+
FlowGraphUnsupportedInteractivityBlock,
|
|
2382
|
+
KHR_INTERACTIVITY_SPECIFICATION_COMMIT,
|
|
2383
|
+
KHRInteractivityDeclarationSupport,
|
|
2384
|
+
IKHRInteractivityDiagnostic,
|
|
2385
|
+
IKHRInteractivityDeclarationModel,
|
|
2386
|
+
IKHRInteractivityGraphModel,
|
|
2387
|
+
IKHRInteractivityInputDefaultProvenance,
|
|
2388
|
+
IKHRInteractivityConfigurationProvenance,
|
|
2389
|
+
IKHRInteractivityBlockProvenance,
|
|
2390
|
+
IKHRInteractivitySocketProvenance,
|
|
2391
|
+
IKHRInteractivityGraphProvenance,
|
|
2392
|
+
IKHRInteractivityDocument,
|
|
2393
|
+
KHRInteractivityExportClassification,
|
|
2394
|
+
IKHRInteractivityExportDiagnostic,
|
|
2395
|
+
IKHRInteractivityNodeExportAnalysis,
|
|
2396
|
+
IKHRInteractivityExportAnalysis,
|
|
2397
|
+
KhrInteractivityRootCollection,
|
|
2398
|
+
IKHRInteractivitySerializerContext,
|
|
2399
|
+
IKHRInteractivityExportProvider,
|
|
2400
|
+
IKHRInteractivityExportOptions,
|
|
2401
|
+
KHRInteractivityExportError,
|
|
2402
|
+
KHRInteractivityExportPlan,
|
|
2403
|
+
InteractivityEvent,
|
|
2404
|
+
InteractivityGraphToFlowGraphParser,
|
|
2405
|
+
InteractivityNodeState
|
|
2055
2406
|
}
|
|
2056
2407
|
}
|
|
2057
2408
|
|
|
@@ -2382,11 +2733,21 @@ export declare interface IAbstractSoundOptions extends Partial<IVolumeAudioOptio
|
|
|
2382
2733
|
|
|
2383
2734
|
export declare interface IAnimationKey {
|
|
2384
2735
|
frame: number;
|
|
2385
|
-
value:
|
|
2736
|
+
value: AnimationValue;
|
|
2386
2737
|
/** Babylon.js per-key interpolation hint (`AnimationKeyInterpolation`). */
|
|
2387
2738
|
interpolation?: number;
|
|
2388
2739
|
}
|
|
2389
2740
|
|
|
2741
|
+
/** Structural vector/quaternion value accepted by Babylon.js animation keys. */
|
|
2742
|
+
export declare interface IAnimationVectorValue {
|
|
2743
|
+
readonly x: number;
|
|
2744
|
+
readonly y: number;
|
|
2745
|
+
readonly z?: number;
|
|
2746
|
+
readonly w?: number;
|
|
2747
|
+
clone(): IAnimationVectorValue;
|
|
2748
|
+
asArray(): number[];
|
|
2749
|
+
}
|
|
2750
|
+
|
|
2390
2751
|
/** Babylon.js `IAudioAnalyzerOptions`. */
|
|
2391
2752
|
export declare interface IAudioAnalyzerOptions {
|
|
2392
2753
|
/** Build the analyzer immediately. Defaults to `false`. */
|
|
@@ -2440,6 +2801,20 @@ export declare interface ICharacterControllerCollisionEvent {
|
|
|
2440
2801
|
impulsePosition: Vector3;
|
|
2441
2802
|
}
|
|
2442
2803
|
|
|
2804
|
+
export declare interface IComputeShaderOptions {
|
|
2805
|
+
bindingsMapping: ComputeBindingMapping;
|
|
2806
|
+
defines?: string[];
|
|
2807
|
+
entryPoint?: string;
|
|
2808
|
+
processFinalCode?: ((code: string) => string) | null;
|
|
2809
|
+
useExplicitComputePipelineLayout?: boolean;
|
|
2810
|
+
}
|
|
2811
|
+
|
|
2812
|
+
export declare interface IComputeShaderPath {
|
|
2813
|
+
computeSource?: string;
|
|
2814
|
+
compute?: string;
|
|
2815
|
+
computeElement?: string;
|
|
2816
|
+
}
|
|
2817
|
+
|
|
2443
2818
|
/** Babylon.js `ICreateTexture2DArrayFromImageUrlsOptions`. */
|
|
2444
2819
|
export declare interface ICreateTexture2DArrayFromImageUrlsOptions extends IUploadImageToTexture2DArrayLayerOptions {
|
|
2445
2820
|
/** Generate a full mip chain (true by default). */
|
|
@@ -2462,6 +2837,40 @@ export declare interface ICreateTexture2DArrayFromKTX2Options {
|
|
|
2462
2837
|
invertY?: boolean;
|
|
2463
2838
|
}
|
|
2464
2839
|
|
|
2840
|
+
export declare interface IDitheredTileFadeBounds {
|
|
2841
|
+
lowerBound: number;
|
|
2842
|
+
upperBound: number;
|
|
2843
|
+
}
|
|
2844
|
+
|
|
2845
|
+
/**
|
|
2846
|
+
* Contract implemented by Babylon.js easing functions.
|
|
2847
|
+
*
|
|
2848
|
+
* Custom easing objects only need to transform a normalized segment gradient.
|
|
2849
|
+
*/
|
|
2850
|
+
export declare interface IEasingFunction {
|
|
2851
|
+
/**
|
|
2852
|
+
* Transform a segment-local gradient.
|
|
2853
|
+
* @param gradient - Linear progress through the current keyframe segment.
|
|
2854
|
+
* @returns The progress used for interpolation. Values are not clamped.
|
|
2855
|
+
*/
|
|
2856
|
+
ease(gradient: number): number;
|
|
2857
|
+
}
|
|
2858
|
+
|
|
2859
|
+
export declare interface IFlowGraphValidationIssue {
|
|
2860
|
+
severity: FlowGraphValidationSeverity;
|
|
2861
|
+
message: string;
|
|
2862
|
+
block?: unknown;
|
|
2863
|
+
connectionName?: string;
|
|
2864
|
+
}
|
|
2865
|
+
|
|
2866
|
+
export declare interface IFlowGraphValidationResult {
|
|
2867
|
+
isValid: boolean;
|
|
2868
|
+
issues: IFlowGraphValidationIssue[];
|
|
2869
|
+
errorCount: number;
|
|
2870
|
+
warningCount: number;
|
|
2871
|
+
issuesByBlock: Map<string, IFlowGraphValidationIssue[]>;
|
|
2872
|
+
}
|
|
2873
|
+
|
|
2465
2874
|
/** Babylon.js `IGaussianSplattingStreamingPart` — a streamed part of a GS compound mesh (shape-only stub for type parity). */
|
|
2466
2875
|
export declare interface IGaussianSplattingStreamingPart {
|
|
2467
2876
|
[key: string]: unknown;
|
|
@@ -2546,6 +2955,32 @@ declare type ImageSource = ImageBitmap | HTMLImageElement | HTMLCanvasElement |
|
|
|
2546
2955
|
export declare interface IMainAudioBusOptions extends Partial<IVolumeAudioOptions> {
|
|
2547
2956
|
}
|
|
2548
2957
|
|
|
2958
|
+
export declare interface IMeshBlendConfiguration {
|
|
2959
|
+
quality?: MeshBlendQuality;
|
|
2960
|
+
radiusClasses?: MeshBlendRadiusDefinitions;
|
|
2961
|
+
slopeFactor?: number;
|
|
2962
|
+
depthType?: MeshBlendDepthType;
|
|
2963
|
+
debugMode?: MeshBlendDebugMode;
|
|
2964
|
+
}
|
|
2965
|
+
|
|
2966
|
+
export declare interface IMeshBlendingPostProcessOptions extends IMeshBlendConfiguration {
|
|
2967
|
+
effectWrapper?: ThinMeshBlendingPostProcess;
|
|
2968
|
+
meshBlendTagTexture: unknown;
|
|
2969
|
+
depthTexture: unknown;
|
|
2970
|
+
baseColorTexture?: unknown;
|
|
2971
|
+
[key: string]: unknown;
|
|
2972
|
+
}
|
|
2973
|
+
|
|
2974
|
+
export declare interface IMeshBlendingTag {
|
|
2975
|
+
groupId: number;
|
|
2976
|
+
radiusClass: MeshBlendingRadiusClass;
|
|
2977
|
+
}
|
|
2978
|
+
|
|
2979
|
+
export declare interface IMeshBlendRadiusDefinition {
|
|
2980
|
+
worldRadius: number;
|
|
2981
|
+
minimumProjectedRadius: number;
|
|
2982
|
+
}
|
|
2983
|
+
|
|
2549
2984
|
/** Babylon.js `ImportMeshAsync(source, scene, options?)` — imports an asset into the scene. */
|
|
2550
2985
|
export declare function ImportMeshAsync(source: string, scene: Scene, options?: ImportMeshOptions): Promise<ImportResult>;
|
|
2551
2986
|
|
|
@@ -2754,6 +3189,10 @@ export declare interface IStreamingSoundPlayOptions {
|
|
|
2754
3189
|
volume?: number;
|
|
2755
3190
|
}
|
|
2756
3191
|
|
|
3192
|
+
export declare interface IThinMeshBlendingPostProcessOptions extends IMeshBlendConfiguration {
|
|
3193
|
+
[key: string]: unknown;
|
|
3194
|
+
}
|
|
3195
|
+
|
|
2757
3196
|
/** Babylon.js `IUploadImageToTexture2DArrayLayerOptions`. */
|
|
2758
3197
|
export declare interface IUploadImageToTexture2DArrayLayerOptions {
|
|
2759
3198
|
/** Store the source with the Y axis inverted (false by default). */
|
|
@@ -2933,7 +3372,8 @@ export declare class MainAudioBus extends AbstractAudioBus {
|
|
|
2933
3372
|
getClassName():
|
|
2934
3373
|
|
|
2935
3374
|
/** Babylon.js `Material` — base class for all materials. */
|
|
2936
3375
|
export declare abstract class Material {
|
|
2937
|
-
name: string;
|
|
3376
|
+
name: string;
|
|
2938
3377
|
/** Babylon.js plugin manager, created lazily by the first `MaterialPluginBase`. */
|
|
3378
|
+
pluginManager: MaterialPluginManager | undefined;
|
|
2939
3379
|
/** Common transparency mode flag (Babylon.js `Material.transparencyMode`). */
|
|
2940
3380
|
transparencyMode: number | null;
|
|
2941
3381
|
/** Back-face culling toggle (Babylon.js `Material.backFaceCulling`). */
|
|
@@ -2965,6 +3405,75 @@ export declare class MaterialGreasedLineDefines {
|
|
|
2965
3405
|
constructor(..._args: unknown[]);
|
|
2966
3406
|
}
|
|
2967
3407
|
|
|
3408
|
+
/**
|
|
3409
|
+
* Babylon.js `MaterialPluginBase` adapter over Lite's opt-in material-plugin
|
|
3410
|
+
* bridge. Subclasses keep the Babylon.js override shape while Lite receives a
|
|
3411
|
+
* plain plugin descriptor.
|
|
3412
|
+
*/
|
|
3413
|
+
export declare class MaterialPluginBase {
|
|
3414
|
+
private _name;
|
|
3415
|
+
private _priority;
|
|
3416
|
+
private _resolveIncludes;
|
|
3417
|
+
readonly markAllDefinesAsDirty: () => void;
|
|
3418
|
+
registerForExtraEvents: boolean;
|
|
3419
|
+
doNotSerialize: boolean;
|
|
3420
|
+
protected readonly _material: Material;
|
|
3421
|
+
protected readonly _pluginManager: MaterialPluginManager;
|
|
3422
|
+
protected readonly _pluginDefineNames?: MaterialPluginDefines;
|
|
2968
3423
|
constructor(material: Material, name: string, priority: number, defines?: MaterialPluginDefines, addToPluginList?: boolean, enable?: boolean, resolveIncludes?: boolean);
|
|
3424
|
+
get name(): string;
|
|
3425
|
+
set name(value: string);
|
|
3426
|
+
get priority(): number;
|
|
3427
|
+
set priority(value: number);
|
|
3428
|
+
get resolveIncludes(): boolean;
|
|
3429
|
+
set resolveIncludes(value: boolean);
|
|
2969
3430
|
protected _enable(enable: boolean): void;
|
|
2970
3431
|
private _assertSupportedExecution;
|
|
3432
|
+
isCompatible(_shaderLanguage: ShaderLanguage): boolean;
|
|
3433
|
+
getCustomCode(_shaderType: string, _shaderLanguage?: ShaderLanguage): MaterialPluginCustomCode | null;
|
|
3434
|
+
isReadyForSubMesh(_defines: object, _scene: Scene, _engine: object, _subMesh: object): boolean;
|
|
3435
|
+
hardBindForSubMesh(_uniformBuffer: object, _scene: Scene, _engine: object, _subMesh: object): void;
|
|
3436
|
+
bindForSubMesh(_uniformBuffer: object, _scene: Scene, _engine: object, _subMesh: object): void;
|
|
3437
|
+
collectDefines(defines: Record<string, {
|
|
3438
|
+
type: string;
|
|
3439
|
+
default: unknown;
|
|
3440
|
+
}>): void;
|
|
3441
|
+
prepareDefinesBeforeAttributes(_defines: object, _scene: Scene, _mesh: AbstractMesh): void;
|
|
3442
|
+
prepareDefines(_defines: object, _scene: Scene, _mesh: AbstractMesh): void;
|
|
3443
|
+
hasTexture(_texture: BaseTexture): boolean;
|
|
3444
|
+
hasRenderTargetTextures(): boolean;
|
|
3445
|
+
fillRenderTargetTextures(_renderTargets: SmartArray<RenderTargetTexture>): void;
|
|
3446
|
+
getActiveTextures(_activeTextures: BaseTexture[]): void;
|
|
3447
|
+
getAnimatables(_animatables: object[]): void;
|
|
3448
|
+
addFallbacks(_defines: object, _fallbacks: object, currentRank: number): number;
|
|
3449
|
+
getSamplers(_samplers: string[]): void;
|
|
3450
|
+
getAttributes(_attributes: string[], _scene: Scene, _mesh: AbstractMesh): void;
|
|
3451
|
+
getUniformBuffersNames(_ubos: string[]): void;
|
|
3452
|
+
getUniforms(_shaderLanguage?: ShaderLanguage): {
|
|
3453
|
+
ubo?: Array<{
|
|
3454
|
+
name: string;
|
|
3455
|
+
size?: number;
|
|
3456
|
+
type?: string;
|
|
3457
|
+
arraySize?: number;
|
|
3458
|
+
}>;
|
|
3459
|
+
vertex?: string;
|
|
3460
|
+
fragment?: string;
|
|
3461
|
+
externalUniforms?: string[];
|
|
3462
|
+
};
|
|
3463
|
+
getClassName(): string;
|
|
3464
|
+
copyTo(plugin: MaterialPluginBase): void;
|
|
3465
|
+
serialize(): Record<string, unknown>;
|
|
3466
|
+
parse(source: Record<string, unknown>, _scene: Scene, _rootUrl: string): void;
|
|
3467
|
+
dispose(_forceDisposeTextures?: boolean): void;
|
|
3468
|
+
}
|
|
3469
|
+
|
|
3470
|
+
export declare type MaterialPluginCustomCode = Record<string, string>;
|
|
3471
|
+
|
|
3472
|
+
export declare type MaterialPluginDefines = Record<string, unknown>;
|
|
3473
|
+
|
|
3474
|
+
/** Babylon.js-shaped manager for the adapter-visible material plugin list. */
|
|
3475
|
+
export declare class MaterialPluginManager {
|
|
3476
|
+
private readonly _plugins;
|
|
3477
|
+
constructor(material: Material);
|
|
2971
3478
|
getPlugin<T = MaterialPluginBase>(name: string): T | null;
|
|
3479
|
+
}
|
|
3480
|
+
|
|
2972
3481
|
export declare class Matrix {
|
|
2973
3482
|
readonly m: Float32Array;
|
|
2974
3483
|
constructor();
|
|
@@ -3024,7 +3533,12 @@ export declare class Matrix {
|
|
|
3024
3533
|
markAsUpdated(): this;
|
|
3025
3534
|
}
|
|
3026
3535
|
|
|
3027
|
-
|
|
3536
|
+
declare interface MatrixLike {
|
|
3537
|
+
asArray(): ArrayLike<number>;
|
|
3538
|
+
readonly updateFlag?: number;
|
|
3539
|
+
}
|
|
3540
|
+
|
|
3541
|
+
export { MaxTintMagnitude }
|
|
3028
3542
|
|
|
3029
3543
|
/** Babylon.js `Mesh` — a concrete renderable mesh with geometry. */
|
|
3030
3544
|
export declare class Mesh extends AbstractMesh {
|
|
@@ -3097,6 +3611,47 @@ export declare class Mesh extends AbstractMesh {
|
|
|
3097
3611
|
static MergeMeshes(meshes: (Mesh | null | undefined)[], disposeSource?: boolean, allow32BitsIndices?: boolean, meshSubclass?: Mesh, subdivideWithSubMeshes?: boolean, multiMultiMaterials?: boolean): Mesh | null;
|
|
3098
3612
|
}
|
|
3099
3613
|
|
|
3614
|
+
export declare enum MeshBlendDebugMode {
|
|
3615
|
+
Off = 0,
|
|
3616
|
+
PackedTag = 1,
|
|
3617
|
+
CandidateDirectionDistance = 2,
|
|
3618
|
+
SeamFade = 3,
|
|
3619
|
+
RejectionReason = 4,
|
|
3620
|
+
StageWork = 5,
|
|
3621
|
+
Continuation = 6,
|
|
3622
|
+
TinyObject = 7,
|
|
3623
|
+
MultiTarget = 8,
|
|
3624
|
+
TargetColor = 9,
|
|
3625
|
+
ShadowAttenuation = 10,
|
|
3626
|
+
ColorInterpolation = 11,
|
|
3627
|
+
WorldPosition = 12
|
|
3628
|
+
}
|
|
3629
|
+
|
|
3630
|
+
export declare enum MeshBlendDepthType {
|
|
3631
|
+
View = 0,
|
|
3632
|
+
Screen = 1
|
|
3633
|
+
}
|
|
3634
|
+
|
|
3635
|
+
export declare class MeshBlendingPostProcess {
|
|
3636
|
+
constructor(..._args: unknown[]);
|
|
3637
|
+
}
|
|
3638
|
+
|
|
3639
|
+
export declare enum MeshBlendingRadiusClass {
|
|
3640
|
+
Small = 0,
|
|
3641
|
+
Medium = 1,
|
|
3642
|
+
Large = 2,
|
|
3643
|
+
ExtraLarge = 3
|
|
3644
|
+
}
|
|
3645
|
+
|
|
3646
|
+
export declare enum MeshBlendQuality {
|
|
3647
|
+
Low = 0,
|
|
3648
|
+
Medium = 1,
|
|
3649
|
+
High = 2,
|
|
3650
|
+
Cinematic = 3
|
|
3651
|
+
}
|
|
3652
|
+
|
|
3653
|
+
export declare type MeshBlendRadiusDefinitions = readonly [IMeshBlendRadiusDefinition, IMeshBlendRadiusDefinition, IMeshBlendRadiusDefinition, IMeshBlendRadiusDefinition];
|
|
3654
|
+
|
|
3100
3655
|
/** Babylon.js `MeshBuilder` — factory namespace for primitive meshes. */
|
|
3101
3656
|
export declare const MeshBuilder: {
|
|
3102
3657
|
CreateBox(name: string, options: BoxOptions, scene: Scene): Mesh;
|
|
@@ -3161,7 +3716,7 @@ export declare class MeshoptCompression {
|
|
|
3161
3716
|
static get Default(): MeshoptCompression;
|
|
3162
3717
|
}
|
|
3163
3718
|
|
|
3164
|
-
export
|
|
3719
|
+
export { MinTemperatureKelvin }
|
|
3165
3720
|
|
|
3166
3721
|
export declare class MirrorTexture {
|
|
3167
3722
|
constructor();
|
|
@@ -3230,6 +3785,14 @@ declare abstract class Node_2 {
|
|
|
3230
3785
|
* descendant nodes that are meshes (all descendants by default).
|
|
3231
3786
|
*/
|
|
3232
3787
|
getChildMeshes(directDescendantsOnly?: boolean, predicate?: (node: Node_2) => boolean): Node_2[];
|
|
3788
|
+
/**
|
|
3789
|
+
* Babylon.js `node.getHierarchyBoundingVectors(includeDescendants?, predicate?)`
|
|
3790
|
+
* — world-space bounds spanning this mesh and eligible descendant meshes.
|
|
3791
|
+
*/
|
|
3792
|
+
getHierarchyBoundingVectors(includeDescendants?: boolean, predicate?: ((mesh: AbstractMesh) => boolean) | null): {
|
|
3793
|
+
min: Vector3;
|
|
3794
|
+
max: Vector3;
|
|
3795
|
+
};
|
|
3233
3796
|
isEnabled(checkAncestors?: boolean): boolean;
|
|
3234
3797
|
setEnabled(value: boolean): void;
|
|
3235
3798
|
isDisposed(): boolean;
|
|
3236
3799
|
dispose(doNotRecurse?: boolean): void;
|
|
@@ -3308,6 +3871,10 @@ export declare class NodeParticleSystemSet {
|
|
|
3308
3871
|
dispose(): void;
|
|
3309
3872
|
}
|
|
3310
3873
|
|
|
3874
|
+
export declare class NodeRenderGraphMeshBlendingPostProcessBlock {
|
|
3875
|
+
constructor(..._args: unknown[]);
|
|
3876
|
+
}
|
|
3877
|
+
|
|
3311
3878
|
/**
|
|
3312
3879
|
* Babylon.js's `NullEngine` — a headless engine with no GPU device, used to run
|
|
3313
3880
|
* scene logic (animations, observables, physics stepping, frame timing) without
|
|
@@ -3388,6 +3955,8 @@ export declare class OutlineRenderer {
|
|
|
3388
3955
|
constructor();
|
|
3389
3956
|
}
|
|
3390
3957
|
|
|
3958
|
+
export declare function PackMeshBlendingTag(groupId: number, radiusClass: MeshBlendingRadiusClass): number;
|
|
3959
|
+
|
|
3391
3960
|
export declare class ParticleHelper {
|
|
3392
3961
|
constructor();
|
|
3393
3962
|
}
|
|
@@ -4154,6 +4723,15 @@ export declare class PostProcess {
|
|
|
4154
4723
|
constructor();
|
|
4155
4724
|
}
|
|
4156
4725
|
|
|
4726
|
+
/**
|
|
4727
|
+
* Babylon.js-compatible power easing class.
|
|
4728
|
+
*/
|
|
4729
|
+
export declare class PowerEase extends EasingFunction {
|
|
4730
|
+
power: number;
|
|
4731
|
+
constructor(power?: number);
|
|
4732
|
+
easeInCore(gradient: number): number;
|
|
4733
|
+
}
|
|
4734
|
+
|
|
4157
4735
|
/** Babylon.js `PrecisionDate` — high-resolution timestamp source. */
|
|
4158
4736
|
export declare const PrecisionDate: {
|
|
4159
4737
|
readonly Now: number;
|
|
@@ -4375,6 +4953,14 @@ export declare function RegisterAbstractEngineTextureLoaders(): void;
|
|
|
4375
4953
|
*/
|
|
4376
4954
|
export declare function registerBuiltInLoaders(): void;
|
|
4377
4955
|
|
|
4956
|
+
export declare function RegisterComputeShader(): void;
|
|
4957
|
+
|
|
4958
|
+
/** Pure-build registration shim; compat wires the Lite array upload directly. */
|
|
4959
|
+
export declare function RegisterEnginesExtensionsEngineTexture2DArrayImageSource(): void;
|
|
4960
|
+
|
|
4961
|
+
/** WebGPU pure-build registration shim; Babylon Lite is WebGPU-only. */
|
|
4962
|
+
export declare function RegisterEnginesWebGPUExtensionsEngineTexture2DArrayImageSource(): void;
|
|
4963
|
+
|
|
4378
4964
|
export declare function RegisterFluidRenderer(): void;
|
|
4379
4965
|
|
|
4380
4966
|
export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
|
|
@@ -4382,6 +4968,8 @@ export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]):
|
|
|
4382
4968
|
/** Babylon.js pure-module registration hook. */
|
|
4383
4969
|
export declare function RegisterImageProcessingConfiguration(): void;
|
|
4384
4970
|
|
|
4971
|
+
export declare function RegisterMeshBlendingPostProcessBlock(): never;
|
|
4972
|
+
|
|
4385
4973
|
export declare function RegisterOpenpbrMaterial(): void;
|
|
4386
4974
|
|
|
4387
4975
|
export declare function RegisterUSDFileLoader(): never;
|
|
@@ -4463,8 +5051,8 @@ export declare class Scene extends AbstractScene {
|
|
|
4463
5051
|
/** Babylon.js fog-mode c
|
|
4464
5052
|
* Babylon.js `scene.animationGroups` / `scene.animatables`. Loaded glTF /
|
|
4465
5053
|
* `.babylon` animation clips live on the Lite scene; `animationGroups` returns
|
|
4466
5054
|
* BJS-shaped `AnimationGroup`s over them (so scenes can `goToFrame`/`pause`/`stop`
|
|
4467
|
-
* to freeze a model at a deterministic frame). `animatables` surfaces the
|
|
4468
|
-
*
|
|
5055
|
+
* to freeze a model at a deterministic frame). `animatables` surfaces the
|
|
5056
|
+
* native-backed and fallback `Animatable`s started through the scene.
|
|
4469
5057
|
*/
|
|
4470
5058
|
get animationGroups(): AnimationGroup[];
|
|
4471
5059
|
/** Babylon.js `scene.getAnimationGroupByName(name)` — first loaded animation group with a matching name, else `null`. */
|
|
@@ -4486,8 +5074,9 @@ export declare class Scene extends AbstractScene {
|
|
|
4486
5074
|
/** Babylon.js fog-mode c
|
|
4487
5075
|
private readonly _pendingTextures;
|
|
4488
5076
|
private readonly _pendingGroundBakes;
|
|
4489
5077
|
private readonly _pendingMorphBuilds;
|
|
4490
|
-
private readonly _runningAnimatables;
|
|
4491
|
-
private readonly _animationGroupCache;
|
|
4492
5078
|
private _ambientColor;
|
|
5079
|
+
private _materialPluginsRequested;
|
|
5080
|
+
private readonly _pendingMaterialPluginReconciliations;
|
|
5081
|
+
private readonly _runningAnimatables;
|
|
4493
5082
|
private readonly _animationGroupCache;
|
|
4494
5083
|
private _ambientColor;
|
|
4495
5084
|
private _environmentIntensity;
|
|
4496
5085
|
private _imageProcessingConfiguration;
|
|
4497
5086
|
/** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
|
|
4498
5087
|
readonly uniqueId: number;
|
|
@@ -4649,8 +5238,9 @@ export declare class Scene extends AbstractScene {
|
|
|
4649
5238
|
/** Babylon.js fog-mode c
|
|
4650
5239
|
disablePhysicsEngine(): void;
|
|
4651
5240
|
/**
|
|
4652
5241
|
* Babylon.js `scene.beginDirectAnimation(target, animations, from, to, loop, speedRatio?)`.
|
|
4653
|
-
*
|
|
4654
|
-
*
|
|
5242
|
+
* Delegates supported tracks to Babylon Lite property animation and retains
|
|
5243
|
+
* explicit compat evaluation only for unsupported tracks. Returns one facade
|
|
5244
|
+
* coordinating both subsets.
|
|
4655
5245
|
*/
|
|
4656
5246
|
beginDirectAnimation(target: unknown, animations: Animation_2[], from: number, to: number, loop?: boolean, speedRatio?: number): Animatable_2;
|
|
4657
5247
|
/**
|
|
4658
5248
|
* Babylon.js `scene.beginAnimation(target, from, to, loop, speedRatio?)`. Runs
|
|
@@ -4763,6 +5353,15 @@ export declare class ShadowGenerator {
|
|
|
4763
5353
|
private _removeCaster;
|
|
4764
5354
|
private _scheduleCasterSync;
|
|
4765
5355
|
private _flushCasterSync;
|
|
5356
|
+
/**
|
|
5357
|
+
* The Lite meshes handed to the native shadow task: every requested caster that carries GPU geometry.
|
|
5358
|
+
* The compat loader wraps a model's complete hierarchy as `Mesh`es, so `addShadowCaster(root, true)`
|
|
5359
|
+
* legitimately collects transform-only roots and intermediate nodes into `renderList`, exactly as
|
|
5360
|
+
* Babylon.js does. Those nodes must not reach the native state: the render task cannot build a
|
|
5361
|
+
* renderable for a mesh without `_gpu` (it would throw inside the frame, every frame), and directional
|
|
5362
|
+
* fitting would substitute default bounds for it, distorting the shadow volume.
|
|
5363
|
+
*/
|
|
5364
|
+
private _liteCasterMeshes;
|
|
4766
5365
|
/** Babylon.js `getShadowMap()` — returns a minimal render-list holder for parity. */
|
|
4767
5366
|
getShadowMap(): {
|
|
4768
5367
|
renderList: AbstractMesh[];
|
|
@@ -5010,7 +5609,9 @@ export declare class SpriteManager {
|
|
|
5010
5609
|
disableDepthWrite: boolean;
|
|
5011
5610
|
/** Babylon.js `manager.blendMode` (`Constants.ALPHA_*`). Mapped to a Lite billboard blend at build. */
|
|
5012
5611
|
blendMode: number;
|
|
5013
5612
|
private _atlas?;
|
|
5014
|
-
constructor(name: string, url: string, capacity: number, cellSize: CellSize, scene: Scene, _epsilon?: number, samplingMode?: number);
|
|
5613
|
+
constructor(name: string, url: string, capacity: number, cellSize: CellSize, scene: Scene, _epsilon?: number, samplingMode?: number);
|
|
5614
|
+
/** Babylon.js `SpriteManager.isReady()` — an empty manager is ready without renderer preparation. */
|
|
5615
|
+
isReady(): boolean;
|
|
5015
5616
|
|
|
5016
5617
|
export declare class SpriteMap {
|
|
5017
5618
|
constructor();
|
|
@@ -5056,7 +5657,9 @@ export declare class SpriteRenderer {
|
|
|
5056
5657
|
private _built;
|
|
5057
5658
|
private readonly _indices;
|
|
5058
5659
|
private _sprites;
|
|
5059
|
-
constructor(engine: WebGPUEngine, capacity?: number, _epsilon?: number, _scene?: unknown);
|
|
5060
5660
|
/**
|
|
5661
|
+
constructor(engine: WebGPUEngine, capacity?: number, _epsilon?: number, _scene?: unknown);
|
|
5662
|
+
/** Babylon.js `SpriteRenderer.isReady()` — the next render can build once its atlas is loaded. */
|
|
5663
|
+
isReady(): boolean;
|
|
5061
5664
|
/**
|
|
5062
5665
|
* Babylon.js `renderer.render(sprites, deltaTime, viewMatrix, projectionMatrix)`.
|
|
5063
5666
|
* The matrices are owned by Babylon Lite's pixel-space sprite pass, so they are
|
|
5064
5667
|
* accepted for API parity but not consumed. First call builds + registers the
|
|
@@ -5068,7 +5671,17 @@ export declare class SSAO2RenderingPipeline {
|
|
|
5068
5671
|
constructor();
|
|
5069
5672
|
}
|
|
5070
5673
|
|
|
5071
|
-
export declare class StandardMaterial extends PushMaterial {
|
|
5072
5674
|
constructor(name: string, scene?: Scene);
|
|
5675
|
+
export declare class StandardMaterial extends PushMaterial {
|
|
5073
5676
|
/** Diffuse colour as the app set it. Kept apart from `_lite.diffuseColor`, which is forced to white
|
|
5677
|
+
* while the material is unlit (see `_syncDiffuse`). */
|
|
5678
|
+
private _diffuse;
|
|
5679
|
+
constructor(name: string, scene?: Scene);
|
|
5680
|
+
/**
|
|
5681
|
+
* Babylon.js shades an unlit StandardMaterial as `emissive + ambient`: the diffuse colour only scales
|
|
5682
|
+
* the accumulated light, and there is none. Lite's unlit path is `emissive × diffuse`, so the usual
|
|
5683
|
+
* "unlit colour" setup (black diffuse, colour in emissive) rendered black. Hand Lite a neutral white
|
|
5684
|
+
* diffuse while lighting is disabled and the app's own colour otherwise.
|
|
5685
|
+
*/
|
|
5686
|
+
private _syncDiffuse;
|
|
5074
5687
|
getClassName(): string;
|
|
5075
5688
|
get diffuseColor(): Color3;
|
|
5076
5689
|
set diffuseColor(value: Color3);
|
|
@@ -5178,6 +5791,18 @@ export declare class STLFileLoader {
|
|
|
5178
5791
|
constructor();
|
|
5179
5792
|
}
|
|
5180
5793
|
|
|
5794
|
+
/** Babylon.js-shaped wrapper over Lite's public opaque storage allocation. */
|
|
5795
|
+
export declare class StorageBuffer {
|
|
5796
|
+
private readonly _engine;
|
|
5181
5797
|
private readonly _copyReadable;
|
|
5798
|
+
private readonly _copyWritable;
|
|
5799
|
+
constructor(_engine: WebGPUEngine, size: number, creationFlags?: number, label?: string);
|
|
5182
5800
|
getBuffer(): StorageBuffer_2 | null;
|
|
5801
|
+
clear(byteOffset?: number, byteLength?: number): void;
|
|
5802
|
+
update(data: DataArray, byteOffset?: number, byteLength?: number): void;
|
|
5803
|
+
read(offset?: number, size?: number, buffer?: ArrayBufferView, noDelay?: boolean): Promise<ArrayBufferView>;
|
|
5804
|
+
dispose(): void;
|
|
5183
5805
|
private _requireBuffer;
|
|
5806
|
+
private _assertCopyWritable;
|
|
5807
|
+
}
|
|
5808
|
+
|
|
5184
5809
|
/** Babylon.js `StreamingSound` — a media-element-backed sound. */
|
|
5185
5810
|
export declare class StreamingSound extends AbstractSound {
|
|
5186
5811
|
private readonly _autoplay;
|
|
5187
5812
|
private _loop;
|
|
@@ -5259,7 +5884,7 @@ export declare class TargetCamera extends Camera {
|
|
|
5259
5884
|
constructor(name: string,
|
|
5260
5885
|
|
|
5261
5886
|
declare type TaskState = "init" | "running" | "done" | "error";
|
|
5262
5887
|
|
|
5263
|
-
export declare function TemperatureTintToXyz(
|
|
5888
|
+
export declare function TemperatureTintToXyz(temperatureKelvin: number, tint: number): Vector3;
|
|
5264
5889
|
|
|
5265
5890
|
export declare class Texture extends BaseTexture {
|
|
5266
5891
|
private readonly _ready;
|
|
@@ -5325,6 +5950,10 @@ export declare class ThinFSR1UpscalePostProcess {
|
|
|
5325
5950
|
constructor();
|
|
5326
5951
|
}
|
|
5327
5952
|
|
|
5953
|
+
export declare class ThinMeshBlendingPostProcess {
|
|
5954
|
+
constructor(..._args: unknown[]);
|
|
5955
|
+
}
|
|
5956
|
+
|
|
5328
5957
|
/**
|
|
5329
5958
|
* Babylon.js `ThinSprite` — a lightweight pixel-space sprite drawn by a
|
|
5330
5959
|
* {@link SpriteRenderer}. Position is in screen pixels (origin bottom-left, +Y
|
|
@@ -5421,6 +6050,83 @@ export declare class TransformNode extends Node_2 {
|
|
|
5421
6050
|
physicsBody: PhysicsBody
|
|
5422
6051
|
|
|
5423
6052
|
export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
|
|
5424
6053
|
|
|
6054
|
+
/** Minimum Babylon.js UniformBuffer surface needed to author compute bindings. */
|
|
6055
|
+
export declare class UniformBuffer {
|
|
6056
|
+
private readonly _engine;
|
|
6057
|
+
private readonly _data;
|
|
6058
|
+
private readonly _dynamic;
|
|
6059
|
+
private readonly _uniformLocations;
|
|
6060
|
+
private readonly _uniformSizes;
|
|
6061
|
+
private readonly _uniformArraySizes;
|
|
6062
|
+
private readonly _uniformNames;
|
|
6063
|
+
private _uniformLocationPointer;
|
|
6064
|
+
private _bufferData;
|
|
6065
|
+
private _buffer;
|
|
6066
|
+
private _needSync;
|
|
6067
|
+
private _name;
|
|
6068
|
+
constructor(_engine: AbstractEngine, data?: number[], dynamic?: boolean, name?: string, forceNoUniformBuffer?: boolean, _trackUBOsInFrame?: boolean);
|
|
6069
|
+
readonly updateMatrix3x3: (name: string, matrix: Float32Array) => void;
|
|
6070
|
+
readonly updateMatrix2x2: (name: string, matrix: Float32Array) => void;
|
|
6071
|
+
readonly updateFloat: (name: string, x: number, _suffix?: string) => void;
|
|
6072
|
+
readonly updateFloat2: (name: string, x: number, y: number, _suffix?: string) => void;
|
|
6073
|
+
readonly updateFloat3: (name: string, x: number, y: number, z: number, _suffix?: string) => void;
|
|
6074
|
+
readonly updateFloat4: (name: string, x: number, y: number, z: number, w: number, _suffix?: string) => void;
|
|
6075
|
+
readonly updateFloatArray: (name: string, array: Float32Array, _suffix?: string) => void;
|
|
6076
|
+
readonly updateArray: (name: string, array: number[]) => void;
|
|
6077
|
+
readonly updateIntArray: (name: string, array: Int32Array) => void;
|
|
6078
|
+
readonly updateUIntArray: (name: string, array: Uint32Array) => void;
|
|
6079
|
+
readonly updateMatrix: (name: string, matrix: MatrixLike) => void;
|
|
6080
|
+
readonly updateMatrices: (name: string, matrices: Float32Array) => void;
|
|
6081
|
+
readonly updateVector3: (name: string, vector: Vector3Like) => void;
|
|
6082
|
+
readonly updateVector4: (name: string, vector: Vector4Like) => void;
|
|
6083
|
+
readonly updateColor3: (name: string, color: Color3Like, suffix?: string) => void;
|
|
6084
|
+
readonly updateColor4: (name: string, color: Color3Like, alpha: number, suffix?: string) => void;
|
|
6085
|
+
readonly updateDirectColor4: (name: string, color: Color4Like, suffix?: string) => void;
|
|
6086
|
+
readonly updateInt: (name: string, x: number, _suffix?: string) => void;
|
|
6087
|
+
readonly updateInt2: (name: string, x: number, y: number, _suffix?: string) => void;
|
|
6088
|
+
readonly updateInt3: (name: string, x: number, y: number, z: number, _suffix?: string) => void;
|
|
6089
|
+
readonly updateInt4: (name: string, x: number, y: number, z: number, w: number, _suffix?: string) => void;
|
|
6090
|
+
readonly updateUInt: (name: string, x: number, _suffix?: string) => void;
|
|
6091
|
+
readonly updateUInt2: (name: string, x: number, y: number, _suffix?: string) => void;
|
|
6092
|
+
readonly updateUInt3: (name: string, x: number, y: number, z: number, _suffix?: string) => void;
|
|
6093
|
+
readonly updateUInt4: (name: string, x: number, y: number, z: number, w: number, _suffix?: string) => void;
|
|
6094
|
+
get useUbo(): boolean;
|
|
6095
|
+
get isSync(): boolean;
|
|
6096
|
+
isDynamic(): boolean;
|
|
6097
|
+
getData(): Float32Array;
|
|
6098
|
+
getBuffer(): UniformBuffer_2 | null;
|
|
6099
|
+
getUniformNames(): string[];
|
|
6100
|
+
addUniform(name: string, sizeOrData: number | number[], arraySize?: number): void;
|
|
6101
|
+
addMatrix(name: string, matrix: MatrixLike): void;
|
|
6102
|
+
addFloat2(name: string, x: number, y: number): void;
|
|
6103
|
+
addFloat3(name: string, x: number, y: number, z: number): void;
|
|
6104
|
+
addColor3(name: string, color: Color3Like): void;
|
|
6105
|
+
addColor4(name: string, color: Color3Like, alpha: number): void;
|
|
6106
|
+
addVector3(name: string, vector: Vector3Like): void;
|
|
6107
|
+
addMatrix3x3(name: string): void;
|
|
6108
|
+
addMatrix2x2(name: string): void;
|
|
6109
|
+
create(): void;
|
|
5425
6110
|
get name(): string;
|
|
6111
|
+
set name(value: string);
|
|
6112
|
+
get currentEffect(): unknown | null;
|
|
6113
|
+
update(): void;
|
|
6114
|
+
updateUniform(uniformName: string, data: FloatArray, size: number): void;
|
|
6115
|
+
updateUniformArray(uniformName: string, data: FloatArray, size: number): void;
|
|
6116
|
+
setTexture(_name: string, _texture: BaseTexture | null): never;
|
|
6117
|
+
setTextureArray(_name: string, _textures: BaseTexture[]): never;
|
|
6118
|
+
bindTexture(_name: string, _texture: unknown | null): never;
|
|
6119
|
+
updateUniformDirectly(uniformName: string, data: FloatArray): void;
|
|
6120
|
+
bindToEffect(_effect: unknown, _name: string): never;
|
|
6121
|
+
bindUniformBuffer(): never;
|
|
6122
|
+
unbindEffect(): void;
|
|
6123
|
+
setDataBuffer(dataBuffer: UniformBuffer_2): boolean;
|
|
6124
|
+
has(name: string): boolean;
|
|
6125
|
+
dispose(): void;
|
|
6126
|
+
private _align;
|
|
6127
|
+
private _updateIntegerUniform;
|
|
6128
|
+
private _updateIntegerUniformArray;
|
|
6129
|
+
private _setInteger;
|
|
6130
|
+
}
|
|
6131
|
+
|
|
5426
6132
|
/** Babylon.js `UninstallHtmlInCanvasPolyfill` — the HTML-in-canvas polyfill is unsupported by the compat layer. */
|
|
5427
6133
|
export declare function UninstallHtmlInCanvasPolyfill(): never;
|
|
5428
6134
|
|
|
@@ -5429,6 +6135,8 @@ export declare class UniversalCamera extends FreeCamera {
|
|
|
5429
6135
|
getClassName(): string;
|
|
5430
6136
|
}
|
|
5431
6137
|
|
|
6138
|
+
export declare function UnpackMeshBlendingTag(tag: number): IMeshBlendingTag;
|
|
6139
|
+
|
|
5432
6140
|
/** Throw a {@link LiteCompatError} for an unsupported API. */
|
|
5433
6141
|
export declare function unsupported(api: string, detail?: string): never;
|
|
5434
6142
|
|
|
@@ -5502,6 +6210,10 @@ export declare class UtilityLayerRenderer {
|
|
|
5502
6210
|
private _registered;
|
|
5503
6211
|
constructor(scene: Scene);
|
|
5504
6212
|
dispose(): void;
|
|
5505
6213
|
}
|
|
5506
6214
|
|
|
6215
|
+
export declare function ValidateFlowGraph(_flowGraph: unknown): IFlowGraphValidationResult;
|
|
6216
|
+
|
|
6217
|
+
export declare function ValidateFlowGraphWithBlockList(_flowGraph: unknown, _allKnownBlocks: unknown[]): IFlowGraphValidationResult;
|
|
6218
|
+
|
|
5507
6219
|
/** Compares `target[propertyPath]` against a value with an operator. */
|
|
5508
6220
|
export declare class ValueCondition extends Condition {
|
|
5509
6221
|
private readonly _target;
|
|
@@ -5623,6 +6335,12 @@ export declare class Vector3 {
|
|
|
5623
6335
|
static TransformNormalToRef<T extends Vector3>(vector: Vector3, transformation: Matrix, result: T): T;
|
|
5624
6336
|
}
|
|
5625
6337
|
|
|
6338
|
+
declare interface Vector3Like {
|
|
6339
|
+
readonly x: number;
|
|
6340
|
+
readonly y: number;
|
|
6341
|
+
readonly z: number;
|
|
6342
|
+
}
|
|
6343
|
+
|
|
5626
6344
|
export declare class Vector4 {
|
|
5627
6345
|
x: number;
|
|
5628
6346
|
y: number;
|
|
@@ -5640,6 +6358,10 @@ export declare class Vector4 {
|
|
|
5640
6358
|
static Zero(): Vector4;
|
|
5641
6359
|
}
|
|
5642
6360
|
|
|
6361
|
+
declare interface Vector4Like extends Vector3Like {
|
|
6362
|
+
readonly w: number;
|
|
6363
|
+
}
|
|
6364
|
+
|
|
5643
6365
|
/**
|
|
5644
6366
|
* Babylon.js `VertexBuffer` — the per-attribute geometry buffer. Only the `kind`
|
|
5645
6367
|
* string constants are surfaced (used with `mesh.getVerticesData` /
|