@babylonjs/lite-compat 1.38.2-preview → 1.39.1

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 CHANGED
@@ -115,35 +115,35 @@ overloads within a supported area may still be absent.
115
115
 
116
116
  ### `@babylonjs/core`
117
117
 
118
- | Feature area | Status | Notes |
119
- | ------------------------------------------------------------------------------------------------------------------------------------------ | :----: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
120
- | Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`, color temperature/white balance) | ✅ | Includes handedness-correct `LookDirection` matrices/quaternions; `Angle` / `Curve3` / `Path3D` partial |
121
- | Engine (`WebGPUEngine`, `Engine`, `ThinEngine`, `NullEngine`) | ⚡ | async startup + render loop; reverse-depth constructor options/state are exposed over Lite's fixed reverse-Z pipeline; `currentSampleCount` reports the active surface's MSAA count; `beginFrame`/`endFrame`, occlusion queries, engine-wide alpha-to-coverage, and manual `scene.render()` unsupported |
122
- | Compute + GPU buffers (`ComputeShader`, `StorageBuffer`, `UniformBuffer`) | ⚡ | WGSL compute, direct/indirect dispatch, storage buffers, and compute-oriented std140 uniform buffers forward to Lite; shader registries/preprocessing, texture bindings, in-frame immediate dispatch, and Effect-oriented UBO methods remain unsupported |
123
- | Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | `Node.accessibilityTag` forwards description, role, and ARIA metadata to Lite (DOM event handlers remain unsupported); sync `scene.pick` forwards to Lite's CPU triangle picker with thin-instance, predicate, normal, and UV detail; `scene.meshes` + `getMeshBy*`/`getNodeBy*` enumerate every mesh via a canonical wrapper registry; exposure/contrast/tone mapping are forwarded, while white balance and fluid rendering throw because Lite lacks their cross-cutting shader/render-pass subsystems |
124
- | Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`) | ✅ | arc controls include pointer, wheel, touch, and BJS-default Arrow-key input; orthographic bounds and projection-mode switching forward to Lite; fully unconfigured orthographic extents use Lite's `halfHeight` + aspect-ratio derivation rather than Babylon.js render dimensions; XR / device-orientation / stereoscopic rigs unsupported |
125
- | Lights (`Hemispheric`, `Directional`, `Point`, `Spot`, `RectAreaLight`) | ⚡ | rectangular area lights use Lite's native LTC path, including `AreaLightTextureTools` emission preprocessing; Lite is stricter for invalid negative/non-finite emitter dimensions. `ClusteredLightContainer` clusters unshadowed point lights before engine start (⚡ partial), while clustered spot lights remain unsupported |
126
- | Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` uses Lite's native 2–4 cascade CSM |
127
- | Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `clone`, `VertexData`, `Mesh.MergeMeshes`) | ⚡ | `CreateLines`/`CreateLineSystem` support fixed-topology line lists and RGBA point colors; `CreateDashedLines` supports uniform-color dashed line lists; mesh-blending tag helpers and validated mesh metadata forward to native Lite; `MergeMeshes` bakes positions/normals/UVs and rejects unsupported attributes/animation; polygon/extruded-polygon, decal/text/tiled builders, `GreasedLine*` (thick lines), `InstancedMesh`, LOD/edges/outline, and hardware instances unsupported |
128
- | CSG / CSG2 | ✅ | over Lite boolean ops |
129
- | Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`) | ⚡ | over Lite gizmo suite; `isEnabled` toggles per-axis interactivity (display-only when disabled) |
130
- | Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `clone(name)` shares textures with its own renderable; fixed-slot custom WGSL `MaterialPluginBase` injection is supported (`#include`, regex replacement, and custom UBO/sampler hooks are not), while Gaussian-splat visualization plugins, `DitheredTileFadeMaterialPlugin`, BJS-preprocessed `ShaderMaterial`, `MultiMaterial`, `BackgroundMaterial`, and `OpenPBRMaterial` remain unsupported |
131
- | Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `HtmlTexture`, `ExternalTexture`, cube textures) | ⚡ | `ExternalTexture` wraps Lite's native external-video texture; `HDRCubeTexture` routes to native `loadHdrEnvironment`; `RawTexture2DArray` supports raw bytes, image sources/URLs, and single-file KTX2 arrays; `RawTexture3D` supports base-level RGBA8 volumes but not mip generation; `HtmlTexture` forwards native Lite DOM capture/update; `RenderTargetTexture` / `MirrorTexture` unsupported |
132
- | Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | All standard easing classes, including `PowerEase` / `BezierCurveEase`, reuse Lite's native functional curves; `beginAnimation` / `beginDirectAnimation` delegate supported float/vector/quaternion tracks to Lite property animation; unsupported tracks use an explicit compat evaluator; structural groups remain compat-owned; loaded glTF skeletal blending supported; root-motion analysis/controller APIs throw |
133
- | Morph targets (`MorphTarget` / `MorphTargetManager`) | ✅ | over Lite morph targets |
134
- | Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported |
135
- | Behaviors / Actions (`AutoRotation`, `Framing`, `ActionManager`, conditions) | ⚡ | `ActionManager` is manual-dispatch; drag / six-DoF / XR-oriented mesh behaviors throw |
136
- | Misc (`Observable`, `Tools`, `SmartArray`, `Tags`, gradients, `PerformanceMonitor`) | ✅ | |
137
- | Audio V2 (`AudioEngineV2`, `StaticSound`, `StreamingSound`, `AudioBus`, buses/sources/analyzer) | ⚡ | over Lite's AudioV2 port; `MainAudioBus` spatial/analyzer and a second main bus unsupported |
138
- | Physics (`HavokPlugin`, `scene.enablePhysics`/`getPhysicsEngine`, `PhysicsAggregate`/`PhysicsBody`/`PhysicsShape`) | ⚡ | Native Havok V2 forwarding for common body/shape operations, thin-instance bodies, and filtered raycasts with instance indices; unrecognized enum values throw at the compat boundary |
139
- | Particles (`NodeParticleSystemSet` / `ParticleSystemSet` — Node Particle Editor) | ⚡ | NPE snippet/JSON graphs: `Parse`/`ParseFromSnippetAsync` → `buildAsync` → `start`, incl. per-system `set.systems[i]` runtime (`start`/`animate`/`updateSpeed`/`particleTexture`). Imperative classic/GPU/solid `ParticleSystem` construction + programmatic block authoring unsupported |
140
- | Post-processes, layers (glow/highlight), probes, WebXR | ❌ | Babylon.js wrapper classes are not implemented — use native Lite `create*Task` functions, including `createMeshBlendingPostProcessTask` with geometry-renderer tag/depth/albedo outputs |
118
+ | Feature area | Status | Notes |
119
+ | ------------------------------------------------------------------------------------------------------------------------------------------ | :----: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
120
+ | Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`, color temperature/white balance) | ✅ | Includes handedness-correct `LookDirection` matrices/quaternions; `Angle` / `Curve3` / `Path3D` partial |
121
+ | Engine (`WebGPUEngine`, `Engine`, `ThinEngine`, `NullEngine`) | ⚡ | async startup + render loop; reverse-depth constructor options/state are exposed over Lite's fixed reverse-Z pipeline; `currentSampleCount` reports the active surface's MSAA count; `beginFrame`/`endFrame`, occlusion queries, engine-wide alpha-to-coverage, and manual `scene.render()` unsupported |
122
+ | Compute + GPU buffers (`ComputeShader`, `StorageBuffer`, `UniformBuffer`) | ⚡ | WGSL compute, direct/indirect dispatch, storage buffers, and compute-oriented std140 uniform buffers forward to Lite; shader registries/preprocessing, texture bindings, in-frame immediate dispatch, and Effect-oriented UBO methods remain unsupported |
123
+ | Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | `scene.meshes`, loader-produced `scene.skeletons`, and registered NPE `scene.particleSystems` expose stable compat wrappers; sync `scene.pick` forwards to Lite's CPU triangle picker; exposure/contrast/tone mapping are forwarded, while camera-wide temporal-history reset, white balance, and fluid rendering throw because Lite lacks the required cross-cutting ownership/render-pass contracts |
124
+ | Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`) | ✅ | arc controls include pointer, wheel, touch, and BJS-default Arrow-key input; orthographic bounds and projection-mode switching forward to Lite; fully unconfigured orthographic extents use Lite's `halfHeight` + aspect-ratio derivation rather than Babylon.js render dimensions; XR / device-orientation / stereoscopic rigs unsupported |
125
+ | Lights (`Hemispheric`, `Directional`, `Point`, `Spot`, `RectAreaLight`) | ⚡ | rectangular area lights use Lite's native LTC path, including `AreaLightTextureTools` emission preprocessing; Lite is stricter for invalid negative/non-finite emitter dimensions. `ClusteredLightContainer` clusters unshadowed point lights before engine start (⚡ partial), while clustered spot lights remain unsupported |
126
+ | Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` uses Lite's native 2–4 cascade CSM |
127
+ | Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `clone`, `VertexData`, `Mesh.MergeMeshes`) | ⚡ | Gaussian GPU-sort helper math is available and GPU-sort preferences preserve Lite's CPU-worker fallback; explicit GPU sorter/output resource classes still throw. `CreateLines`/`CreateLineSystem`, dashed lines, mesh metadata/blending tags, and common merges work; polygon/decal/text/tiled builders, thick lines, instances, LOD/edges/outline remain unsupported |
128
+ | CSG / CSG2 | ✅ | over Lite boolean ops |
129
+ | Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`) | ⚡ | over Lite gizmo suite; `isEnabled` toggles per-axis interactivity (display-only when disabled) |
130
+ | Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `clone(name)` shares textures with its own renderable; fixed-slot custom WGSL `MaterialPluginBase` injection is supported (`#include`, regex replacement, and custom UBO/sampler hooks are not), while Gaussian-splat visualization plugins, `DitheredTileFadeMaterialPlugin`, BJS-preprocessed `ShaderMaterial`, `MultiMaterial`, `BackgroundMaterial`, and `OpenPBRMaterial` remain unsupported |
131
+ | Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `HtmlTexture`, `ExternalTexture`, cube textures) | ⚡ | New texture/scatter processors support exact constant-only paths; textured operands need BJS's missing procedural render-target pipeline and throw. Arrays, base-level 3D volumes, dynamic/HTML/external textures, and cube environments work; `RenderTargetTexture` / `MirrorTexture` remain unsupported |
132
+ | Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | All standard easing classes, including `PowerEase` / `BezierCurveEase`, reuse Lite's native functional curves; `beginAnimation` / `beginDirectAnimation` delegate supported float/vector/quaternion tracks to Lite property animation; unsupported tracks use an explicit compat evaluator; structural groups remain compat-owned; loaded glTF skeletal blending supported; root-motion analysis/controller APIs throw |
133
+ | Morph targets (`MorphTarget` / `MorphTargetManager`) | ✅ | over Lite morph targets, including named loader-produced targets and live influence writes |
134
+ | Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported |
135
+ | Behaviors / Actions (`AutoRotation`, `Framing`, `ActionManager`, conditions) | ⚡ | `ActionManager` is manual-dispatch; drag / six-DoF / XR-oriented mesh behaviors throw |
136
+ | Misc (`Observable`, `Tools`, `SmartArray`, `Tags`, gradients, `PerformanceMonitor`) | ✅ | |
137
+ | Audio V2 (`AudioEngineV2`, `StaticSound`, `StreamingSound`, `AudioBus`, buses/sources/analyzer) | ⚡ | over Lite's AudioV2 port; `MainAudioBus` spatial/analyzer and a second main bus unsupported |
138
+ | Physics (`HavokPlugin`, `scene.enablePhysics`/`getPhysicsEngine`, `PhysicsAggregate`/`PhysicsBody`/`PhysicsShape`) | ⚡ | Native Havok V2 forwarding for common body/shape operations, thin-instance bodies, and filtered raycasts with instance indices; unrecognized enum values throw at the compat boundary |
139
+ | Particles (`NodeParticleSystemSet` / `ParticleSystemSet` — Node Particle Editor) | ⚡ | NPE snippet/JSON graphs: `Parse`/`ParseFromSnippetAsync` → `buildAsync` → `start`, with stable named systems through both `set.systems` and `scene.particleSystems`, plus `isStarted`; imperative classic/GPU/solid construction and programmatic block authoring remain unsupported |
140
+ | Post-processes, layers (glow/highlight), probes, WebXR | ❌ | Babylon.js wrapper classes are not implemented — use native Lite `create*Task` functions, including `createMeshBlendingPostProcessTask` with geometry-renderer tag/depth/albedo outputs |
141
141
 
