@babylonjs/lite-compat 1.38.1-preview → 1.39.0-preview
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +64 -32
- package/index.d.ts +219 -19
- package/index.js +790 -545
- package/index.js.map +1 -1
- package/{meshes-CTqDBeGc.js → meshes-C-PkzbPM.js} +456 -22
- package/meshes-C-PkzbPM.js.map +1 -0
- package/navigation.d.ts +185 -17
- package/navigation.js +1 -1
- package/package.json +4 -4
- package/meshes-CTqDBeGc.js.map +0 -1
package/index.d.ts
CHANGED
|
@@ -257,12 +257,19 @@ export declare interface AbstractEngineOptions extends EngineOptions_2 {
|
|
|
257
257
|
* visibility, and shadow-receipt. Concrete meshes derive from this.
|
|
258
258
|
*/
|
|
259
259
|
export declare class AbstractMesh extends TransformNode {
|
|
260
260
|
private _material;
|
|
261
261
|
private _meshBlendingTag;
|
|
262
|
+
protected _visibilityValue: number;
|
|
262
263
|
protected _visible: boolean;
|
|
263
264
|
constructor(name: string, lite: Mesh_2, scene?: Scene);
|
|
264
265
|
getClassName(): string;
|
|
265
266
|
get material(): CompatMaterial | null;
|
|
266
267
|
set material(value: CompatMaterial | null);
|
|
267
268
|
get isVisible(): boolean;
|
|
268
269
|
set isVisible(value: boolean);
|
|
270
|
+
/** Raw finite Babylon visibility; rendering clamps it to [0, 1]. Independent of isVisible. */
|
|
271
|
+
get visibility(): number;
|
|
272
|
+
set visibility(value: number);
|
|
273
|
+
private _validateCompatOpacityMaterial;
|
|
274
|
+
/** A glTF node owns its immediate primitive meshes, never a child glTF node's primitives. */
|
|
275
|
+
private _opacityTargets;
|
|
269
276
|
get isPickable(): boolean;
|
|
270
277
|
set isPickable(value: boolean);
|
|
271
278
|
get receiveShadows(): boolean;
|
|
@@ -1119,7 +1126,8 @@ export declare const BlurPostProcess: new () => never;
|
|
|
1119
1126
|
|
|
1120
1127
|
export declare class Bone {
|
|
1121
1128
|
private _enabled;
|
|
1122
|
-
readonly name: string;
|
|
1123
1129
|
constructor(_name?: string, _skeleton?: Skeleton);
|
|
1124
1130
|
getName(): string;
|
|
1131
|
+
readonly name: string;
|
|
1132
|
+
readonly parent: Bone | null;
|
|
1125
1133
|
constructor(_name?: string, _skeleton?: Skeleton);
|
|
1126
1134
|
getName(): string;
|
|
1127
1135
|
getSkeleton(): Skeleton;
|
|
1128
1136
|
setPosition(position: Vector3, space?: number): this;
|
|
1129
1137
|
setRotationQuaternion(rotation: Quaternion, space?: number): this;
|
|
@@ -1244,6 +1252,12 @@ export declare abstract class Camera extends Node_2 {
|
|
|
1244
1252
|
private _orthoTop;
|
|
1245
1253
|
protected constructor(name: string, scene?: Scene);
|
|
1246
1254
|
getClassName(): string;
|
|
1255
|
+
/**
|
|
1256
|
+
* Babylon.js `Camera.resetViewHistory()` invalidates temporal history owned by
|
|
1257
|
+
* every render pass using this camera. Lite's TAA/history state is owned by
|
|
1258
|
+
* independently-created frame-graph tasks, with no camera-to-task registry.
|
|
1259
|
+
*/
|
|
1260
|
+
resetViewHistory(): never;
|
|
1247
1261
|
get fov(): number;
|
|
1248
1262
|
set fov(value: number);
|
|
1249
1263
|
get minZ(): number;
|
|
@@ -1326,6 +1340,15 @@ declare interface CellSize {
|
|
|
1326
1340
|
height: number;
|
|
1327
1341
|
}
|
|
1328
1342
|
|
|
1343
|
+
export declare enum ChannelMask {
|
|
1344
|
+
R = 1,
|
|
1345
|
+
G = 2,
|
|
1346
|
+
B = 4,
|
|
1347
|
+
A = 8,
|
|
1348
|
+
RGB = 7,
|
|
1349
|
+
RGBA = 15
|
|
1350
|
+
}
|
|
1351
|
+
|
|
1329
1352
|
export declare interface CharacterShapeOptions {
|
|
1330
1353
|
shape?: PhysicsShape;
|
|
1331
1354
|
capsuleHeight?: number;
|
|
@@ -1353,6 +1376,8 @@ export declare class CircleEase extends EasingFunction {
|
|
|
1353
1376
|
easeInCore(gradient: number): number;
|
|
1354
1377
|
}
|
|
1355
1378
|
|
|
1379
|
+
export declare function _ClampGpuSortKeyBits(keyBits: number): number;
|
|
1380
|
+
|
|
1356
1381
|
/**
|
|
1357
1382
|
* Babylon.js `ClusteredLightContainer` — a `Light` that renders a large set of
|
|
1358
1383
|
* point lights through a clustered / forward+ system.
|
|
@@ -1496,6 +1521,18 @@ export declare type ComputeBindingMapping = Record<string, ComputeBindingLocatio
|
|
|
1496
1521
|
|
|
1497
1522
|
declare type ComputeEffect = ComputeShader_2;
|
|
1498
1523
|
|
|
1524
|
+
export declare function _ComputeGpuSortDepthCoefficients(_world: ArrayLike<number>, _view: ArrayLike<number>, _depthSign: number, _cameraPosition: ArrayLike<number> | null, _out: Float32Array, _offset: number, _worldOffset?: number): void;
|
|
1525
|
+
|
|
1526
|
+
export declare function _ComputeGpuSortDepthRange(_coefficients: ArrayLike<number>, _setCount: number, _boundsMin: ArrayLike<number>, _boundsMax: ArrayLike<number>, _result?: {
|
|
1527
|
+
min: number;
|
|
1528
|
+
max: number;
|
|
1529
|
+
}): {
|
|
1530
|
+
min: number;
|
|
1531
|
+
max: number;
|
|
1532
|
+
};
|
|
1533
|
+
|
|
1534
|
+
export declare function _ComputeGpuSortKeyScale(depthMin: number, depthMax: number, keyBits: number): number;
|
|
1535
|
+
|
|
1499
1536
|
/** Babylon.js `ComputeOverlayCssTransform` — HTML overlay interaction is unsupported by the compat layer. */
|
|
1500
1537
|
export declare function ComputeOverlayCssTransform(): never;
|
|
1501
1538
|
|
|
@@ -1579,6 +1616,7 @@ export declare const Constants: {
|
|
|
1579
1616
|
readonly TEXTURE_TRILINEAR_SAMPLINGMODE: 3;
|
|
1580
1617
|
readonly TEXTUREFORMAT_RGBA: 5;
|
|
1581
1618
|
readonly TEXTURETYPE_UNSIGNED_BYTE: 0;
|
|
1619
|
+
readonly TEXTURE_CREATIONFLAG_SAMPLED_DATA_ONLY: 2;
|
|
1582
1620
|
readonly BUFFER_CREATIONFLAG_READ: 1;
|
|
1583
1621
|
readonly BUFFER_CREATIONFLAG_WRITE: 2;
|
|
1584
1622
|
readonly BUFFER_CREATIONFLAG_READWRITE: 3;
|
|
@@ -1817,6 +1855,8 @@ declare interface DashedLinesBuilderOptions {
|
|
|
1817
1855
|
|
|
1818
1856
|
export declare type DataArray = number[] | ArrayBufferLike | ArrayBufferView;
|
|
1819
1857
|
|
|
1858
|
+
export declare function _DecodeGpuSortSogMean(value: number): number;
|
|
1859
|
+
|
|
1820
1860
|
declare interface DefaultEnvironmentOptions {
|
|
1821
1861
|
createSkybox?: boolean;
|
|
1822
1862
|
createGround?: boolean;
|
|
@@ -1924,6 +1964,8 @@ export declare type DitheredTileFadeMesh = Mesh | InstancedMesh;
|
|
|
1924
1964
|
|
|
1925
1965
|
export declare type DitheredTileFadeSupportedMaterial = StandardMaterial | PBRMaterial;
|
|
1926
1966
|
|
|
1967
|
+
export declare function DivideTexturesAsync(_name: string, a: ITextureProcessOperand, b: ITextureProcessOperand, _scene: Scene, _outputColorSpace?: TextureColorSpace, outputChannelMask?: ChannelMask, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
|
|
1968
|
+
|
|
1927
1969
|
/** Babylon.js drag move payload. */
|
|
1928
1970
|
declare type DragEvent_2 = {
|
|
1929
1971
|
delta: Vector3;
|
|
@@ -2462,6 +2504,34 @@ export declare class GaussianSplattingGpuPickingMaterialPlugin extends MaterialP
|
|
|
2462
2504
|
static EncodeIdToColor(id: number): [number, number, number];
|
|
2463
2505
|
constructor(material: GaussianSplattingMaterial, _maxPartCount?: number);
|
|
2464
2506
|
}
|
|
2465
2507
|
|
|
2508
|
+
export declare class GaussianSplattingGpuSorter {
|
|
2509
|
+
static IsSupported(_engine: AbstractEngine): boolean;
|
|
2510
|
+
static GetMaxSupportedSplatCount(_engine: AbstractEngine): number;
|
|
2511
|
+
static LoadDependenciesAsync(): Promise<void>;
|
|
2512
|
+
constructor(_engine: AbstractEngine, _name?: string, _keyBits?: number);
|
|
2513
|
+
get activeCount(): number;
|
|
2514
|
+
get paddedCount(): number;
|
|
2515
|
+
get keyBits(): number;
|
|
2516
|
+
setSource(_source: IGaussianSplattingGpuSortSource): never;
|
|
2517
|
+
setPartMatrices(_matrices: ReadonlyArray<GaussianSplattingGpuSortMatrix> | ArrayLike<number> | null): never;
|
|
2518
|
+
setIntervals(_intervals: ArrayLike<number> | null): never;
|
|
2519
|
+
createOutput(): never;
|
|
2520
|
+
sort(_output: GaussianSplattingGpuSortOutput, _worldMatrix: GaussianSplattingGpuSortMatrix, _viewMatrix: GaussianSplattingGpuSortMatrix, _options?: IGaussianSplattingGpuSortOptions): never;
|
|
2521
|
+
dispose(): void;
|
|
2522
|
+
}
|
|
2523
|
+
|
|
2524
|
+
export declare type GaussianSplattingGpuSortMatrix = Pick<Matrix, "m">;
|
|
2525
|
+
|
|
2526
|
+
export declare class GaussianSplattingGpuSortOutput {
|
|
2527
|
+
constructor(_engine?: AbstractEngine, _label?: string);
|
|
2528
|
+
get buffer(): null;
|
|
2529
|
+
get vertexBuffers(): readonly never[];
|
|
2530
|
+
get paddedCount(): number;
|
|
2531
|
+
get instanceCount(): number;
|
|
2532
|
+
get buffersVersion(): number;
|
|
2533
|
+
dispose(): void;
|
|
2534
|
+
}
|
|
2535
|
+
|
|
2466
2536
|
export declare class GaussianSplattingMaterial extends PushMaterial {
|
|
2467
2537
|
constructor(name: string, scene?: Scene);
|
|
2468
2538
|
clone(_name: string): GaussianSplattingMaterial;
|
|
2469
2539
|
}
|
|
@@ -2472,7 +2542,14 @@ export declare const GaussianSplattingMaxPartCount = 128;
|
|
|
2472
2542
|
* Babylon.js `GaussianSplattingMesh`. Derives from `TransformNode` so the loaded
|
|
2473
2543
|
* cloud's `position` / `rotation` / `scaling` proxy onto the Lite splat node.
|
|
2474
2544
|
*/
|
|
2475
|
-
export declare class GaussianSplattingMesh extends TransformNode {
|
|
2476
2545
|
/**
|
|
2546
|
+
export declare class GaussianSplattingMesh extends TransformNode {
|
|
2547
|
+
private static _useGpuSort;
|
|
2548
|
+
static GpuSortMinFrameInterval: number;
|
|
2549
|
+
static get UseGpuSort(): boolean;
|
|
2550
|
+
static set UseGpuSort(value: boolean);
|
|
2477
2551
|
private _useGpuSort;
|
|
2552
|
+
get useGpuSort(): boolean | null;
|
|
2553
|
+
set useGpuSort(value: boolean | null);
|
|
2554
|
+
/**
|
|
2478
2555
|
* Babylon.js `gs.safeOrbitCameraLimits` — safe-orbit camera limits parsed from the source
|
|
2479
2556
|
* file's metadata (Adobe safe-orbit extension), or `null` when the file carries none.
|
|
2480
2557
|
*
|
|
@@ -2640,8 +2717,14 @@ export declare class GeospatialClippingBehavior {
|
|
|
2640
2717
|
/** Babylon.js `GetElementPixelFromUv` — HTML overlay raycast interaction is unsupported by the compat layer. */
|
|
2641
2718
|
export declare function GetElementPixelFromUv(): never;
|
|
2642
2719
|
|
|
2720
|
+
export declare function GetGaussianSplattingGpuSorterMaxSplatCount(engine: AbstractEngine): number;
|
|
2721
|
+
|
|
2643
2722
|
export declare function GetGaussianSplattingMaxPartCount(engine: AbstractEngine): number;
|
|
2644
2723
|
|
|
2724
|
+
export declare function _GetGpuSortPaddedCount(activeCount: number): number;
|
|
2725
|
+
|
|
2726
|
+
export declare function _GetGpuSortPassCount(keyBits: number): number;
|
|
2727
|
+
|
|
2645
2728
|
export declare function _GetPackedShBytesPerSplat(shDegree: number): number;
|
|
2646
2729
|
|
|
2647
2730
|
export declare function GetPartIndexVaryingDeclaration(shaderLanguage: ShaderLanguage): string;
|
|
@@ -2711,6 +2794,8 @@ export declare namespace GLTF1 {
|
|
|
2711
2794
|
export declare namespace GLTF2 {
|
|
2712
2795
|
export {
|
|
2713
2796
|
OpenPBRMaterialLoadingAdapter,
|
|
2797
|
+
KHR_materials_scatter,
|
|
2798
|
+
RegisterKHR_materials_scatter,
|
|
2714
2799
|
ParseDebugLogTemplate,
|
|
2715
2800
|
getMappingForFullOperationName,
|
|
2716
2801
|
getMappingForDeclaration,
|
|
@@ -3312,6 +3397,29 @@ export declare interface IGaussianSplattingDebugOptions {
|
|
|
3312
3397
|
shOrder4: boolean;
|
|
3313
3398
|
}
|
|
3314
3399
|
|
|
3400
|
+
export declare interface IGaussianSplattingGpuSortOptions {
|
|
3401
|
+
rightHanded?: boolean;
|
|
3402
|
+
cameraPosition?: ArrayLike<number>;
|
|
3403
|
+
depthRange?: {
|
|
3404
|
+
min: number;
|
|
3405
|
+
max: number;
|
|
3406
|
+
};
|
|
3407
|
+
}
|
|
3408
|
+
|
|
3409
|
+
export declare interface IGaussianSplattingGpuSortSource {
|
|
3410
|
+
vertexCount: number;
|
|
3411
|
+
textureWidth: number;
|
|
3412
|
+
centersTexture: BaseTexture;
|
|
3413
|
+
sog?: {
|
|
3414
|
+
meansHighTexture: BaseTexture;
|
|
3415
|
+
meansMin: ArrayLike<number>;
|
|
3416
|
+
meansMax: ArrayLike<number>;
|
|
3417
|
+
};
|
|
3418
|
+
partIndicesTexture?: BaseTexture;
|
|
3419
|
+
boundsMin?: ArrayLike<number>;
|
|
3420
|
+
boundsMax?: ArrayLike<number>;
|
|
3421
|
+
}
|
|
3422
|
+
|
|
3315
3423
|
export declare interface IGaussianSplattingStreamingPart {
|
|
3316
3424
|
readonly proxy: GaussianSplattingPartProxyMesh;
|
|
3317
3425
|
readonly partIndex: number;
|
|
@@ -3632,6 +3740,9 @@ export declare interface ISceneLoaderProgressEvent {
|
|
|
3632
3740
|
total: number;
|
|
3633
3741
|
}
|
|
3634
3742
|
|
|
3743
|
+
/** Babylon.js internal polyfill-state query. Compat never installs the unsupported polyfill. */
|
|
3744
|
+
export declare function _IsHtmlInCanvasPolyfillInstalled(): boolean;
|
|
3745
|
+
|
|
3635
3746
|
/** Babylon.js `IsHtmlInCanvasSupportedNatively` — the HTML-in-canvas feature is unsupported by the compat layer. */
|
|
3636
3747
|
export declare function IsHtmlInCanvasSupportedNatively(): never;
|
|
3637
3748
|
|
|
@@ -3777,6 +3888,20 @@ export declare interface IStreamingSoundPlayOptions {
|
|
|
3777
3888
|
volume?: number;
|
|
3778
3889
|
}
|
|
3779
3890
|
|
|
3891
|
+
export declare interface ITextureProcessOperand {
|
|
3892
|
+
texture: BaseTexture | null;
|
|
3893
|
+
factor?: Color4;
|
|
3894
|
+
channel?: TextureChannel;
|
|
3895
|
+
colorSpace?: TextureColorSpace;
|
|
3896
|
+
dispose?: () => void;
|
|
3897
|
+
}
|
|
3898
|
+
|
|
3899
|
+
export declare interface ITextureProcessorOutputOptions {
|
|
3900
|
+
textureType?: number;
|
|
3901
|
+
samplingMode?: number;
|
|
3902
|
+
generateMipMaps?: boolean;
|
|
3903
|
+
}
|
|
3904
|
+
|
|
3780
3905
|
export declare interface IThinMeshBlendingPostProcessOptions extends IMeshBlendConfiguration {
|
|
3781
3906
|
[key: string]: unknown;
|
|
3782
3907
|
}
|
|
@@ -3827,6 +3952,19 @@ export declare interface IWheelEvent extends IMouseEvent {
|
|
|
3827
3952
|
wheelDelta?: number;
|
|
3828
3953
|
}
|
|
3829
3954
|
|
|
3955
|
+
export declare class KHR_materials_scatter {
|
|
3956
|
+
readonly name = "KHR_materials_scatter";
|
|
3957
|
+
enabled: boolean;
|
|
3958
|
+
order: number;
|
|
3959
|
+
constructor(loader?: {
|
|
3960
|
+
isExtensionUsed?(name: string): boolean;
|
|
3961
|
+
});
|
|
3962
|
+
dispose(): void;
|
|
3963
|
+
loadMaterialPropertiesAsync(_context: string, material: {
|
|
3964
|
+
extensions?: Record<string, unknown>;
|
|
3965
|
+
}, _babylonMaterial: unknown): Promise<void> | null;
|
|
3966
|
+
}
|
|
3967
|
+
|
|
3830
3968
|
/**
|
|
3831
3969
|
* Babylon.js `KHR_materials_variants` extension helpers. Mirrors the static
|
|
3832
3970
|
* surface ported code calls (`SelectVariant` / `GetAvailableVariants` / `Reset`)
|
|
@@ -4176,6 +4314,8 @@ export { MaxTintMagnitude }
|
|
|
4176
4314
|
export declare class Mesh extends AbstractMesh {
|
|
4177
4315
|
constructor(name: string, sceneOrLite?: Scene | Mesh_2, scene?: Scene);
|
|
4178
4316
|
getClassName(): string;
|
|
4179
4317
|
private _morphTargetManager;
|
|
4318
|
+
private readonly _ownedMorphTargetManagers;
|
|
4319
|
+
private _retainMorphTargetManagerOwnership;
|
|
4180
4320
|
/**
|
|
4181
4321
|
* Babylon.js `mesh.morphTargetManager`. Babylon Lite builds morph GPU data via
|
|
4182
4322
|
* `createMorphTargets` and stores it on the Lite mesh; the compat manager is
|
|
@@ -4183,8 +4323,7 @@ export declare class Mesh extends AbstractMesh {
|
|
|
4183
4323
|
* CPU geometry exists) and assigns it onto the Lite mesh before registration.
|
|
4184
4324
|
*/
|
|
4185
4325
|
get morphTargetManager(): MorphTargetManager | null;
|
|
4186
|
-
set morphTargetManager(value: MorphTargetManager | null);
|
|
4187
|
-
/** Legacy `Mesh.CreateSphere(name, segments, diameter, scene)`. */
|
|
4326
|
+
set morphTargetManager(value: MorphTargetManager | null);
|
|
4188
4327
|
/** Legacy `Mesh.CreateSphere(name, segments, diameter, scene)`. */
|
|
4189
4328
|
static CreateSphere(name: string, segments: number, diameter: number, scene: Scene): Mesh;
|
|
4190
4329
|
/** Legacy `Mesh.CreateBox(name, size, scene)`. */
|
|
4191
4330
|
static CreateBox(name: string, size: number, scene: Scene): Mesh;
|
|
@@ -4375,16 +4514,16 @@ export declare class MorphTarget {
|
|
|
4375
4514
|
/** Babylon.js `MorphTarget.setNormals(data)` — absolute target normals. */
|
|
4376
4515
|
setNormals(data: Float32Array | number[] | null): void;
|
|
4377
4516
|
/** Babylon.js `MorphTarget.getNormals()`. */
|
|
4378
|
-
getNormals(): Float32Array | null;
|
|
4379
|
-
}
|
|
4517
|
+
getNormals(): Float32Array | null;
|
|
4380
4518
|
|
|
4381
4519
|
/** Babylon.js `MorphTargetManager` — owns a mesh's morph targets (Babylon Lite supports up to 4). */
|
|
4382
4520
|
export declare class MorphTargetManager {
|
|
4383
4521
|
private readonly _targets;
|
|
4384
|
-
constructor(_scene?: Scene);
|
|
4385
|
-
get numTargets(): number;
|
|
4522
|
+
constructor(_scene?: Scene);
|
|
4386
4523
|
get numTargets(): number;
|
|
4387
4524
|
getTarget(index: number): MorphTarget;
|
|
4388
4525
|
/** Babylon.js `MorphTargetManager.addTarget(target)`. */
|
|
4389
|
-
addTarget(target: MorphTarget): void;
|
|
4526
|
+
addTarget(target: MorphTarget): void;
|
|
4390
4527
|
/** Babylon.js `MorphTargetManager.dispose()` — release this manager's morph-resource claim. */
|
|
4528
|
+
dispose(): void;
|
|
4529
|
+
}
|
|
4391
4530
|
|
|
4392
4531
|
export declare class MultiMaterial {
|
|
4393
4532
|
constructor();
|
|
@@ -4394,6 +4533,8 @@ export declare class MultiPointerScaleBehavior {
|
|
|
4394
4533
|
constructor();
|
|
4395
4534
|
}
|
|
4396
4535
|
|
|
4536
|
+
export declare function MultiScatterToSingleScatterAlbedoAsync(_name: string, input: ITextureProcessOperand, _scene: Scene, aniso?: number, scale?: ITextureProcessOperand): Promise<ITextureProcessOperand>;
|
|
4537
|
+
|
|
4397
4538
|
declare abstract class Node_2 {
|
|
4398
4539
|
name: string;
|
|
4399
4540
|
/** String id. Defaults to the name (Babylon.js parity). */
|
|
@@ -4609,6 +4750,12 @@ export declare class OutlineRenderer {
|
|
|
4609
4750
|
constructor();
|
|
4610
4751
|
}
|
|
4611
4752
|
|
|
4753
|
+
export declare function _PackGpuSortIntervals(intervals: ArrayLike<number>, vertexCount: number): {
|
|
4754
|
+
data: Uint32Array;
|
|
4755
|
+
count: number;
|
|
4756
|
+
total: number;
|
|
4757
|
+
};
|
|
4758
|
+
|
|
4612
4759
|
export declare function PackMeshBlendingTag(groupId: number, radiusClass: MeshBlendingRadiusClass): number;
|
|
4613
4760
|
|
|
4614
4761
|
export declare class ParticleHelper {
|
|
@@ -4633,6 +4780,7 @@ export declare class ParticleSystem {
|
|
|
4633
4780
|
private _texture;
|
|
4634
4781
|
private _billboardScheduled;
|
|
4635
4782
|
private _billboardOwnedBySet;
|
|
4783
|
+
private _started;
|
|
4636
4784
|
/**
|
|
4637
4785
|
* Babylon.js `new ParticleSystem(name, capacity, scene)`. The imperative
|
|
4638
4786
|
* construction API (emitters, over-lifetime gradients, `minEmitBox`, a
|
|
@@ -4670,6 +4818,8 @@ export declare class ParticleSystem {
|
|
|
4670
4818
|
animate(preWarmOnly?: boolean): void;
|
|
4671
4819
|
/** Babylon.js `ParticleSystem.stop()` — stop emission; live particles drain. Forwards to Lite `stopParticleSystem`. */
|
|
4672
4820
|
stop(): void;
|
|
4821
|
+
/** Babylon.js `ParticleSystem.isStarted()` — whether the system is currently emitting. */
|
|
4822
|
+
isStarted(): boolean;
|
|
4673
4823
|
/** Babylon.js `ParticleSystem.dispose()` — stop the system. */
|
|
4674
4824
|
dispose(): void;
|
|
4675
4825
|
/**
|
|
4676
4826
|
* Schedule the one-time billboard build. Deferred to engine start (via the
|
|
@@ -5711,6 +5861,8 @@ export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]):
|
|
|
5711
5861
|
/** Babylon.js pure-module registration hook. */
|
|
5712
5862
|
export declare function RegisterImageProcessingConfiguration(): void;
|
|
5713
5863
|
|
|
5864
|
+
export declare function RegisterKHR_materials_scatter(): void;
|
|
5865
|
+
|
|
5714
5866
|
export declare function RegisterMeshBlendingPostProcessBlock(): never;
|
|
5715
5867
|
|
|
5716
5868
|
/** Babylon.js 9.29 node-render-graph registration function. */
|
|
@@ -5867,6 +6019,10 @@ export declare class Scene extends AbstractScene {
|
|
|
5867
6019
|
/** Babylon.js fog-mode c
|
|
5868
6020
|
/** Babylon.js `scene.getAnimationGroupByName(name)` — first loaded animation group with a matching name, else `null`. */
|
|
5869
6021
|
getAnimationGroupByName(name: string): AnimationGroup | null;
|
|
5870
6022
|
get animatables(): Animatable_2[];
|
|
6023
|
+
/** Babylon.js `scene.skeletons` — loader-produced skeletons currently used by scene meshes. */
|
|
6024
|
+
get skeletons(): Skeleton[];
|
|
6025
|
+
/** Babylon.js `scene.particleSystems` — registered Lite node-particle systems in scene order. */
|
|
6026
|
+
get particleSystems(): ParticleSystem[];
|
|
5871
6027
|
private readonly _engine;
|
|
5872
6028
|
private _activeCamera;
|
|
5873
6029
|
cameraToUseForPointers: Camera | null;
|
|
@@ -5888,9 +6044,16 @@ export declare class Scene extends AbstractScene {
|
|
|
5888
6044
|
/** Babylon.js fog-mode c
|
|
5889
6045
|
private readonly _pendingTextures;
|
|
5890
6046
|
private readonly _pendingGroundBakes;
|
|
5891
6047
|
private readonly _pendingMorphBuilds;
|
|
6048
|
+
private readonly _ownedMorphTargetManagers;
|
|
5892
6049
|
private _materialPluginsRequested;
|
|
5893
6050
|
private readonly _pendingMaterialPluginReconciliations;
|
|
5894
|
-
private readonly _runningAnimatables;
|
|
5895
6051
|
private readonly _animationGroupCache;
|
|
5896
6052
|
private _ambientColor;
|
|
6053
|
+
private readonly _runningAnimatables;
|
|
5897
6054
|
private readonly _animationGroupCache;
|
|
6055
|
+
private readonly _skeletonCache;
|
|
6056
|
+
private readonly _skeletons;
|
|
6057
|
+
private readonly _particleSystemCache;
|
|
6058
|
+
private readonly _particleSystems;
|
|
6059
|
+
private readonly _retiredParticleSystems;
|
|
6060
|
+
private _disposed;
|
|
5898
6061
|
private _ambientColor;
|
|
5899
6062
|
private _environmentIntensity;
|
|
5900
6063
|
private _imageProcessingConfiguration;
|
|
5901
6064
|
/** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
|
|
5902
6065
|
readonly uniqueId: number;
|
|
@@ -6201,6 +6364,8 @@ export declare class SineEase extends EasingFunction {
|
|
|
6201
6364
|
easeInCore(gradient: number): number;
|
|
6202
6365
|
}
|
|
6203
6366
|
|
|
6367
|
+
export declare function SingleScatterToMultiScatterAlbedoAsync(_name: string, input: ITextureProcessOperand, _scene: Scene, aniso?: number, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
|
|
6368
|
+
|
|
6204
6369
|
export declare class SixDofDragBehavior {
|
|
6205
6370
|
constructor();
|
|
6206
6371
|
}
|
|
@@ -6222,6 +6387,10 @@ export declare class Skeleton {
|
|
|
6222
6387
|
readonly id: string;
|
|
6223
6388
|
readonly bones: Bone[];
|
|
6224
6389
|
constructor(_name?: string, _id?: string, _scene?: Scene);
|
|
6225
6390
|
getBoneIndexByName(name: string): number;
|
|
6226
6391
|
getBoneByName(name: string): Bone | null;
|
|
6392
|
+
/** Babylon.js `Skeleton.returnToRest()` — clear every compat bone override. */
|
|
6393
|
+
returnToRest(): void;
|
|
6394
|
+
/** Babylon.js `Skeleton.prepare()` — Lite keeps loaded/evaluated bone matrices ready, so no additional bake is needed. */
|
|
6395
|
+
prepare(_dontCheckFrameId?: boolean): void;
|
|
6227
6396
|
}
|
|
6228
6397
|
|
|
6229
6398
|
export declare class SliderConstraint extends PhysicsConstraint {
|
|
@@ -6856,6 +7025,19 @@ export declare class Texture extends BaseTexture {
|
|
|
6856
7025
|
static LoadAsync(url: string, scene: Scene): Promise<Texture>;
|
|
6857
7026
|
}
|
|
6858
7027
|
|
|
7028
|
+
export declare enum TextureChannel {
|
|
7029
|
+
RGBA = 0,
|
|
7030
|
+
R = 1,
|
|
7031
|
+
G = 2,
|
|
7032
|
+
B = 3,
|
|
7033
|
+
A = 4
|
|
7034
|
+
}
|
|
7035
|
+
|
|
7036
|
+
export declare enum TextureColorSpace {
|
|
7037
|
+
Linear = 0,
|
|
7038
|
+
SRGB = 1
|
|
7039
|
+
}
|
|
7040
|
+
|
|
6859
7041
|
declare interface TextureLike {
|
|
6860
7042
|
_lite?: Texture2D;
|
|
6861
7043
|
whenReadyAsync?(): Promise<void>;
|
|
@@ -6921,6 +7103,11 @@ declare interface ThinSpriteLike {
|
|
|
6921
7103
|
isVisible: boolean;
|
|
6922
7104
|
}
|
|
6923
7105
|
|
|
7106
|
+
export declare function ThinWalledScatterWeightsAsync(_name: string, transmission: ITextureProcessOperand, scatter: ITextureProcessOperand, _scene: Scene): Promise<{
|
|
7107
|
+
transmission: ITextureProcessOperand;
|
|
7108
|
+
subsurface: ITextureProcessOperand;
|
|
7109
|
+
}>;
|
|
7110
|
+
|
|
6924
7111
|
export declare const ToDegrees: number;
|
|
6925
7112
|
|
|
6926
7113
|
/** Babylon.js-compatible `Tools` helpers (the small, pure subset). */
|
|
@@ -6954,22 +7141,29 @@ export declare function transformCoordinates(vector: Vector3, transformation: Ma
|
|
|
6954
7141
|
* Wraps a Lite scene node (`_node`): either a standalone Lite transform node, or
|
|
6955
7142
|
* (for meshes) the Lite mesh itself, which also carries the transform.
|
|
6956
7143
|
*/
|
|
6957
|
-
export declare class TransformNode extends Node_2 {
|
|
6958
7144
|
physicsBody: PhysicsBody | null;
|
|
6959
7145
|
constructor(name: string, scene?: Scene, liteNode?: SceneNode);
|
|
7146
|
+
export declare class TransformNode extends Node_2 {
|
|
6960
7147
|
physicsBody: PhysicsBody | null;
|
|
7148
|
+
private _rotation;
|
|
7149
|
+
private _rotationBinding;
|
|
7150
|
+
private _rotationQuaternion;
|
|
7151
|
+
private _rotationQuaternionBinding?;
|
|
7152
|
+
private _nativeRotationVersion;
|
|
7153
|
+
private readonly _nativeRotationValues;
|
|
7154
|
+
private _isSyncingRotationFromNative;
|
|
7155
|
+
private _sceneDisposeObserver?;
|
|
6961
7156
|
constructor(name: string, scene?: Scene, liteNode?: SceneNode);
|
|
6962
7157
|
getClassName(): string;
|
|
6963
7158
|
get position(): Vector3;
|
|
6964
7159
|
set position(value: Vector3);
|
|
6965
7160
|
get rotation(): Vector3;
|
|
6966
7161
|
set rotation(value: Vector3);
|
|
6967
7162
|
get scaling(): Vector3;
|
|
6968
|
-
set scaling(value: Vector3);
|
|
6969
7163
|
/**
|
|
6970
|
-
|
|
6971
|
-
|
|
6972
|
-
* quaternion), so this reads/writes that quaternion. Returns `null` until
|
|
6973
|
-
* explicitly assigned, matching Babylon.js's euler-by-default convention.
|
|
6974
|
-
*/
|
|
7164
|
+
set scaling(value: Vector3);
|
|
7165
|
+
/** Babylon.js `rotationQuaternion`, kept live while Lite receives translated component writes. */
|
|
6975
7166
|
get rotationQuaternion(): Quaternion | null;
|
|
6976
7167
|
set rotationQuaternion(value: Quaternion | null);
|
|
6977
|
-
|
|
7168
|
+
private _applyEulerRotation;
|
|
7169
|
+
private _applyQuaternionRotation;
|
|
7170
|
+
private _markNativeRotationSynced;
|
|
7171
|
+
private _syncRotationFromNative;
|
|
6978
7172
|
/**
|
|
6979
7173
|
* Babylon.js `getChildTransformNodes(directDescendantsOnly?, predicate?)` — the descendants that are transform nodes
|
|
6980
7174
|
* (meshes included). As in Babylon.js, `predicate` is called on every evaluated descendant.
|
|
6981
7175
|
*/
|
|
@@ -6980,10 +7174,16 @@ export declare class TransformNode extends Node_2 {
|
|
|
6980
7174
|
physicsBody: PhysicsBody
|
|
6981
7175
|
* setter, which keeps the local transform and lets the world move.
|
|
6982
7176
|
*/
|
|
6983
7177
|
setParent(parent: Node_2 | null): TransformNode;
|
|
6984
|
-
protected _applyParent(parent: Node_2 | null): void;
|
|
7178
|
+
protected _applyParent(parent: Node_2 | null): void;
|
|
6985
7179
|
private _bindRotationSceneDisposal;
|
|
7180
|
+
protected _retireFromScene(): void;
|
|
7181
|
+
}
|
|
6986
7182
|
|
|
6987
7183
|
export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
|
|
6988
7184
|
|
|
7185
|
+
export declare function TransmissionFractionAsync(_name: string, a: ITextureProcessOperand, b: ITextureProcessOperand, _scene: Scene, _outputColorSpace?: TextureColorSpace, outputChannelMask?: ChannelMask, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
|
|
7186
|
+
|
|
7187
|
+
export declare function TransmissionScatterToSingleScatterAlbedoAsync(_name: string, transmissionColor: ITextureProcessOperand, transmissionScatter: ITextureProcessOperand, _scene: Scene, _outputColorSpace?: TextureColorSpace, outputChannelMask?: ChannelMask, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
|
|
7188
|
+
|
|
6989
7189
|
export declare type TrianglePickingPredicate = (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray, i0: number, i1: number, i2: number) => boolean;
|
|
6990
7190
|
|
|
6991
7191
|
/** Minimum Babylon.js UniformBuffer surface needed to author compute bindings. */
|