@babylonjs/lite-compat 1.30.0-preview → 1.31.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 +32 -31
- package/index.d.ts +450 -8
- package/index.js +807 -74
- 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 +130 -2
- 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
|
@@ -7,7 +7,9 @@ import { EngineContext } from '@babylonjs/lite';
|
|
|
7
7
|
import { EngineOptions } from '@babylonjs/lite';
|
|
8
8
|
import { IridescenceProps } from '@babylonjs/lite';
|
|
9
9
|
import { LineMaterial } from '@babylonjs/lite';
|
|
10
|
+
import { MaxTintMagnitude } from '@babylonjs/lite';
|
|
10
11
|
import { Mesh as Mesh_2 } from '@babylonjs/lite';
|
|
12
|
+
import { MinTemperatureKelvin } from '@babylonjs/lite';
|
|
11
13
|
import { PhysicsMassProperties } from '@babylonjs/lite';
|
|
12
14
|
import { PhysicsShape as PhysicsShape_2 } from '@babylonjs/lite';
|
|
13
15
|
import { PhysicsShapeParameters } from '@babylonjs/lite';
|
|
@@ -236,6 +238,7 @@ export declare abstract class AbstractEngine {
|
|
|
236
238
|
* visibility, and shadow-receipt. Concrete meshes derive from this.
|
|
237
239
|
*/
|
|
238
240
|
export declare class AbstractMesh extends TransformNode {
|
|
239
241
|
private _material;
|
|
242
|
+
private _meshBlendingTag;
|
|
240
243
|
protected _visible: boolean;
|
|
241
244
|
constructor(name: string, lite: Mesh_2, scene?: Scene);
|
|
242
245
|
getClassName(): string;
|
|
243
246
|
get material(): CompatMaterial | null;
|
|
@@ -246,6 +249,8 @@ export declare class AbstractMesh extends TransformNode {
|
|
|
246
249
|
private _material;
|
|
247
250
|
set isPickable(value: boolean);
|
|
248
251
|
get receiveShadows(): boolean;
|
|
249
252
|
set receiveShadows(value: boolean);
|
|
253
|
+
get meshBlendingTag(): number;
|
|
254
|
+
set meshBlendingTag(value: number);
|
|
250
255
|
protected _onEffectiveEnabledStateChanged(enabled: boolean): void;
|
|
251
256
|
/**
|
|
252
257
|
* Babylon.js `mesh.getBoundingInfo()` — the mesh's AABB. `minimum`/`maximum`
|
|
253
258
|
* are the local-space bounds; the returned `BoundingInfo`'s world members
|
|
@@ -1429,6 +1434,8 @@ export declare function CreateCylinder(name: string, options: CylinderOptions, s
|
|
|
1429
1434
|
/** Babylon.js `CreateDashedLines(name, options, scene)` (linesBuilder). */
|
|
1430
1435
|
export declare function CreateDashedLines(name: string, options: DashedLinesBuilderOptions, scene?: Scene | null): LinesMesh;
|
|
1431
1436
|
|
|
1437
|
+
export declare function CreateDefaultMeshBlendRadiusDefinitions(): MeshBlendRadiusDefinitions;
|
|
1438
|
+
|
|
1432
1439
|
/** Babylon.js `CreateDisc(name, options, scene)` (discBuilder). */
|
|
1433
1440
|
export declare function CreateDisc(name: string, options: object, scene: Scene): Mesh;
|
|
1434
1441
|
|
|
@@ -1671,6 +1678,29 @@ export declare class DistanceConstraint extends PhysicsConstraint {
|
|
|
1671
1678
|
constructor(maxDistance: number, scene: Scene);
|
|
1672
1679
|
}
|
|
1673
1680
|
|
|
1681
|
+
export declare class DitheredTileFadeMaterialPlugin extends MaterialPluginBase {
|
|
1682
|
+
static readonly Name = "DitheredTileFade";
|
|
1674
1683
|
constructor(material: DitheredTileFadeSupportedMaterial);
|
|
1684
|
+
static GetOrCreate(_material: DitheredTileFadeSupportedMaterial): DitheredTileFadeMaterialPlugin;
|
|
1685
|
+
get isEnabled(): boolean;
|
|
1686
|
+
set isEnabled(_value: boolean);
|
|
1687
|
+
setFadeBounds(_mesh: DitheredTileFadeMesh, _lowerBound: number, _upperBound: number): void;
|
|
1688
|
+
setFadeLowerBound(_mesh: DitheredTileFadeMesh, _lowerBound: number): void;
|
|
1689
|
+
setFadeUpperBound(_mesh: DitheredTileFadeMesh, _upperBound: number): void;
|
|
1690
|
+
getFadeBoundsToRef(_mesh: DitheredTileFadeMesh, _result: IDitheredTileFadeBounds): boolean;
|
|
1691
|
+
resetFade(_mesh: DitheredTileFadeMesh): void;
|
|
1692
|
+
setThinInstanceFadeBounds(_mesh: Mesh, _index: number, _lowerBound: number, _upperBound: number, _refresh?: boolean): void;
|
|
1693
|
+
setThinInstanceFadeBoundsBuffer(_mesh: Mesh, _bounds: Float32Array): void;
|
|
1694
|
+
commitThinInstanceFadeBounds(_mesh: Mesh): void;
|
|
1695
|
+
resetThinInstanceFade(_mesh: Mesh, _index: number, _refresh?: boolean): void;
|
|
1696
|
+
reset(): void;
|
|
1697
|
+
copyToMaterial(_material: DitheredTileFadeSupportedMaterial): DitheredTileFadeMaterialPlugin;
|
|
1698
|
+
getClassName(): string;
|
|
1699
|
+
}
|
|
1700
|
+
|
|
1701
|
+
export declare type DitheredTileFadeMesh = Mesh | InstancedMesh;
|
|
1702
|
+
|
|
1703
|
+
export declare type DitheredTileFadeSupportedMaterial = StandardMaterial | PBRMaterial;
|
|
1704
|
+
|
|
1675
1705
|
/** Babylon.js drag move payload. */
|
|
1676
1706
|
declare type DragEvent_2 = {
|
|
1677
1707
|
delta: Vector3;
|
|
@@ -1796,8 +1826,126 @@ export declare class FadeInOutBehavior {
|
|
|
1796
1826
|
constructor();
|
|
1797
1827
|
}
|
|
1798
1828
|
|
|
1829
|
+
export declare class FBXConstraintBehavior {
|
|
1830
|
+
readonly constraint: FBXConstraintData;
|
|
1831
|
+
readonly name: string;
|
|
1832
|
+
attachedNode: TransformNode | null;
|
|
1833
|
+
enabled: boolean;
|
|
1834
|
+
constructor(constraint: FBXConstraintData, _options: FBXConstraintBehaviorOptions);
|
|
1835
|
+
init(): void;
|
|
1836
|
+
attach(_target: TransformNode): void;
|
|
1837
|
+
detach(): void;
|
|
1838
|
+
captureBase(): void;
|
|
1839
|
+
restoreBase(): void;
|
|
1840
|
+
dependencyNodes(): Array<Node_2 | null>;
|
|
1841
|
+
evaluate(): void;
|
|
1842
|
+
}
|
|
1843
|
+
|
|
1844
|
+
export declare interface FBXConstraintBehaviorOptions {
|
|
1845
|
+
root: TransformNode;
|
|
1846
|
+
targets: FBXConstraintBehaviorTarget[];
|
|
1847
|
+
upNode: TransformNode | null;
|
|
1848
|
+
sceneUp: Vector3;
|
|
1849
|
+
}
|
|
1850
|
+
|
|
1851
|
+
export declare interface FBXConstraintBehaviorTarget {
|
|
1852
|
+
node: TransformNode;
|
|
1853
|
+
weight: number;
|
|
1854
|
+
offset: Matrix;
|
|
1855
|
+
}
|
|
1856
|
+
|
|
1857
|
+
declare type FBXConstraintBoolean3 = [boolean, boolean, boolean];
|
|
1858
|
+
|
|
1859
|
+
export declare interface FBXConstraintData {
|
|
1860
|
+
id: number;
|
|
1861
|
+
name: string;
|
|
1862
|
+
type: FBXConstraintType;
|
|
1863
|
+
typeName: string;
|
|
1864
|
+
nodeId?: number;
|
|
1865
|
+
targets: FBXConstraintTarget[];
|
|
1866
|
+
weight: number;
|
|
1867
|
+
active: boolean;
|
|
1868
|
+
affectTranslation: FBXConstraintBoolean3;
|
|
1869
|
+
affectRotation: FBXConstraintBoolean3;
|
|
1870
|
+
affectScale: FBXConstraintBoolean3;
|
|
1871
|
+
offsetTranslation: FBXConstraintVector3;
|
|
1872
|
+
offsetRotation: FBXConstraintVector3;
|
|
1873
|
+
offsetScale: FBXConstraintVector3;
|
|
1874
|
+
aimVector: FBXConstraintVector3;
|
|
1875
|
+
upVector: FBXConstraintVector3;
|
|
1876
|
+
worldUpVector: FBXConstraintVector3;
|
|
1877
|
+
worldUpType: number;
|
|
1878
|
+
worldUpNodeId?: number;
|
|
1879
|
+
ikFirstJointId?: number;
|
|
1880
|
+
ikEndJointId?: number;
|
|
1881
|
+
ikEffectorId?: number;
|
|
1882
|
+
ikPoleVector: FBXConstraintVector3;
|
|
1883
|
+
}
|
|
1884
|
+
|
|
1885
|
+
export declare class FBXConstraintSolver {
|
|
1886
|
+
private constructor();
|
|
1887
|
+
static Get(_scene: Scene): FBXConstraintSolver | undefined;
|
|
1888
|
+
static GetOrCreate(_scene: Scene): FBXConstraintSolver;
|
|
1889
|
+
get constraints(): readonly FBXConstraintBehavior[];
|
|
1890
|
+
get cyclicConstraints(): readonly FBXConstraintBehavior[];
|
|
1891
|
+
register(_behavior: FBXConstraintBehavior): void;
|
|
1892
|
+
unregister(_behavior: FBXConstraintBehavior): void;
|
|
1893
|
+
invalidateOrder(): void;
|
|
1894
|
+
beginFrame(): void;
|
|
1895
|
+
solve(): void;
|
|
1896
|
+
}
|
|
1897
|
+
|
|
1898
|
+
export declare interface FBXConstraintTarget {
|
|
1899
|
+
modelId: number;
|
|
1900
|
+
weight: number;
|
|
1901
|
+
offsetTranslation: FBXConstraintVector3;
|
|
1902
|
+
offsetRotation: FBXConstraintVector3;
|
|
1903
|
+
offsetScale: FBXConstraintVector3;
|
|
1904
|
+
}
|
|
1905
|
+
|
|
1906
|
+
export declare type FBXConstraintType = "aim" | "parent" | "position" | "rotation" | "scale" | "singleChainIK" | "unknown";
|
|
1907
|
+
|
|
1908
|
+
declare type FBXConstraintVector3 = [number, number, number];
|
|
1909
|
+
|
|
1799
1910
|
export declare class FBXFileLoader {
|
|
1800
|
-
constructor();
|
|
1911
|
+
constructor(_options?: Partial<FBXFileLoaderOptions>);
|
|
1912
|
+
}
|
|
1913
|
+
|
|
1914
|
+
export declare const FBXFileLoaderMetadata: {
|
|
1915
|
+
readonly name: "fbx";
|
|
1916
|
+
readonly extensions: {
|
|
1917
|
+
readonly ".fbx": {
|
|
1918
|
+
readonly isBinary: true;
|
|
1919
|
+
};
|
|
1920
|
+
};
|
|
1921
|
+
};
|
|
1922
|
+
|
|
1923
|
+
export declare interface FBXFileLoaderOptions {
|
|
1924
|
+
preset?: "compatible" | "full";
|
|
1925
|
+
normalMapCoordinateSystem?: FBXNormalMapCoordinateSystem;
|
|
1926
|
+
materials?: "auto" | "standard" | "pbr";
|
|
1927
|
+
unitScale?: "preserve" | "meters" | number;
|
|
1928
|
+
shareGeometry?: boolean;
|
|
1929
|
+
onWarning?: (warning: FBXLoaderWarning) => void;
|
|
1930
|
+
nurbsSubdivision?: number;
|
|
1931
|
+
curves?: "lines" | "skip";
|
|
1932
|
+
constraints?: "apply" | "metadata";
|
|
1933
|
+
rebaseAnimations?: boolean;
|
|
1934
|
+
attachCamerasAndLights?: boolean;
|
|
1935
|
+
}
|
|
1936
|
+
|
|
1937
|
+
export declare interface FBXLoaderWarning {
|
|
1938
|
+
source: "scene" | "model" | "geometry" | "skin" | "rig" | "animation" | "blendShape" | "camera" | "light";
|
|
1939
|
+
message: string;
|
|
1940
|
+
objectName?: string;
|
|
1941
|
+
details?: unknown;
|
|
1942
|
+
}
|
|
1943
|
+
|
|
1944
|
+
export declare type FBXNormalMapCoordinateSystem = "y-up" | "y-down";
|
|
1945
|
+
|
|
1946
|
+
export declare enum FlowGraphValidationSeverity {
|
|
1947
|
+
Error = 0,
|
|
1948
|
+
Warning = 1
|
|
1801
1949
|
}
|
|
1802
1950
|
|
|
1803
1951
|
export declare class FluidRenderer {
|
|
@@ -1851,6 +1999,10 @@ export declare class FollowCamera extends TargetCamera {
|
|
|
1851
1999
|
private _follow;
|
|
1852
2000
|
}
|
|
1853
2001
|
|
|
2002
|
+
export declare class FrameGraphMeshBlendingTask {
|
|
2003
|
+
constructor(..._args: unknown[]);
|
|
2004
|
+
}
|
|
2005
|
+
|
|
1854
2006
|
/** Frames an `ArcRotateCamera` on a target by setting its radius (no zoom tween). */
|
|
1855
2007
|
export declare class FramingBehavior implements Behavior<ArcRotateCamera> {
|
|
1856
2008
|
readonly name = "Framing";
|
|
@@ -1933,6 +2085,7 @@ export declare class GaussianSplattingMesh extends TransformNode {
|
|
|
1933
2085
|
/**
|
|
1934
2086
|
|
|
1935
2087
|
export declare class GaussianSplattingStream {
|
|
1936
2088
|
constructor(..._args: unknown[]);
|
|
2089
|
+
get minimumResidentSplats(): never;
|
|
1937
2090
|
}
|
|
1938
2091
|
|
|
1939
2092
|
/** Babylon.js `GaussianSplattingStreamDebugLodSource` — LOD debug source selector (shape-only stub for type parity). */
|
|
@@ -2001,7 +2154,7 @@ export declare function GetPointsCount(..._args: unknown[]): never;
|
|
|
2001
2154
|
*/
|
|
2002
2155
|
export declare function GetSupportedSimultaneousLights(scene: Scene, maxSimultaneousLights: number): number;
|
|
2003
2156
|
|
|
2004
|
-
export declare function GetWhiteBalanceMatrix(
|
|
2157
|
+
export declare function GetWhiteBalanceMatrix(temperatureKelvin: number, tint: number): Float32Array;
|
|
2005
2158
|
|
|
2006
2159
|
/** Shared base for compat gizmos (Babylon.js `Gizmo`). */
|
|
2007
2160
|
declare abstract class GizmoBase {
|
|
2008
2161
|
protected constructor(layer: UtilityLayerRenderer);
|
|
@@ -2051,7 +2204,82 @@ export declare namespace GLTF1 {
|
|
|
2051
2204
|
|
|
2052
2205
|
export declare namespace GLTF2 {
|
|
2053
2206
|
export {
|
|
2054
|
-
OpenPBRMaterialLoadingAdapter
|
|
2207
|
+
OpenPBRMaterialLoadingAdapter,
|
|
2208
|
+
ParseDebugLogTemplate,
|
|
2209
|
+
getMappingForFullOperationName,
|
|
2210
|
+
getMappingForDeclaration,
|
|
2211
|
+
getNoOpMappingForDeclaration,
|
|
2212
|
+
addNewInteractivityFlowGraphMapping,
|
|
2213
|
+
getAllSupportedNativeNodeTypes,
|
|
2214
|
+
HasDefaultInteractivityFlowInput,
|
|
2215
|
+
NormalizeInteractivityEventDataConfiguration,
|
|
2216
|
+
GetInteractivityOperationRegistry,
|
|
2217
|
+
GetInteractivityObjectReference,
|
|
2218
|
+
_NormalizeKHRInteractivityRuntimeValue,
|
|
2219
|
+
_CreateKHRInteractivityRuntimeValueSnapshot,
|
|
2220
|
+
CloneKHRInteractivityGraph,
|
|
2221
|
+
CreateEffectiveKHRInteractivityGraph,
|
|
2222
|
+
CreateKHRInteractivityGraphModel,
|
|
2223
|
+
CreateKHRInteractivityDocument,
|
|
2224
|
+
_CaptureKHRInteractivityRuntimeInputDefaults,
|
|
2225
|
+
CreateKHRInteractivityExportPlan,
|
|
2226
|
+
InitializeInteractivityNodeState,
|
|
2227
|
+
GetInteractivityNodeState,
|
|
2228
|
+
SetInteractivityNodeState,
|
|
2229
|
+
KHRInteractivitySignature,
|
|
2230
|
+
IKHRInteractivityNode,
|
|
2231
|
+
IKHRInteractivityGraph,
|
|
2232
|
+
IKHRInteractivityDeclaration,
|
|
2233
|
+
IKHRInteractivityType,
|
|
2234
|
+
IKHRInteractivityVariable,
|
|
2235
|
+
IKHRInteractivityEvent,
|
|
2236
|
+
IKHRInteractivityOutputSocketReference,
|
|
2237
|
+
IKHRInteractivityOutputFlow,
|
|
2238
|
+
IKHRInteractivityConfiguration,
|
|
2239
|
+
IGLTF,
|
|
2240
|
+
ISerializedFlowGraphConnection,
|
|
2241
|
+
ISerializedFlowGraphBlock,
|
|
2242
|
+
ISerializedFlowGraphContext,
|
|
2243
|
+
ISerializedFlowGraph,
|
|
2244
|
+
IGLTFToFlowGraphMappingObject,
|
|
2245
|
+
IGLTFToFlowGraphMapping,
|
|
2246
|
+
IKHRInteractivityOperationRegistryEntry,
|
|
2247
|
+
IDebugLogTemplateParseResult,
|
|
2248
|
+
KHRInteractivityFlowGraphType,
|
|
2249
|
+
IKHRInteractivityTypeMapping,
|
|
2250
|
+
gltfTypeToBabylonType,
|
|
2251
|
+
IFlowGraphEventReferenceBlockConfiguration,
|
|
2252
|
+
FlowGraphEventReferenceBlock,
|
|
2253
|
+
IFlowGraphGLTFDataProviderBlockConfiguration,
|
|
2254
|
+
FlowGraphGLTFDataProvider,
|
|
2255
|
+
FlowGraphObjectReferenceBlock,
|
|
2256
|
+
IFlowGraphUnsupportedInteractivitySocket,
|
|
2257
|
+
IFlowGraphUnsupportedInteractivityBlockConfiguration,
|
|
2258
|
+
FlowGraphUnsupportedInteractivityBlock,
|
|
2259
|
+
KHR_INTERACTIVITY_SPECIFICATION_COMMIT,
|
|
2260
|
+
KHRInteractivityDeclarationSupport,
|
|
2261
|
+
IKHRInteractivityDiagnostic,
|
|
2262
|
+
IKHRInteractivityDeclarationModel,
|
|
2263
|
+
IKHRInteractivityGraphModel,
|
|
2264
|
+
IKHRInteractivityInputDefaultProvenance,
|
|
2265
|
+
IKHRInteractivityConfigurationProvenance,
|
|
2266
|
+
IKHRInteractivityBlockProvenance,
|
|
2267
|
+
IKHRInteractivitySocketProvenance,
|
|
2268
|
+
IKHRInteractivityGraphProvenance,
|
|
2269
|
+
IKHRInteractivityDocument,
|
|
2270
|
+
KHRInteractivityExportClassification,
|
|
2271
|
+
IKHRInteractivityExportDiagnostic,
|
|
2272
|
+
IKHRInteractivityNodeExportAnalysis,
|
|
2273
|
+
IKHRInteractivityExportAnalysis,
|
|
2274
|
+
KhrInteractivityRootCollection,
|
|
2275
|
+
IKHRInteractivitySerializerContext,
|
|
2276
|
+
IKHRInteractivityExportProvider,
|
|
2277
|
+
IKHRInteractivityExportOptions,
|
|
2278
|
+
KHRInteractivityExportError,
|
|
2279
|
+
KHRInteractivityExportPlan,
|
|
2280
|
+
InteractivityEvent,
|
|
2281
|
+
InteractivityGraphToFlowGraphParser,
|
|
2282
|
+
InteractivityNodeState
|
|
2055
2283
|
}
|
|
2056
2284
|
}
|
|
2057
2285
|
|
|
@@ -2462,6 +2690,26 @@ export declare interface ICreateTexture2DArrayFromKTX2Options {
|
|
|
2462
2690
|
invertY?: boolean;
|
|
2463
2691
|
}
|
|
2464
2692
|
|
|
2693
|
+
export declare interface IDitheredTileFadeBounds {
|
|
2694
|
+
lowerBound: number;
|
|
2695
|
+
upperBound: number;
|
|
2696
|
+
}
|
|
2697
|
+
|
|
2698
|
+
export declare interface IFlowGraphValidationIssue {
|
|
2699
|
+
severity: FlowGraphValidationSeverity;
|
|
2700
|
+
message: string;
|
|
2701
|
+
block?: unknown;
|
|
2702
|
+
connectionName?: string;
|
|
2703
|
+
}
|
|
2704
|
+
|
|
2705
|
+
export declare interface IFlowGraphValidationResult {
|
|
2706
|
+
isValid: boolean;
|
|
2707
|
+
issues: IFlowGraphValidationIssue[];
|
|
2708
|
+
errorCount: number;
|
|
2709
|
+
warningCount: number;
|
|
2710
|
+
issuesByBlock: Map<string, IFlowGraphValidationIssue[]>;
|
|
2711
|
+
}
|
|
2712
|
+
|
|
2465
2713
|
/** Babylon.js `IGaussianSplattingStreamingPart` — a streamed part of a GS compound mesh (shape-only stub for type parity). */
|
|
2466
2714
|
export declare interface IGaussianSplattingStreamingPart {
|
|
2467
2715
|
[key: string]: unknown;
|
|
@@ -2546,6 +2794,32 @@ declare type ImageSource = ImageBitmap | HTMLImageElement | HTMLCanvasElement |
|
|
|
2546
2794
|
export declare interface IMainAudioBusOptions extends Partial<IVolumeAudioOptions> {
|
|
2547
2795
|
}
|
|
2548
2796
|
|
|
2797
|
+
export declare interface IMeshBlendConfiguration {
|
|
2798
|
+
quality?: MeshBlendQuality;
|
|
2799
|
+
radiusClasses?: MeshBlendRadiusDefinitions;
|
|
2800
|
+
slopeFactor?: number;
|
|
2801
|
+
depthType?: MeshBlendDepthType;
|
|
2802
|
+
debugMode?: MeshBlendDebugMode;
|
|
2803
|
+
}
|
|
2804
|
+
|
|
2805
|
+
export declare interface IMeshBlendingPostProcessOptions extends IMeshBlendConfiguration {
|
|
2806
|
+
effectWrapper?: ThinMeshBlendingPostProcess;
|
|
2807
|
+
meshBlendTagTexture: unknown;
|
|
2808
|
+
depthTexture: unknown;
|
|
2809
|
+
baseColorTexture?: unknown;
|
|
2810
|
+
[key: string]: unknown;
|
|
2811
|
+
}
|
|
2812
|
+
|
|
2813
|
+
export declare interface IMeshBlendingTag {
|
|
2814
|
+
groupId: number;
|
|
2815
|
+
radiusClass: MeshBlendingRadiusClass;
|
|
2816
|
+
}
|
|
2817
|
+
|
|
2818
|
+
export declare interface IMeshBlendRadiusDefinition {
|
|
2819
|
+
worldRadius: number;
|
|
2820
|
+
minimumProjectedRadius: number;
|
|
2821
|
+
}
|
|
2822
|
+
|
|
2549
2823
|
/** Babylon.js `ImportMeshAsync(source, scene, options?)` — imports an asset into the scene. */
|
|
2550
2824
|
export declare function ImportMeshAsync(source: string, scene: Scene, options?: ImportMeshOptions): Promise<ImportResult>;
|
|
2551
2825
|
|
|
@@ -2754,6 +3028,10 @@ export declare interface IStreamingSoundPlayOptions {
|
|
|
2754
3028
|
volume?: number;
|
|
2755
3029
|
}
|
|
2756
3030
|
|
|
3031
|
+
export declare interface IThinMeshBlendingPostProcessOptions extends IMeshBlendConfiguration {
|
|
3032
|
+
[key: string]: unknown;
|
|
3033
|
+
}
|
|
3034
|
+
|
|
2757
3035
|
/** Babylon.js `IUploadImageToTexture2DArrayLayerOptions`. */
|
|
2758
3036
|
export declare interface IUploadImageToTexture2DArrayLayerOptions {
|
|
2759
3037
|
/** Store the source with the Y axis inverted (false by default). */
|
|
@@ -2933,7 +3211,8 @@ export declare class MainAudioBus extends AbstractAudioBus {
|
|
|
2933
3211
|
getClassName():
|
|
2934
3212
|
|
|
2935
3213
|
/** Babylon.js `Material` — base class for all materials. */
|
|
2936
3214
|
export declare abstract class Material {
|
|
2937
|
-
name: string;
|
|
3215
|
+
name: string;
|
|
2938
3216
|
/** Babylon.js plugin manager, created lazily by the first `MaterialPluginBase`. */
|
|
3217
|
+
pluginManager: MaterialPluginManager | undefined;
|
|
2939
3218
|
/** Common transparency mode flag (Babylon.js `Material.transparencyMode`). */
|
|
2940
3219
|
transparencyMode: number | null;
|
|
2941
3220
|
/** Back-face culling toggle (Babylon.js `Material.backFaceCulling`). */
|
|
@@ -2965,6 +3244,75 @@ export declare class MaterialGreasedLineDefines {
|
|
|
2965
3244
|
constructor(..._args: unknown[]);
|
|
2966
3245
|
}
|
|
2967
3246
|
|
|
3247
|
+
/**
|
|
3248
|
+
* Babylon.js `MaterialPluginBase` adapter over Lite's opt-in material-plugin
|
|
3249
|
+
* bridge. Subclasses keep the Babylon.js override shape while Lite receives a
|
|
3250
|
+
* plain plugin descriptor.
|
|
3251
|
+
*/
|
|
3252
|
+
export declare class MaterialPluginBase {
|
|
3253
|
+
private _name;
|
|
3254
|
+
private _priority;
|
|
3255
|
+
private _resolveIncludes;
|
|
3256
|
+
readonly markAllDefinesAsDirty: () => void;
|
|
3257
|
+
registerForExtraEvents: boolean;
|
|
3258
|
+
doNotSerialize: boolean;
|
|
3259
|
+
protected readonly _material: Material;
|
|
3260
|
+
protected readonly _pluginManager: MaterialPluginManager;
|
|
3261
|
+
protected readonly _pluginDefineNames?: MaterialPluginDefines;
|
|
2968
3262
|
constructor(material: Material, name: string, priority: number, defines?: MaterialPluginDefines, addToPluginList?: boolean, enable?: boolean, resolveIncludes?: boolean);
|
|
3263
|
+
get name(): string;
|
|
3264
|
+
set name(value: string);
|
|
3265
|
+
get priority(): number;
|
|
3266
|
+
set priority(value: number);
|
|
3267
|
+
get resolveIncludes(): boolean;
|
|
3268
|
+
set resolveIncludes(value: boolean);
|
|
2969
3269
|
protected _enable(enable: boolean): void;
|
|
2970
3270
|
private _assertSupportedExecution;
|
|
3271
|
+
isCompatible(_shaderLanguage: ShaderLanguage): boolean;
|
|
3272
|
+
getCustomCode(_shaderType: string, _shaderLanguage?: ShaderLanguage): MaterialPluginCustomCode | null;
|
|
3273
|
+
isReadyForSubMesh(_defines: object, _scene: Scene, _engine: object, _subMesh: object): boolean;
|
|
3274
|
+
hardBindForSubMesh(_uniformBuffer: object, _scene: Scene, _engine: object, _subMesh: object): void;
|
|
3275
|
+
bindForSubMesh(_uniformBuffer: object, _scene: Scene, _engine: object, _subMesh: object): void;
|
|
3276
|
+
collectDefines(defines: Record<string, {
|
|
3277
|
+
type: string;
|
|
3278
|
+
default: unknown;
|
|
3279
|
+
}>): void;
|
|
3280
|
+
prepareDefinesBeforeAttributes(_defines: object, _scene: Scene, _mesh: AbstractMesh): void;
|
|
3281
|
+
prepareDefines(_defines: object, _scene: Scene, _mesh: AbstractMesh): void;
|
|
3282
|
+
hasTexture(_texture: BaseTexture): boolean;
|
|
3283
|
+
hasRenderTargetTextures(): boolean;
|
|
3284
|
+
fillRenderTargetTextures(_renderTargets: SmartArray<RenderTargetTexture>): void;
|
|
3285
|
+
getActiveTextures(_activeTextures: BaseTexture[]): void;
|
|
3286
|
+
getAnimatables(_animatables: object[]): void;
|
|
3287
|
+
addFallbacks(_defines: object, _fallbacks: object, currentRank: number): number;
|
|
3288
|
+
getSamplers(_samplers: string[]): void;
|
|
3289
|
+
getAttributes(_attributes: string[], _scene: Scene, _mesh: AbstractMesh): void;
|
|
3290
|
+
getUniformBuffersNames(_ubos: string[]): void;
|
|
3291
|
+
getUniforms(_shaderLanguage?: ShaderLanguage): {
|
|
3292
|
+
ubo?: Array<{
|
|
3293
|
+
name: string;
|
|
3294
|
+
size?: number;
|
|
3295
|
+
type?: string;
|
|
3296
|
+
arraySize?: number;
|
|
3297
|
+
}>;
|
|
3298
|
+
vertex?: string;
|
|
3299
|
+
fragment?: string;
|
|
3300
|
+
externalUniforms?: string[];
|
|
3301
|
+
};
|
|
3302
|
+
getClassName(): string;
|
|
3303
|
+
copyTo(plugin: MaterialPluginBase): void;
|
|
3304
|
+
serialize(): Record<string, unknown>;
|
|
3305
|
+
parse(source: Record<string, unknown>, _scene: Scene, _rootUrl: string): void;
|
|
3306
|
+
dispose(_forceDisposeTextures?: boolean): void;
|
|
3307
|
+
}
|
|
3308
|
+
|
|
3309
|
+
export declare type MaterialPluginCustomCode = Record<string, string>;
|
|
3310
|
+
|
|
3311
|
+
export declare type MaterialPluginDefines = Record<string, unknown>;
|
|
3312
|
+
|
|
3313
|
+
/** Babylon.js-shaped manager for the adapter-visible material plugin list. */
|
|
3314
|
+
export declare class MaterialPluginManager {
|
|
3315
|
+
private readonly _plugins;
|
|
3316
|
+
constructor(material: Material);
|
|
2971
3317
|
getPlugin<T = MaterialPluginBase>(name: string): T | null;
|
|
3318
|
+
}
|
|
3319
|
+
|
|
2972
3320
|
export declare class Matrix {
|
|
2973
3321
|
readonly m: Float32Array;
|
|
2974
3322
|
constructor();
|
|
@@ -3024,7 +3372,7 @@ export declare class Matrix {
|
|
|
3024
3372
|
markAsUpdated(): this;
|
|
3025
3373
|
}
|
|
3026
3374
|
|
|
3027
|
-
export
|
|
3375
|
+
export { MaxTintMagnitude }
|
|
3028
3376
|
|
|
3029
3377
|
/** Babylon.js `Mesh` — a concrete renderable mesh with geometry. */
|
|
3030
3378
|
export declare class Mesh extends AbstractMesh {
|
|
@@ -3097,6 +3445,47 @@ export declare class Mesh extends AbstractMesh {
|
|
|
3097
3445
|
static MergeMeshes(meshes: (Mesh | null | undefined)[], disposeSource?: boolean, allow32BitsIndices?: boolean, meshSubclass?: Mesh, subdivideWithSubMeshes?: boolean, multiMultiMaterials?: boolean): Mesh | null;
|
|
3098
3446
|
}
|
|
3099
3447
|
|
|
3448
|
+
export declare enum MeshBlendDebugMode {
|
|
3449
|
+
Off = 0,
|
|
3450
|
+
PackedTag = 1,
|
|
3451
|
+
CandidateDirectionDistance = 2,
|
|
3452
|
+
SeamFade = 3,
|
|
3453
|
+
RejectionReason = 4,
|
|
3454
|
+
StageWork = 5,
|
|
3455
|
+
Continuation = 6,
|
|
3456
|
+
TinyObject = 7,
|
|
3457
|
+
MultiTarget = 8,
|
|
3458
|
+
TargetColor = 9,
|
|
3459
|
+
ShadowAttenuation = 10,
|
|
3460
|
+
ColorInterpolation = 11,
|
|
3461
|
+
WorldPosition = 12
|
|
3462
|
+
}
|
|
3463
|
+
|
|
3464
|
+
export declare enum MeshBlendDepthType {
|
|
3465
|
+
View = 0,
|
|
3466
|
+
Screen = 1
|
|
3467
|
+
}
|
|
3468
|
+
|
|
3469
|
+
export declare class MeshBlendingPostProcess {
|
|
3470
|
+
constructor(..._args: unknown[]);
|
|
3471
|
+
}
|
|
3472
|
+
|
|
3473
|
+
export declare enum MeshBlendingRadiusClass {
|
|
3474
|
+
Small = 0,
|
|
3475
|
+
Medium = 1,
|
|
3476
|
+
Large = 2,
|
|
3477
|
+
ExtraLarge = 3
|
|
3478
|
+
}
|
|
3479
|
+
|
|
3480
|
+
export declare enum MeshBlendQuality {
|
|
3481
|
+
Low = 0,
|
|
3482
|
+
Medium = 1,
|
|
3483
|
+
High = 2,
|
|
3484
|
+
Cinematic = 3
|
|
3485
|
+
}
|
|
3486
|
+
|
|
3487
|
+
export declare type MeshBlendRadiusDefinitions = readonly [IMeshBlendRadiusDefinition, IMeshBlendRadiusDefinition, IMeshBlendRadiusDefinition, IMeshBlendRadiusDefinition];
|
|
3488
|
+
|
|
3100
3489
|
/** Babylon.js `MeshBuilder` — factory namespace for primitive meshes. */
|
|
3101
3490
|
export declare const MeshBuilder: {
|
|
3102
3491
|
CreateBox(name: string, options: BoxOptions, scene: Scene): Mesh;
|
|
@@ -3161,7 +3550,7 @@ export declare class MeshoptCompression {
|
|
|
3161
3550
|
static get Default(): MeshoptCompression;
|
|
3162
3551
|
}
|
|
3163
3552
|
|
|
3164
|
-
export
|
|
3553
|
+
export { MinTemperatureKelvin }
|
|
3165
3554
|
|
|
3166
3555
|
export declare class MirrorTexture {
|
|
3167
3556
|
constructor();
|
|
@@ -3230,6 +3619,14 @@ declare abstract class Node_2 {
|
|
|
3230
3619
|
* descendant nodes that are meshes (all descendants by default).
|
|
3231
3620
|
*/
|
|
3232
3621
|
getChildMeshes(directDescendantsOnly?: boolean, predicate?: (node: Node_2) => boolean): Node_2[];
|
|
3622
|
+
/**
|
|
3623
|
+
* Babylon.js `node.getHierarchyBoundingVectors(includeDescendants?, predicate?)`
|
|
3624
|
+
* — world-space bounds spanning this mesh and eligible descendant meshes.
|
|
3625
|
+
*/
|
|
3626
|
+
getHierarchyBoundingVectors(includeDescendants?: boolean, predicate?: ((mesh: AbstractMesh) => boolean) | null): {
|
|
3627
|
+
min: Vector3;
|
|
3628
|
+
max: Vector3;
|
|
3629
|
+
};
|
|
3233
3630
|
isEnabled(checkAncestors?: boolean): boolean;
|
|
3234
3631
|
setEnabled(value: boolean): void;
|
|
3235
3632
|
isDisposed(): boolean;
|
|
3236
3633
|
dispose(doNotRecurse?: boolean): void;
|
|
@@ -3308,6 +3705,10 @@ export declare class NodeParticleSystemSet {
|
|
|
3308
3705
|
dispose(): void;
|
|
3309
3706
|
}
|
|
3310
3707
|
|
|
3708
|
+
export declare class NodeRenderGraphMeshBlendingPostProcessBlock {
|
|
3709
|
+
constructor(..._args: unknown[]);
|
|
3710
|
+
}
|
|
3711
|
+
|
|
3311
3712
|
/**
|
|
3312
3713
|
* Babylon.js's `NullEngine` — a headless engine with no GPU device, used to run
|
|
3313
3714
|
* scene logic (animations, observables, physics stepping, frame timing) without
|
|
@@ -3388,6 +3789,8 @@ export declare class OutlineRenderer {
|
|
|
3388
3789
|
constructor();
|
|
3389
3790
|
}
|
|
3390
3791
|
|
|
3792
|
+
export declare function PackMeshBlendingTag(groupId: number, radiusClass: MeshBlendingRadiusClass): number;
|
|
3793
|
+
|
|
3391
3794
|
export declare class ParticleHelper {
|
|
3392
3795
|
constructor();
|
|
3393
3796
|
}
|
|
@@ -4375,6 +4778,12 @@ export declare function RegisterAbstractEngineTextureLoaders(): void;
|
|
|
4375
4778
|
*/
|
|
4376
4779
|
export declare function registerBuiltInLoaders(): void;
|
|
4377
4780
|
|
|
4781
|
+
/** Pure-build registration shim; compat wires the Lite array upload directly. */
|
|
4782
|
+
export declare function RegisterEnginesExtensionsEngineTexture2DArrayImageSource(): void;
|
|
4783
|
+
|
|
4784
|
+
/** WebGPU pure-build registration shim; Babylon Lite is WebGPU-only. */
|
|
4785
|
+
export declare function RegisterEnginesWebGPUExtensionsEngineTexture2DArrayImageSource(): void;
|
|
4786
|
+
|
|
4378
4787
|
export declare function RegisterFluidRenderer(): void;
|
|
4379
4788
|
|
|
4380
4789
|
export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
|
|
@@ -4382,6 +4791,8 @@ export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]):
|
|
|
4382
4791
|
/** Babylon.js pure-module registration hook. */
|
|
4383
4792
|
export declare function RegisterImageProcessingConfiguration(): void;
|
|
4384
4793
|
|
|
4794
|
+
export declare function RegisterMeshBlendingPostProcessBlock(): never;
|
|
4795
|
+
|
|
4385
4796
|
export declare function RegisterOpenpbrMaterial(): void;
|
|
4386
4797
|
|
|
4387
4798
|
export declare function RegisterUSDFileLoader(): never;
|
|
@@ -4486,6 +4897,8 @@ export declare class Scene extends AbstractScene {
|
|
|
4486
4897
|
/** Babylon.js fog-mode c
|
|
4487
4898
|
private readonly _pendingTextures;
|
|
4488
4899
|
private readonly _pendingGroundBakes;
|
|
4489
4900
|
private readonly _pendingMorphBuilds;
|
|
4901
|
+
private _materialPluginsRequested;
|
|
4902
|
+
private readonly _pendingMaterialPluginReconciliations;
|
|
4490
4903
|
private readonly _runningAnimatables;
|
|
4491
4904
|
private readonly _animationGroupCache;
|
|
4492
4905
|
private _ambientColor;
|
|
4493
4906
|
private _environmentIntensity;
|
|
@@ -4763,6 +5176,15 @@ export declare class ShadowGenerator {
|
|
|
4763
5176
|
private _removeCaster;
|
|
4764
5177
|
private _scheduleCasterSync;
|
|
4765
5178
|
private _flushCasterSync;
|
|
5179
|
+
/**
|
|
5180
|
+
* The Lite meshes handed to the native shadow task: every requested caster that carries GPU geometry.
|
|
5181
|
+
* The compat loader wraps a model's complete hierarchy as `Mesh`es, so `addShadowCaster(root, true)`
|
|
5182
|
+
* legitimately collects transform-only roots and intermediate nodes into `renderList`, exactly as
|
|
5183
|
+
* Babylon.js does. Those nodes must not reach the native state: the render task cannot build a
|
|
5184
|
+
* renderable for a mesh without `_gpu` (it would throw inside the frame, every frame), and directional
|
|
5185
|
+
* fitting would substitute default bounds for it, distorting the shadow volume.
|
|
5186
|
+
*/
|
|
5187
|
+
private _liteCasterMeshes;
|
|
4766
5188
|
/** Babylon.js `getShadowMap()` — returns a minimal render-list holder for parity. */
|
|
4767
5189
|
getShadowMap(): {
|
|
4768
5190
|
renderList: AbstractMesh[];
|
|
@@ -5068,7 +5490,17 @@ export declare class SSAO2RenderingPipeline {
|
|
|
5068
5490
|
constructor();
|
|
5069
5491
|
}
|
|
5070
5492
|
|
|
5071
|
-
export declare class StandardMaterial extends PushMaterial {
|
|
5072
5493
|
constructor(name: string, scene?: Scene);
|
|
5494
|
+
export declare class StandardMaterial extends PushMaterial {
|
|
5073
5495
|
/** Diffuse colour as the app set it. Kept apart from `_lite.diffuseColor`, which is forced to white
|
|
5496
|
+
* while the material is unlit (see `_syncDiffuse`). */
|
|
5497
|
+
private _diffuse;
|
|
5498
|
+
constructor(name: string, scene?: Scene);
|
|
5499
|
+
/**
|
|
5500
|
+
* Babylon.js shades an unlit StandardMaterial as `emissive + ambient`: the diffuse colour only scales
|
|
5501
|
+
* the accumulated light, and there is none. Lite's unlit path is `emissive × diffuse`, so the usual
|
|
5502
|
+
* "unlit colour" setup (black diffuse, colour in emissive) rendered black. Hand Lite a neutral white
|
|
5503
|
+
* diffuse while lighting is disabled and the app's own colour otherwise.
|
|
5504
|
+
*/
|
|
5505
|
+
private _syncDiffuse;
|
|
5074
5506
|
getClassName(): string;
|
|
5075
5507
|
get diffuseColor(): Color3;
|
|
5076
5508
|
set diffuseColor(value: Color3);
|
|
@@ -5259,7 +5691,7 @@ export declare class TargetCamera extends Camera {
|
|
|
5259
5691
|
constructor(name: string,
|
|
5260
5692
|
|
|
5261
5693
|
declare type TaskState = "init" | "running" | "done" | "error";
|
|
5262
5694
|
|
|
5263
|
-
export declare function TemperatureTintToXyz(
|
|
5695
|
+
export declare function TemperatureTintToXyz(temperatureKelvin: number, tint: number): Vector3;
|
|
5264
5696
|
|
|
5265
5697
|
export declare class Texture extends BaseTexture {
|
|
5266
5698
|
private readonly _ready;
|
|
@@ -5325,6 +5757,10 @@ export declare class ThinFSR1UpscalePostProcess {
|
|
|
5325
5757
|
constructor();
|
|
5326
5758
|
}
|
|
5327
5759
|
|
|
5760
|
+
export declare class ThinMeshBlendingPostProcess {
|
|
5761
|
+
constructor(..._args: unknown[]);
|
|
5762
|
+
}
|
|
5763
|
+
|
|
5328
5764
|
/**
|
|
5329
5765
|
* Babylon.js `ThinSprite` — a lightweight pixel-space sprite drawn by a
|
|
5330
5766
|
* {@link SpriteRenderer}. Position is in screen pixels (origin bottom-left, +Y
|
|
@@ -5429,6 +5865,8 @@ export declare class UniversalCamera extends FreeCamera {
|
|
|
5429
5865
|
getClassName(): string;
|
|
5430
5866
|
}
|
|
5431
5867
|
|
|
5868
|
+
export declare function UnpackMeshBlendingTag(tag: number): IMeshBlendingTag;
|
|
5869
|
+
|
|
5432
5870
|
/** Throw a {@link LiteCompatError} for an unsupported API. */
|
|
5433
5871
|
export declare function unsupported(api: string, detail?: string): never;
|
|
5434
5872
|
|
|
@@ -5502,6 +5940,10 @@ export declare class UtilityLayerRenderer {
|
|
|
5502
5940
|
private _registered;
|
|
5503
5941
|
constructor(scene: Scene);
|
|
5504
5942
|
dispose(): void;
|
|
5505
5943
|
}
|
|
5506
5944
|
|
|
5945
|
+
export declare function ValidateFlowGraph(_flowGraph: unknown): IFlowGraphValidationResult;
|
|
5946
|
+
|
|
5947
|
+
export declare function ValidateFlowGraphWithBlockList(_flowGraph: unknown, _allKnownBlocks: unknown[]): IFlowGraphValidationResult;
|
|
5948
|
+
|
|
5507
5949
|
/** Compares `target[propertyPath]` against a value with an operator. */
|
|
5508
5950
|
export declare class ValueCondition extends Condition {
|
|
5509
5951
|
private readonly _target;
|