@babylonjs/lite-compat 1.29.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
@@ -787,7 +792,7 @@ export declare class ArcRotateCamera extends Camera {
787
792
  constructor(name: stri
788
793
  /** Right-drag panning sensitivity in pixels-per-unit (LOWER = faster pan). Babylon default 50. */
789
794
  get panningSensibility(): number;
790
795
  set panningSensibility(value: number);
791
- attachControl(canvas: HTMLCanvasElement, _noPreventDefault?: boolean): void;
796
+ attachControl(canvas: HTMLCanvasElement, noPreventDefault?: boolean): void;
792
797
 
793
798
  export declare class AssetContainer {
794
799
  constructor(lite: AssetContainer_2);
795
800
  get animationGroups(): AnimationGroup_2[];
@@ -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,43 @@ 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
+
1705
+ /** Babylon.js drag move payload. */
1706
+ declare type DragEvent_2 = {
1707
+ delta: Vector3;
1708
+ dragPlanePoint: Vector3;
1709
+ dragPlaneNormal: Vector3;
1710
+ dragDistance: number;
1711
+ pointerId: number;
1712
+ pointerInfo: PointerInfo | null;
1713
+ };
1714
+ export { DragEvent_2 as DragEvent }
1715
+
1716
+ /** Babylon.js drag start/end payload. */
1717
+ export declare type DragStartEndEvent = Pick<DragEvent_2, "dragPlanePoint" | "pointerId" | "pointerInfo">;
1718
+
1675
1719
  /**
1676
1720
  * Babylon.js `DynamicTexture` — a canvas-backed texture. Draw into
1677
1721
  * `getContext()`, then call `update()` to upload the canvas pixels to the GPU.
@@ -1782,8 +1826,126 @@ export declare class FadeInOutBehavior {
1782
1826
  constructor();
1783
1827
  }
1784
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
+
1785
1910
  export declare class FBXFileLoader {
1786
- 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
1787
1949
  }
1788
1950
 
1789
1951
  export declare class FluidRenderer {
@@ -1837,6 +1999,10 @@ export declare class FollowCamera extends TargetCamera {
1837
1999
  private _follow;
1838
2000
  }
1839
2001
 
2002
+ export declare class FrameGraphMeshBlendingTask {
2003
+ constructor(..._args: unknown[]);
2004
+ }
2005
+
1840
2006
  /** Frames an `ArcRotateCamera` on a target by setting its radius (no zoom tween). */
1841
2007
  export declare class FramingBehavior implements Behavior<ArcRotateCamera> {
1842
2008
  readonly name = "Framing";
@@ -1919,15 +2085,28 @@ export declare class GaussianSplattingMesh extends TransformNode {
1919
2085
  /**
1920
2086
 
1921
2087
  export declare class GaussianSplattingStream {
1922
2088
  constructor(..._args: unknown[]);
2089
+ get minimumResidentSplats(): never;
1923
2090
  }
1924
2091
 
1925
2092
  /** Babylon.js `GaussianSplattingStreamDebugLodSource` — LOD debug source selector (shape-only stub for type parity). */
1926
2093
  export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
1927
2094
 
2095
+ /** Babylon.js finest-LOD splat-count resolution state. */
2096
+ export declare type GaussianSplattingStreamLod0SplatCount = Readonly<{
2097
+ status: "pending";
2098
+ }> | Readonly<{
2099
+ status: "available";
2100
+ count: number;
2101
+ }> | Readonly<{
2102
+ status: "unavailable";
2103
+ }>;
2104
+
1928
2105
  export declare class GeometryBufferRenderer {
1929
2106
  constructor();
1930
2107
  }
1931
2108
 
2109
+ export declare type GeometryRenderingObjectIdProvider = (mesh: AbstractMesh) => number;
2110
+
1932
2111
  /**
1933
2112
  * Babylon.js `GeospatialCamera` — globe-orbit camera anchored to a surface
1934
2113
  * `center` (ECEF), orbiting at `radius` with `yaw`/`pitch`. Wraps Babylon Lite's
@@ -1975,7 +2154,7 @@ export declare function GetPointsCount(..._args: unknown[]): never;
1975
2154
  */
1976
2155
  export declare function GetSupportedSimultaneousLights(scene: Scene, maxSimultaneousLights: number): number;
1977
2156
 
1978
- export declare function GetWhiteBalanceMatrix(_temperatureKelvin: number, _tint: number): Float32Array | number[];
2157
+ export declare function GetWhiteBalanceMatrix(temperatureKelvin: number, tint: number): Float32Array;
1979
2158
 
1980
2159
  /** Shared base for compat gizmos (Babylon.js `Gizmo`). */
1981
2160
  declare abstract class GizmoBase {
1982
2161
  protected constructor(layer: UtilityLayerRenderer);
@@ -2025,7 +2204,82 @@ export declare namespace GLTF1 {
2025
2204
 
2026
2205
  export declare namespace GLTF2 {
2027
2206
  export {
2028
- 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
2029
2283
  }
2030
2284
  }
2031
2285
 
@@ -2436,6 +2690,26 @@ export declare interface ICreateTexture2DArrayFromKTX2Options {
2436
2690
  invertY?: boolean;
2437
2691
  }
2438
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
+
2439
2713
  /** Babylon.js `IGaussianSplattingStreamingPart` — a streamed part of a GS compound mesh (shape-only stub for type parity). */
2440
2714
  export declare interface IGaussianSplattingStreamingPart {
2441
2715
  [key: string]: unknown;
@@ -2520,6 +2794,32 @@ declare type ImageSource = ImageBitmap | HTMLImageElement | HTMLCanvasElement |
2520
2794
  export declare interface IMainAudioBusOptions extends Partial<IVolumeAudioOptions> {
2521
2795
  }
2522
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
+
2523
2823
  /** Babylon.js `ImportMeshAsync(source, scene, options?)` — imports an asset into the scene. */
2524
2824
  export declare function ImportMeshAsync(source: string, scene: Scene, options?: ImportMeshOptions): Promise<ImportResult>;
2525
2825
 
@@ -2728,6 +3028,10 @@ export declare interface IStreamingSoundPlayOptions {
2728
3028
  volume?: number;
2729
3029
  }
2730
3030
 
3031
+ export declare interface IThinMeshBlendingPostProcessOptions extends IMeshBlendConfiguration {
3032
+ [key: string]: unknown;
3033
+ }
3034
+
2731
3035
  /** Babylon.js `IUploadImageToTexture2DArrayLayerOptions`. */
2732
3036
  export declare interface IUploadImageToTexture2DArrayLayerOptions {
2733
3037
  /** Store the source with the Y axis inverted (false by default). */
@@ -2907,7 +3211,8 @@ export declare class MainAudioBus extends AbstractAudioBus {
2907
3211
  getClassName():
2908
3212
 
2909
3213
  /** Babylon.js `Material` — base class for all materials. */
2910
3214
  export declare abstract class Material {
2911
- name: string;
3215
+ name: string;
2912
3216
  /** Babylon.js plugin manager, created lazily by the first `MaterialPluginBase`. */
3217
+ pluginManager: MaterialPluginManager | undefined;
2913
3218
  /** Common transparency mode flag (Babylon.js `Material.transparencyMode`). */
2914
3219
  transparencyMode: number | null;
2915
3220
  /** Back-face culling toggle (Babylon.js `Material.backFaceCulling`). */
@@ -2939,6 +3244,75 @@ export declare class MaterialGreasedLineDefines {
2939
3244
  constructor(..._args: unknown[]);
2940
3245
  }
2941
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;
2942
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);
2943
3269
  protected _enable(enable: boolean): void;
2944
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);
2945
3317
  getPlugin<T = MaterialPluginBase>(name: string): T | null;
3318
+ }
3319
+
2946
3320
  export declare class Matrix {
2947
3321
  readonly m: Float32Array;
2948
3322
  constructor();
@@ -2998,7 +3372,7 @@ export declare class Matrix {
2998
3372
  markAsUpdated(): this;
2999
3373
  }
3000
3374
 
3001
- export declare const MaxTintMagnitude = 150;
3375
+ export { MaxTintMagnitude }
3002
3376
 
3003
3377
  /** Babylon.js `Mesh` — a concrete renderable mesh with geometry. */
3004
3378
  export declare class Mesh extends AbstractMesh {
@@ -3071,6 +3445,47 @@ export declare class Mesh extends AbstractMesh {
3071
3445
  static MergeMeshes(meshes: (Mesh | null | undefined)[], disposeSource?: boolean, allow32BitsIndices?: boolean, meshSubclass?: Mesh, subdivideWithSubMeshes?: boolean, multiMultiMaterials?: boolean): Mesh | null;
3072
3446
  }
3073
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
+
3074
3489
  /** Babylon.js `MeshBuilder` — factory namespace for primitive meshes. */
3075
3490
  export declare const MeshBuilder: {
3076
3491
  CreateBox(name: string, options: BoxOptions, scene: Scene): Mesh;
@@ -3135,7 +3550,7 @@ export declare class MeshoptCompression {
3135
3550
  static get Default(): MeshoptCompression;
3136
3551
  }
3137
3552
 
3138
- export declare const MinTemperatureKelvin: number;
3553
+ export { MinTemperatureKelvin }
3139
3554
 
3140
3555
  export declare class MirrorTexture {
3141
3556
  constructor();
@@ -3204,6 +3619,14 @@ declare abstract class Node_2 {
3204
3619
  * descendant nodes that are meshes (all descendants by default).
3205
3620
  */
3206
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
+ };
3207
3630
  isEnabled(checkAncestors?: boolean): boolean;
3208
3631
  setEnabled(value: boolean): void;
3209
3632
  isDisposed(): boolean;
3210
3633
  dispose(doNotRecurse?: boolean): void;
@@ -3282,6 +3705,10 @@ export declare class NodeParticleSystemSet {
3282
3705
  dispose(): void;
3283
3706
  }
3284
3707
 
3708
+ export declare class NodeRenderGraphMeshBlendingPostProcessBlock {
3709
+ constructor(..._args: unknown[]);
3710
+ }
3711
+
3285
3712
  /**
3286
3713
  * Babylon.js's `NullEngine` — a headless engine with no GPU device, used to run
3287
3714
  * scene logic (animations, observables, physics stepping, frame timing) without
@@ -3362,6 +3789,8 @@ export declare class OutlineRenderer {
3362
3789
  constructor();
3363
3790
  }
3364
3791
 
3792
+ export declare function PackMeshBlendingTag(groupId: number, radiusClass: MeshBlendingRadiusClass): number;
3793
+
3365
3794
  export declare class ParticleHelper {
3366
3795
  constructor();
3367
3796
  }
@@ -4104,6 +4533,10 @@ export declare class PositionGizmo extends GizmoBase {
4104
4533
  private _attached;
4105
4534
  private _xGizmo;
4106
4535
  private _yGizmo;
4107
4536
  private _zGizmo;
4537
+ private _dragSubscriptions;
4538
+ readonly onDragStartObservable: Observable<DragStartEndEvent>;
4539
+ readonly onDragObservable: Observable<DragEvent_2>;
4540
+ readonly onDragEndObservable: Observable<DragStartEndEvent>;
4108
4541
  constructor(layer: UtilityLayerRenderer);
4109
4542
  /** Babylon.js `PositionGizmo.xGizmo/yGizmo/zGizmo` — the per-axis drag sub-gizmos.
4110
4543
  * Exposed so callers can toggle interactivity per axis (e.g. `xGizmo.isEnabled = false`
@@ -4338,6 +4771,19 @@ export declare class ReflectionProbe {
4338
4771
  */
4339
4772
  export declare function RegisterAbstractEngineTextureLoaders(): void;
4340
4773
 
4774
+ /**
4775
+ * Babylon.js registers built-in loader factories through a global plugin
4776
+ * registry. Compat dispatches its supported formats directly, so registration
4777
+ * is already complete and this compatibility hook is intentionally idempotent.
4778
+ */
4779
+ export declare function registerBuiltInLoaders(): void;
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
+
4341
4787
  export declare function RegisterFluidRenderer(): void;
4342
4788
 
4343
4789
  export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
@@ -4345,6 +4791,8 @@ export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]):
4345
4791
  /** Babylon.js pure-module registration hook. */
4346
4792
  export declare function RegisterImageProcessingConfiguration(): void;
4347
4793
 
4794
+ export declare function RegisterMeshBlendingPostProcessBlock(): never;
4795
+
4348
4796
  export declare function RegisterOpenpbrMaterial(): void;
4349
4797
 
4350
4798
  export declare function RegisterUSDFileLoader(): never;
@@ -4358,6 +4806,10 @@ export declare class RotationGizmo extends GizmoBase {
4358
4806
  private _attached;
4359
4807
  private _xGizmo;
4360
4808
  private _yGizmo;
4361
4809
  private _zGizmo;
4810
+ private _dragSubscriptions;
4811
+ readonly onDragStartObservable: Observable<DragStartEndEvent>;
4812
+ readonly onDragObservable: Observable<DragEvent_2>;
4813
+ readonly onDragEndObservable: Observable<DragStartEndEvent>;
4362
4814
  constructor(layer: UtilityLayerRenderer);
4363
4815
  /** Babylon.js `RotationGizmo.xGizmo/yGizmo/zGizmo` — the per-plane rotation sub-gizmos. */
4364
4816
  get xGizmo(): PlaneRotationGizmo;
@@ -4445,6 +4897,8 @@ export declare class Scene extends AbstractScene {
4445
4897
  /** Babylon.js fog-mode c
4446
4898
  private readonly _pendingTextures;
4447
4899
  private readonly _pendingGroundBakes;
4448
4900
  private readonly _pendingMorphBuilds;
4901
+ private _materialPluginsRequested;
4902
+ private readonly _pendingMaterialPluginReconciliations;
4449
4903
  private readonly _runningAnimatables;
4450
4904
  private readonly _animationGroupCache;
4451
4905
  private _ambientColor;
4452
4906
  private _environmentIntensity;
@@ -4722,6 +5176,15 @@ export declare class ShadowGenerator {
4722
5176
  private _removeCaster;
4723
5177
  private _scheduleCasterSync;
4724
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;
4725
5188
  /** Babylon.js `getShadowMap()` — returns a minimal render-list holder for parity. */
4726
5189
  getShadowMap(): {
4727
5190
  renderList: AbstractMesh[];
@@ -5027,7 +5490,17 @@ export declare class SSAO2RenderingPipeline {
5027
5490
  constructor();
5028
5491
  }
5029
5492
 
5030
- export declare class StandardMaterial extends PushMaterial {
5031
5493
  constructor(name: string, scene?: Scene);
5494
+ export declare class StandardMaterial extends PushMaterial {
5032
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;
5033
5506
  getClassName(): string;
5034
5507
  get diffuseColor(): Color3;
5035
5508
  set diffuseColor(value: Color3);
@@ -5218,7 +5691,7 @@ export declare class TargetCamera extends Camera {
5218
5691
  constructor(name: string,
5219
5692
 
5220
5693
  declare type TaskState = "init" | "running" | "done" | "error";
5221
5694
 
5222
- export declare function TemperatureTintToXyz(_temperatureKelvin: number, _tint: number): Vector3;
5695
+ export declare function TemperatureTintToXyz(temperatureKelvin: number, tint: number): Vector3;
5223
5696
 
5224
5697
  export declare class Texture extends BaseTexture {
5225
5698
  private readonly _ready;
@@ -5284,6 +5757,10 @@ export declare class ThinFSR1UpscalePostProcess {
5284
5757
  constructor();
5285
5758
  }
5286
5759
 
5760
+ export declare class ThinMeshBlendingPostProcess {
5761
+ constructor(..._args: unknown[]);
5762
+ }
5763
+
5287
5764
  /**
5288
5765
  * Babylon.js `ThinSprite` — a lightweight pixel-space sprite drawn by a
5289
5766
  * {@link SpriteRenderer}. Position is in screen pixels (origin bottom-left, +Y
@@ -5388,6 +5865,8 @@ export declare class UniversalCamera extends FreeCamera {
5388
5865
  getClassName(): string;
5389
5866
  }
5390
5867
 
5868
+ export declare function UnpackMeshBlendingTag(tag: number): IMeshBlendingTag;
5869
+
5391
5870
  /** Throw a {@link LiteCompatError} for an unsupported API. */
5392
5871
  export declare function unsupported(api: string, detail?: string): never;
5393
5872
 
@@ -5461,6 +5940,10 @@ export declare class UtilityLayerRenderer {
5461
5940
  private _registered;
5462
5941
  constructor(scene: Scene);
5463
5942
  dispose(): void;
5464
5943
  }
5465
5944
 
5945
+ export declare function ValidateFlowGraph(_flowGraph: unknown): IFlowGraphValidationResult;
5946
+
5947
+ export declare function ValidateFlowGraphWithBlockList(_flowGraph: unknown, _allKnownBlocks: unknown[]): IFlowGraphValidationResult;
5948
+
5466
5949
  /** Compares `target[propertyPath]` against a value with an operator. */
5467
5950
  export declare class ValueCondition extends Condition {
5468
5951
  private readonly _target;