142
142
  ### `@babylonjs/loaders`
143
143
 
144
144
  | Feature area | Status | Notes |
145
145
  | ---------------------------------------------------------------------------------------------- | :----: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
146
- | glTF 2.0 (+ extensions), `.babylon` | ✅ | via Lite `loadGltf` / `loadBabylon`; KHR_interactivity assets run through Lite's native flow-graph runtime |
146
+ | glTF 2.0 (+ extensions), `.babylon` | ⚡ | via Lite `loadGltf` / `loadBabylon`; KHR_interactivity assets run through Lite's native flow-graph runtime. `KHR_materials_scatter` resolves but throws because Lite has no scattering prepass/texture-processing subsystem |
147
147
  | `GLTF2.KHR_interactivity` public helpers | ⚡ | pure operation/data normalization and exporter data types are implemented; BJS FlowGraph registry/parser/block/export planning throws with named structural blockers |
148
148
  | glTF 1.0 loader and extensions | ❌ | named `GLTF1` stubs throw; Lite has no legacy parser, extension registry, or material-conversion subsystem |
149
149
  | OpenPBR glTF material adapter | ❌ | exported at root and under `GLTF2`; throws because Lite has no OpenPBR material subsystem |
package/index.d.ts CHANGED
@@ -1126,7 +1126,8 @@ export declare const BlurPostProcess: new () => never;
1126
1126
 
