@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/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(_temperatureKelvin: number, _tint: number): Float32Array | number[];
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 declare const MaxTintMagnitude = 150;
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 declare const MinTemperatureKelvin: number;
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(_temperatureKelvin: number, _tint: number): Vector3;
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;