1127
1127
  export declare class Bone {
1128
1128
  private _enabled;
1129
- readonly name: string;
1130
1129
  constructor(_name?: string, _skeleton?: Skeleton);
1131
1130
  getName(): string;
1131
+ readonly name: string;
1132
+ readonly parent: Bone | null;
1132
1133
  constructor(_name?: string, _skeleton?: Skeleton);
1133
1134
  getName(): string;
1134
1135
  getSkeleton(): Skeleton;
1135
1136
  setPosition(position: Vector3, space?: number): this;
1136
1137
  setRotationQuaternion(rotation: Quaternion, space?: number): this;
@@ -1251,6 +1252,12 @@ export declare abstract class Camera extends Node_2 {
1251
1252
  private _orthoTop;
1252
1253
  protected constructor(name: string, scene?: Scene);
1253
1254
  getClassName(): string;
1255
+ /**
1256
+ * Babylon.js `Camera.resetViewHistory()` invalidates temporal history owned by
1257
+ * every render pass using this camera. Lite's TAA/history state is owned by
1258
+ * independently-created frame-graph tasks, with no camera-to-task registry.
1259
+ */
1260
+ resetViewHistory(): never;
1254
1261
  get fov(): number;
1255
1262
  set fov(value: number);
1256
1263
  get minZ(): number;
@@ -1333,6 +1340,15 @@ declare interface CellSize {
1333
1340
  height: number;
1334
1341
  }
1335
1342
 
1343
+ export declare enum ChannelMask {
1344
+ R = 1,
1345
+ G = 2,
1346
+ B = 4,
1347
+ A = 8,
1348
+ RGB = 7,
1349
+ RGBA = 15
1350
+ }
1351
+
1336
1352
  export declare interface CharacterShapeOptions {
1337
1353
  shape?: PhysicsShape;
1338
1354
  capsuleHeight?: number;
@@ -1360,6 +1376,8 @@ export declare class CircleEase extends EasingFunction {
1360
1376
  easeInCore(gradient: number): number;
1361
1377
  }
1362
1378
 
1379
+ export declare function _ClampGpuSortKeyBits(keyBits: number): number;
1380
+
1363
1381
  /**
1364
1382
  * Babylon.js `ClusteredLightContainer` — a `Light` that renders a large set of
1365
1383
  * point lights through a clustered / forward+ system.
@@ -1503,6 +1521,18 @@ export declare type ComputeBindingMapping = Record<string, ComputeBindingLocatio
1503
1521
 
1504
1522
  declare type ComputeEffect = ComputeShader_2;
1505
1523
 
1524
+ export declare function _ComputeGpuSortDepthCoefficients(_world: ArrayLike<number>, _view: ArrayLike<number>, _depthSign: number, _cameraPosition: ArrayLike<number> | null, _out: Float32Array, _offset: number, _worldOffset?: number): void;
1525
+
1526
+ export declare function _ComputeGpuSortDepthRange(_coefficients: ArrayLike<number>, _setCount: number, _boundsMin: ArrayLike<number>, _boundsMax: ArrayLike<number>, _result?: {
1527
+ min: number;
1528
+ max: number;
1529
+ }): {
1530
+ min: number;
1531
+ max: number;
1532
+ };
1533
+
1534
+ export declare function _ComputeGpuSortKeyScale(depthMin: number, depthMax: number, keyBits: number): number;
1535
+
1506
1536
  /** Babylon.js `ComputeOverlayCssTransform` — HTML overlay interaction is unsupported by the compat layer. */
1507
1537
  export declare function ComputeOverlayCssTransform(): never;
1508
1538
 
@@ -1586,6 +1616,7 @@ export declare const Constants: {
1586
1616
  readonly TEXTURE_TRILINEAR_SAMPLINGMODE: 3;
1587
1617
  readonly TEXTUREFORMAT_RGBA: 5;
1588
1618
  readonly TEXTURETYPE_UNSIGNED_BYTE: 0;
1619
+ readonly TEXTURE_CREATIONFLAG_SAMPLED_DATA_ONLY: 2;
1589
1620
  readonly BUFFER_CREATIONFLAG_READ: 1;
1590
1621
  readonly BUFFER_CREATIONFLAG_WRITE: 2;
1591
1622
  readonly BUFFER_CREATIONFLAG_READWRITE: 3;
@@ -1824,6 +1855,8 @@ declare interface DashedLinesBuilderOptions {
1824
1855
 
1825
1856
  export declare type DataArray = number[] | ArrayBufferLike | ArrayBufferView;
1826
1857
 
1858
+ export declare function _DecodeGpuSortSogMean(value: number): number;
1859
+
1827
1860
  declare interface DefaultEnvironmentOptions {
1828
1861
  createSkybox?: boolean;
1829
1862
  createGround?: boolean;
@@ -1931,6 +1964,8 @@ export declare type DitheredTileFadeMesh = Mesh | InstancedMesh;
1931
1964
 
1932
1965
  export declare type DitheredTileFadeSupportedMaterial = StandardMaterial | PBRMaterial;
1933
1966
 
1967
+ export declare function DivideTexturesAsync(_name: string, a: ITextureProcessOperand, b: ITextureProcessOperand, _scene: Scene, _outputColorSpace?: TextureColorSpace, outputChannelMask?: ChannelMask, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
1968
+
1934
1969
  /** Babylon.js drag move payload. */
1935
1970
  declare type DragEvent_2 = {
1936
1971
  delta: Vector3;
@@ -2469,6 +2504,34 @@ export declare class GaussianSplattingGpuPickingMaterialPlugin extends MaterialP
2469
2504
  static EncodeIdToColor(id: number): [number, number, number];
2470
2505
  constructor(material: GaussianSplattingMaterial, _maxPartCount?: number);
2471
2506
  }
2472
2507
 
2508
+ export declare class GaussianSplattingGpuSorter {
2509
+ static IsSupported(_engine: AbstractEngine): boolean;
2510
+ static GetMaxSupportedSplatCount(_engine: AbstractEngine): number;
2511
+ static LoadDependenciesAsync(): Promise<void>;
2512
+ constructor(_engine: AbstractEngine, _name?: string, _keyBits?: number);
2513
+ get activeCount(): number;
2514
+ get paddedCount(): number;
2515
+ get keyBits(): number;
2516
+ setSource(_source: IGaussianSplattingGpuSortSource): never;
2517
+ setPartMatrices(_matrices: ReadonlyArray<GaussianSplattingGpuSortMatrix> | ArrayLike<number> | null): never;
2518
+ setIntervals(_intervals: ArrayLike<number> | null): never;
2519
+ createOutput(): never;
2520
+ sort(_output: GaussianSplattingGpuSortOutput, _worldMatrix: GaussianSplattingGpuSortMatrix, _viewMatrix: GaussianSplattingGpuSortMatrix, _options?: IGaussianSplattingGpuSortOptions): never;
2521
+ dispose(): void;
2522
+ }
2523
+
2524
+ export declare type GaussianSplattingGpuSortMatrix = Pick<Matrix, "m">;
2525
+
2526
+ export declare class GaussianSplattingGpuSortOutput {
2527
+ constructor(_engine?: AbstractEngine, _label?: string);
2528
+ get buffer(): null;
2529
+ get vertexBuffers(): readonly never[];
2530
+ get paddedCount(): number;
2531
+ get instanceCount(): number;
2532
+ get buffersVersion(): number;
2533
+ dispose(): void;
2534
+ }
2535
+
2473
2536
  export declare class GaussianSplattingMaterial extends PushMaterial {
2474
2537
  constructor(name: string, scene?: Scene);
2475
2538
  clone(_name: string): GaussianSplattingMaterial;
2476
2539
  }
@@ -2479,7 +2542,14 @@ export declare const GaussianSplattingMaxPartCount = 128;
2479
2542
  * Babylon.js `GaussianSplattingMesh`. Derives from `TransformNode` so the loaded
2480
2543
  * cloud's `position` / `rotation` / `scaling` proxy onto the Lite splat node.
2481
2544
  */
2482
- export declare class GaussianSplattingMesh extends TransformNode {
2483
2545
  /**
2546
+ export declare class GaussianSplattingMesh extends TransformNode {
2547
+ private static _useGpuSort;
2548
+ static GpuSortMinFrameInterval: number;
2549
+ static get UseGpuSort(): boolean;
2550
+ static set UseGpuSort(value: boolean);
2484
2551
  private _useGpuSort;
2552
+ get useGpuSort(): boolean | null;
2553
+ set useGpuSort(value: boolean | null);
2554
+ /**
2485
2555
  * Babylon.js `gs.safeOrbitCameraLimits` — safe-orbit camera limits parsed from the source
2486
2556
  * file's metadata (Adobe safe-orbit extension), or `null` when the file carries none.
2487
2557
  *
@@ -2647,8 +2717,14 @@ export declare class GeospatialClippingBehavior {
2647
2717
  /** Babylon.js `GetElementPixelFromUv` — HTML overlay raycast interaction is unsupported by the compat layer. */
2648
2718
  export declare function GetElementPixelFromUv(): never;
2649
2719
 
2720
+ export declare function GetGaussianSplattingGpuSorterMaxSplatCount(engine: AbstractEngine): number;
2721
+
2650
2722
  export declare function GetGaussianSplattingMaxPartCount(engine: AbstractEngine): number;
2651
2723
 
2724
+ export declare function _GetGpuSortPaddedCount(activeCount: number): number;
2725
+
2726
+ export declare function _GetGpuSortPassCount(keyBits: number): number;
2727
+
2652
2728
  export declare function _GetPackedShBytesPerSplat(shDegree: number): number;
2653
2729
 
2654
2730
  export declare function GetPartIndexVaryingDeclaration(shaderLanguage: ShaderLanguage): string;
@@ -2718,6 +2794,8 @@ export declare namespace GLTF1 {
2718
2794
  export declare namespace GLTF2 {
2719
2795
  export {
2720
2796
  OpenPBRMaterialLoadingAdapter,
2797
+ KHR_materials_scatter,
2798
+ RegisterKHR_materials_scatter,
2721
2799
  ParseDebugLogTemplate,
2722
2800
  getMappingForFullOperationName,
2723
2801
  getMappingForDeclaration,
@@ -3319,6 +3397,29 @@ export declare interface IGaussianSplattingDebugOptions {
3319
3397
  shOrder4: boolean;
3320
3398
  }
3321
3399
 
3400
+ export declare interface IGaussianSplattingGpuSortOptions {
3401
+ rightHanded?: boolean;
3402
+ cameraPosition?: ArrayLike<number>;
3403
+ depthRange?: {
3404
+ min: number;
3405
+ max: number;
3406
+ };
3407
+ }
3408
+
3409
+ export declare interface IGaussianSplattingGpuSortSource {
3410
+ vertexCount: number;
3411
+ textureWidth: number;
3412
+ centersTexture: BaseTexture;
3413
+ sog?: {
3414
+ meansHighTexture: BaseTexture;
3415
+ meansMin: ArrayLike<number>;
3416
+ meansMax: ArrayLike<number>;
3417
+ };
3418
+ partIndicesTexture?: BaseTexture;
3419
+ boundsMin?: ArrayLike<number>;
3420
+ boundsMax?: ArrayLike<number>;
3421
+ }
3422
+
3322
3423
  export declare interface IGaussianSplattingStreamingPart {
3323
3424
  readonly proxy: GaussianSplattingPartProxyMesh;
3324
3425
  readonly partIndex: number;
@@ -3639,6 +3740,9 @@ export declare interface ISceneLoaderProgressEvent {
3639
3740
  total: number;
3640
3741
  }
3641
3742
 
3743
+ /** Babylon.js internal polyfill-state query. Compat never installs the unsupported polyfill. */
3744
+ export declare function _IsHtmlInCanvasPolyfillInstalled(): boolean;
3745
+
3642
3746
  /** Babylon.js `IsHtmlInCanvasSupportedNatively` — the HTML-in-canvas feature is unsupported by the compat layer. */
3643
3747
  export declare function IsHtmlInCanvasSupportedNatively(): never;
3644
3748
 
@@ -3784,6 +3888,20 @@ export declare interface IStreamingSoundPlayOptions {
3784
3888
  volume?: number;
3785
3889
  }
3786
3890
 
3891
+ export declare interface ITextureProcessOperand {
3892
+ texture: BaseTexture | null;
3893
+ factor?: Color4;
3894
+ channel?: TextureChannel;
3895
+ colorSpace?: TextureColorSpace;
3896
+ dispose?: () => void;
3897
+ }
3898
+
3899
+ export declare interface ITextureProcessorOutputOptions {
3900
+ textureType?: number;
3901
+ samplingMode?: number;
3902
+ generateMipMaps?: boolean;
3903
+ }
3904
+
3787
3905
  export declare interface IThinMeshBlendingPostProcessOptions extends IMeshBlendConfiguration {
3788
3906
  [key: string]: unknown;
3789
3907
  }
@@ -3834,6 +3952,19 @@ export declare interface IWheelEvent extends IMouseEvent {
3834
3952
  wheelDelta?: number;
3835
3953
  }
3836
3954
 
3955
+ export declare class KHR_materials_scatter {
3956
+ readonly name = "KHR_materials_scatter";
3957
+ enabled: boolean;
3958
+ order: number;
3959
+ constructor(loader?: {
3960
+ isExtensionUsed?(name: string): boolean;
3961
+ });
3962
+ dispose(): void;
3963
+ loadMaterialPropertiesAsync(_context: string, material: {
3964
+ extensions?: Record<string, unknown>;
3965
+ }, _babylonMaterial: unknown): Promise<void> | null;
3966
+ }
3967
+
3837
3968
  /**
3838
3969
  * Babylon.js `KHR_materials_variants` extension helpers. Mirrors the static
3839
3970
  * surface ported code calls (`SelectVariant` / `GetAvailableVariants` / `Reset`)
@@ -4183,6 +4314,8 @@ export { MaxTintMagnitude }
4183
4314
  export declare class Mesh extends AbstractMesh {
4184
4315
  constructor(name: string, sceneOrLite?: Scene | Mesh_2, scene?: Scene);
4185
4316
  getClassName(): string;
4186
4317
  private _morphTargetManager;
4318
+ private readonly _ownedMorphTargetManagers;
4319
+ private _retainMorphTargetManagerOwnership;
4187
4320
  /**
4188
4321
  * Babylon.js `mesh.morphTargetManager`. Babylon Lite builds morph GPU data via
4189
4322
  * `createMorphTargets` and stores it on the Lite mesh; the compat manager is
@@ -4190,8 +4323,7 @@ export declare class Mesh extends AbstractMesh {
4190
4323
  * CPU geometry exists) and assigns it onto the Lite mesh before registration.
4191
4324
  */
4192
4325
  get morphTargetManager(): MorphTargetManager | null;
4193
- set morphTargetManager(value: MorphTargetManager | null);
4194
- /** Legacy `Mesh.CreateSphere(name, segments, diameter, scene)`. */
4326
+ set morphTargetManager(value: MorphTargetManager | null);
4195
4327
  /** Legacy `Mesh.CreateSphere(name, segments, diameter, scene)`. */
4196
4328
  static CreateSphere(name: string, segments: number, diameter: number, scene: Scene): Mesh;
4197
4329
  /** Legacy `Mesh.CreateBox(name, size, scene)`. */
4198
4330
  static CreateBox(name: string, size: number, scene: Scene): Mesh;
@@ -4382,16 +4514,16 @@ export declare class MorphTarget {
4382
4514
  /** Babylon.js `MorphTarget.setNormals(data)` — absolute target normals. */
4383
4515
  setNormals(data: Float32Array | number[] | null): void;
4384
4516
  /** Babylon.js `MorphTarget.getNormals()`. */
4385
- getNormals(): Float32Array | null;
4386
- }
4517
+ getNormals(): Float32Array | null;
4387
4518
 
4388
4519
  /** Babylon.js `MorphTargetManager` — owns a mesh's morph targets (Babylon Lite supports up to 4). */
4389
4520
  export declare class MorphTargetManager {
4390
4521
  private readonly _targets;
4391
- constructor(_scene?: Scene);
4392
- get numTargets(): number;
4522
+ constructor(_scene?: Scene);
4393
4523
  get numTargets(): number;
4394
4524
  getTarget(index: number): MorphTarget;
4395
4525
  /** Babylon.js `MorphTargetManager.addTarget(target)`. */
4396
- addTarget(target: MorphTarget): void;
4526
+ addTarget(target: MorphTarget): void;
4397
4527
  /** Babylon.js `MorphTargetManager.dispose()` — release this manager's morph-resource claim. */
4528
+ dispose(): void;
4529
+ }
4398
4530
 
4399
4531
  export declare class MultiMaterial {
4400
4532
  constructor();
@@ -4401,6 +4533,8 @@ export declare class MultiPointerScaleBehavior {
4401
4533
  constructor();
4402
4534
  }
4403
4535
 
4536
+ export declare function MultiScatterToSingleScatterAlbedoAsync(_name: string, input: ITextureProcessOperand, _scene: Scene, aniso?: number, scale?: ITextureProcessOperand): Promise<ITextureProcessOperand>;
4537
+
4404
4538
  declare abstract class Node_2 {
4405
4539
  name: string;
4406
4540
  /** String id. Defaults to the name (Babylon.js parity). */
@@ -4616,6 +4750,12 @@ export declare class OutlineRenderer {
4616
4750
  constructor();
4617
4751
  }
4618
4752
 
4753
+ export declare function _PackGpuSortIntervals(intervals: ArrayLike<number>, vertexCount: number): {
4754
+ data: Uint32Array;
4755
+ count: number;
4756
+ total: number;
4757
+ };
4758
+
4619
4759
  export declare function PackMeshBlendingTag(groupId: number, radiusClass: MeshBlendingRadiusClass): number;
4620
4760
 
4621
4761
  export declare class ParticleHelper {
@@ -4640,6 +4780,7 @@ export declare class ParticleSystem {
4640
4780
  private _texture;
4641
4781
  private _billboardScheduled;
4642
4782
  private _billboardOwnedBySet;
4783
+ private _started;
4643
4784
  /**
4644
4785
  * Babylon.js `new ParticleSystem(name, capacity, scene)`. The imperative
4645
4786
  * construction API (emitters, over-lifetime gradients, `minEmitBox`, a
@@ -4677,6 +4818,8 @@ export declare class ParticleSystem {
4677
4818
  animate(preWarmOnly?: boolean): void;
4678
4819
  /** Babylon.js `ParticleSystem.stop()` — stop emission; live particles drain. Forwards to Lite `stopParticleSystem`. */
4679
4820
  stop(): void;
4821
+ /** Babylon.js `ParticleSystem.isStarted()` — whether the system is currently emitting. */
4822
+ isStarted(): boolean;
4680
4823
  /** Babylon.js `ParticleSystem.dispose()` — stop the system. */
4681
4824
  dispose(): void;
4682
4825
  /**
4683
4826
  * Schedule the one-time billboard build. Deferred to engine start (via the
@@ -5718,6 +5861,8 @@ export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]):
5718
5861
  /** Babylon.js pure-module registration hook. */
5719
5862
  export declare function RegisterImageProcessingConfiguration(): void;
5720
5863
 
5864
+ export declare function RegisterKHR_materials_scatter(): void;
5865
+
5721
5866
  export declare function RegisterMeshBlendingPostProcessBlock(): never;
5722
5867
 
5723
5868
  /** Babylon.js 9.29 node-render-graph registration function. */
@@ -5874,6 +6019,10 @@ export declare class Scene extends AbstractScene {
5874
6019
  /** Babylon.js fog-mode c
5875
6020
  /** Babylon.js `scene.getAnimationGroupByName(name)` — first loaded animation group with a matching name, else `null`. */
5876
6021
  getAnimationGroupByName(name: string): AnimationGroup | null;
5877
6022
  get animatables(): Animatable_2[];
6023
+ /** Babylon.js `scene.skeletons` — loader-produced skeletons currently used by scene meshes. */
6024
+ get skeletons(): Skeleton[];
6025
+ /** Babylon.js `scene.particleSystems` — registered Lite node-particle systems in scene order. */
6026
+ get particleSystems(): ParticleSystem[];
5878
6027
  private readonly _engine;
5879
6028
  private _activeCamera;
5880
6029
  cameraToUseForPointers: Camera | null;
@@ -5895,9 +6044,16 @@ export declare class Scene extends AbstractScene {
5895
6044
  /** Babylon.js fog-mode c
5896
6045
  private readonly _pendingTextures;
5897
6046
  private readonly _pendingGroundBakes;
5898
6047
  private readonly _pendingMorphBuilds;
6048
+ private readonly _ownedMorphTargetManagers;
5899
6049
  private _materialPluginsRequested;
5900
6050
  private readonly _pendingMaterialPluginReconciliations;
5901
- private readonly _runningAnimatables;
5902
6051
  private readonly _animationGroupCache;
5903
6052
  private _ambientColor;
6053
+ private readonly _runningAnimatables;
5904
6054
  private readonly _animationGroupCache;
6055
+ private readonly _skeletonCache;
6056
+ private readonly _skeletons;
6057
+ private readonly _particleSystemCache;
6058
+ private readonly _particleSystems;
6059
+ private readonly _retiredParticleSystems;
6060
+ private _disposed;
5905
6061
  private _ambientColor;
5906
6062
  private _environmentIntensity;
5907
6063
  private _imageProcessingConfiguration;
5908
6064
  /** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
5909
6065
  readonly uniqueId: number;
@@ -6208,6 +6364,8 @@ export declare class SineEase extends EasingFunction {
6208
6364
  easeInCore(gradient: number): number;
6209
6365
  }
6210
6366
 
6367
+ export declare function SingleScatterToMultiScatterAlbedoAsync(_name: string, input: ITextureProcessOperand, _scene: Scene, aniso?: number, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
6368
+
6211
6369
  export declare class SixDofDragBehavior {
6212
6370
  constructor();
6213
6371
  }
@@ -6229,6 +6387,10 @@ export declare class Skeleton {
6229
6387
  readonly id: string;
6230
6388
  readonly bones: Bone[];
6231
6389
  constructor(_name?: string, _id?: string, _scene?: Scene);
6232
6390
  getBoneIndexByName(name: string): number;
6233
6391
  getBoneByName(name: string): Bone | null;
6392
+ /** Babylon.js `Skeleton.returnToRest()` — clear every compat bone override. */
6393
+ returnToRest(): void;
6394
+ /** Babylon.js `Skeleton.prepare()` — Lite keeps loaded/evaluated bone matrices ready, so no additional bake is needed. */
6395
+ prepare(_dontCheckFrameId?: boolean): void;
6234
6396
  }
6235
6397
 
6236
6398
  export declare class SliderConstraint extends PhysicsConstraint {
@@ -6863,6 +7025,19 @@ export declare class Texture extends BaseTexture {
6863
7025
  static LoadAsync(url: string, scene: Scene): Promise<Texture>;
6864
7026
  }
6865
7027
 
7028
+ export declare enum TextureChannel {
7029
+ RGBA = 0,
7030
+ R = 1,
7031
+ G = 2,
7032
+ B = 3,
7033
+ A = 4
7034
+ }
7035
+
7036
+ export declare enum TextureColorSpace {
7037
+ Linear = 0,
7038
+ SRGB = 1
7039
+ }
7040
+
6866
7041
  declare interface TextureLike {
6867
7042
  _lite?: Texture2D;
6868
7043
  whenReadyAsync?(): Promise<void>;
@@ -6928,6 +7103,11 @@ declare interface ThinSpriteLike {
6928
7103
  isVisible: boolean;
6929
7104
  }
6930
7105
 
7106
+ export declare function ThinWalledScatterWeightsAsync(_name: string, transmission: ITextureProcessOperand, scatter: ITextureProcessOperand, _scene: Scene): Promise<{
7107
+ transmission: ITextureProcessOperand;
7108
+ subsurface: ITextureProcessOperand;
7109
+ }>;
7110
+
6931
7111
  export declare const ToDegrees: number;
6932
7112
 
6933
7113
  /** Babylon.js-compatible `Tools` helpers (the small, pure subset). */
@@ -6961,22 +7141,29 @@ export declare function transformCoordinates(vector: Vector3, transformation: Ma
6961
7141
  * Wraps a Lite scene node (`_node`): either a standalone Lite transform node, or
6962
7142
  * (for meshes) the Lite mesh itself, which also carries the transform.
6963
7143
  */
6964
- export declare class TransformNode extends Node_2 {
6965
7144
  physicsBody: PhysicsBody | null;
6966
7145
  constructor(name: string, scene?: Scene, liteNode?: SceneNode);
7146
+ export declare class TransformNode extends Node_2 {
6967
7147
  physicsBody: PhysicsBody | null;
7148
+ private _rotation;
7149
+ private _rotationBinding;
7150
+ private _rotationQuaternion;
7151
+ private _rotationQuaternionBinding?;
7152
+ private _nativeRotationVersion;
7153
+ private readonly _nativeRotationValues;
7154
+ private _isSyncingRotationFromNative;
7155
+ private _sceneDisposeObserver?;
6968
7156
  constructor(name: string, scene?: Scene, liteNode?: SceneNode);
6969
7157
  getClassName(): string;
6970
7158
  get position(): Vector3;
6971
7159
  set position(value: Vector3);
6972
7160
  get rotation(): Vector3;
6973
7161
  set rotation(value: Vector3);
6974
7162
  get scaling(): Vector3;
6975
- set scaling(value: Vector3);
6976
7163
  /**
6977
- * Babylon.js `rotationQuaternion`. Babylon Lite always drives a node's world
6978
- * matrix from a quaternion (its euler `rotation` is a proxy over the same
6979
- * quaternion), so this reads/writes that quaternion. Returns `null` until
6980
- * explicitly assigned, matching Babylon.js's euler-by-default convention.
6981
- */
7164
+ set scaling(value: Vector3);
7165
+ /** Babylon.js `rotationQuaternion`, kept live while Lite receives translated component writes. */
6982
7166
  get rotationQuaternion(): Quaternion | null;
6983
7167
  set rotationQuaternion(value: Quaternion | null);
6984
- /**
7168
+ private _applyEulerRotation;
7169
+ private _applyQuaternionRotation;
7170
+ private _markNativeRotationSynced;
7171
+ private _syncRotationFromNative;
6985
7172
  /**
6986
7173
  * Babylon.js `getChildTransformNodes(directDescendantsOnly?, predicate?)` — the descendants that are transform nodes
6987
7174
  * (meshes included). As in Babylon.js, `predicate` is called on every evaluated descendant.
6988
7175
  */
@@ -6987,10 +7174,16 @@ export declare class TransformNode extends Node_2 {
6987
7174
  physicsBody: PhysicsBody
6988
7175
  * setter, which keeps the local transform and lets the world move.
6989
7176
  */
6990
7177
  setParent(parent: Node_2 | null): TransformNode;
6991
- protected _applyParent(parent: Node_2 | null): void;
7178
+ protected _applyParent(parent: Node_2 | null): void;
6992
7179
  private _bindRotationSceneDisposal;
7180
+ protected _retireFromScene(): void;
7181
+ }
6993
7182
 
6994
7183
  export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
6995
7184
 
7185
+ export declare function TransmissionFractionAsync(_name: string, a: ITextureProcessOperand, b: ITextureProcessOperand, _scene: Scene, _outputColorSpace?: TextureColorSpace, outputChannelMask?: ChannelMask, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
7186
+
7187
+ export declare function TransmissionScatterToSingleScatterAlbedoAsync(_name: string, transmissionColor: ITextureProcessOperand, transmissionScatter: ITextureProcessOperand, _scene: Scene, _outputColorSpace?: TextureColorSpace, outputChannelMask?: ChannelMask, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
7188
+
6996
7189
  export declare type TrianglePickingPredicate = (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray, i0: number, i1: number, i2: number) => boolean;
6997
7190
 
6998
7191
  /** Minimum Babylon.js UniformBuffer surface needed to author compute bindings. */