@babylonjs/lite-compat 1.36.0-preview → 1.37.1-preview

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -118,7 +118,7 @@ overloads within a supported area may still be absent.
118
118
  | Feature area | Status | Notes |
119
119
  | ----------------------------------------------------------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
120
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; `currentSampleCount` reports the active surface's MSAA count; `beginFrame`/`endFrame`, occlusion queries, engine-wide alpha-to-coverage, and manual `scene.render()` unsupported |
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
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
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
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 |
@@ -144,14 +144,18 @@ overloads within a supported area may still be absent.
144
144
  | Feature area | Status | Notes |
145
145
  | ---------------------------------------------------------------------------------------------- | :----: | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
146
146
  | glTF 2.0 (+ extensions), `.babylon` | ✅ | via Lite `loadGltf` / `loadBabylon`; KHR_interactivity assets run through Lite's native flow-graph runtime |
147
- | `GLTF2.KHR_interactivity` public helpers | ⚡ | pure operation/data normalization and exporter data types are implemented; BJS FlowGraph registry/parser/export planning throws with named structural blockers |
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 |
150
150
  | OpenUSD (`USDFileLoader`) | ⚡ | delegates binary import, virtual files, callbacks, diagnostics, asset containers, and disposal to Lite; all four custom runtime assets must share one directory |
151
151
  | `SceneLoader` (`ImportMeshAsync` / `AppendAsync` / `LoadAssetContainerAsync`), `AssetsManager` | ⚡ | `AssetContainer` partial |
152
- | Gaussian Splatting (`.ply` / `.splat` / `.sog` / `.spz`) | ⚡ | `GaussianSplattingMesh` wraps eager Lite loaders; BJS `GaussianSplattingStream` resolves to a named stub because Lite's URL-only streamer has different budget, transform, cancellation, and compound-hosting semantics |
152
+ | Gaussian Splatting (`.ply` / `.splat` / `.sog` / `.spz`) | ⚡ | `GaussianSplattingMesh` wraps eager Lite loaders; BJS streaming (including range residency) and the separate stochastic WebGPU point-splatting compute path resolve to named stubs because their budget, pass-lifecycle, and rendering models do not map to Lite's sorted-splat renderer |
153
153
  | `OBJ` / `STL` / `FBX` / `BVH` | ❌ | parser/materializer subsystems are not in Lite — convert to glTF |
154
154
 
155
+ > **glTF hierarchy:** `result.meshes` is a flattened view of the glTF node hierarchy (transform nodes plus the
156
+ > primitive meshes beneath them), not one mesh per node as in Babylon.js. Reparent with `setParent()`, not `.parent =`,
157
+ > when you flatten it — see [glTF import hierarchy and reparenting](#gltf-import-hierarchy-and-reparenting).
158
+
155
159
  ### `@babylonjs/addons` · `@recast-navigation/*`
156
160
 
157
161
  | Feature area | Status | Notes |
@@ -174,6 +178,111 @@ The intended migration path is:
174
178
  @babylonjs/core → @babylonjs/lite-compat → babylon-lite (native)
175
179
  ```
176
180
 
181
+ ## glTF import hierarchy and reparenting
182
+
183
+ Babylon Lite keeps the glTF node hierarchy: every glTF node becomes a transform node, and every primitive of its mesh
184
+ becomes a mesh **under** that node. For a node with a single primitive, Babylon.js instead returns one `Mesh` that
185
+ carries both the node transform and the geometry. The compat layer rebuilds Lite's hierarchy as canonical wrappers and
186
+ returns it flattened, in hierarchy order, from `SceneLoader.ImportMeshAsync(...).meshes` and `AssetContainer.meshes`:
187
+
188
+ - The list is a flattened view of a retained hierarchy, not a list of independent renderable meshes. A parent always
189
+ comes before its children.
190
+ - It contains the synthetic `__root__` at index 0, the source glTF transform nodes, and the primitive meshes beneath
191
+ them.
192
+ - Transform-only entries are wrapped as `Mesh` too, but carry no geometry: `getTotalVertices() === 0`. Do not treat an
193
+ entry as geometry just because it is a `Mesh`.
194
+
195
+ ### Why per-entry `.parent` breaks
196
+
197
+ `mesh.parent = node` keeps the mesh's **local** transform and lets its world transform change under the new parent.
198
+ `mesh.setParent(node)` keeps its **world** transform. Both behave as in Babylon.js, but a loop written for Babylon.js
199
+ often assigns `.parent` to every returned entry:
200
+
201
+ ```ts
202
+ // Fine in Babylon.js. Under compat it detaches each primitive from the glTF node that carries its transform.
203
+ for (const mesh of result.meshes) {
204
+ mesh.parent = applicationRoot;
205
+ }
206
+ ```
207
+
208
+ Under compat every primitive mesh is then moved off the glTF node above it and keeps only its own local transform, so
209
+ any scale, rotation or translation that came from an ancestor node is lost. A typical case is a hardware asset modelled
210
+ in millimetres whose glTF node scales it by `0.001`: after the loop its primitives render 1000 times too large, so a
211
+ 40 mm connector becomes 40 m, often far outside the camera range.
212
+
213
+ Baking in list order fails the same way. `bakeCurrentTransformIntoVertices()` bakes only the mesh's **local**
214
+ transform: on a primitive that still sits under its glTF node it leaves the node's scale out, and resetting a node's
215
+ transform first (it comes earlier in the list) changes what its children inherit before they are processed.
216
+
217
+ ### Safe patterns
218
+
219
+ Keep the hierarchy and move the whole import:
220
+
221
+ ```ts
222
+ import { Mesh, SceneLoader } from "@babylonjs/lite-compat";
223
+
224
+ const result = await SceneLoader.ImportMeshAsync("", rootUrl, "model.glb", scene);
225
+ result.meshes[0]!.setParent(applicationRoot);
226
+ ```
227
+
228
+ Flatten only the renderable meshes, keeping their current world transforms. `result.meshes` is typed as
229
+ `TransformNode[]`, so narrow the entries to `Mesh` before calling mesh-only methods:
230
+
231
+ ```ts
232
+ const renderableMeshes = result.meshes.filter((mesh): mesh is Mesh => mesh instanceof Mesh && mesh.getTotalVertices() > 0);
233
+ for (const mesh of renderableMeshes) {
234
+ mesh.setParent(applicationRoot);
235
+ }
236
+ ```
237
+
238
+ Baking the composed transform into the geometry works only for a narrow set of imported meshes. For those, call
239
+ `setParent()` first, so the full hierarchy-composed world transform becomes the mesh's new local transform, then bake:
240
+
241
+ ```ts
242
+ // bakeableMeshes: the entries of renderableMeshes that meet every condition listed below.
243
+ for (const mesh of bakeableMeshes) {
244
+ mesh.setParent(applicationRoot);
245
+ mesh.bakeCurrentTransformIntoVertices();
246
+ }
247
+ ```
248
+
249
+ Bake a mesh only if all of the following hold. Otherwise flatten it with `setParent()` alone, or keep the hierarchy and
250
+ move the whole import:
251
+
252
+ - **Shear-free composed transform.** `setParent()` keeps the exact affine local matrix, but
253
+ `bakeCurrentTransformIntoVertices()` rebuilds the transform from position, rotation and scaling, and that cannot
254
+ express shear. Shear appears when an ancestor has a non-uniform scale and a descendant below it is rotated: for
255
+ example, a node scaled `(2, 1, 1)` above a primitive rotated 45 degrees around Z. Baking such a primitive drops the
256
+ shear and changes the geometry.
257
+ - **Tightly packed vertex data.** Baking replaces the vertex buffers through `resizeMeshGeometry()`, which throws for
258
+ interleaved geometry. A glTF primitive loads as interleaved only when at least one of its vertex attributes comes
259
+ from a bufferView whose `byteStride` is larger than that attribute's element size, for example positions and normals
260
+ sharing one bufferView with `byteStride: 24`, and no loader extension such as Draco has already decoded it. A
261
+ `byteStride` equal to the element size, which many exporters write on tightly packed bufferViews, keeps the primitive
262
+ on the tightly packed path.
263
+ - **Undeformed geometry.** The baker transforms the base positions, normals and tangents only. It does not transform
264
+ morph target deltas, so after baking a delta contributes in the baked space: under an inherited uniform scale of
265
+ `0.001`, a delta of 1 contributes `0.001` before baking and `1` after. Skinned meshes are not covered either, and
266
+ flattening already detaches a primitive from any animated glTF node above it. Keep the hierarchy for assets whose
267
+ morph targets, skinning or node animation must keep working.
268
+ - **Only positions, normals and the first UV set.** Baking can only re-upload the vertex attributes whose CPU arrays are
269
+ retained. The glTF loader uploads `COLOR_0` and `TEXCOORD_1` without keeping CPU copies, so baking drops vertex colors
270
+ and the second UV set, and it retains tangents only after `enableGltfCpuTangents()` from `@babylonjs/lite` is called before loading.
271
+ - **No thin instances.** This includes every primitive on a glTF node with `EXT_mesh_gpu_instancing`, which the loader
272
+ draws as thin instances: their matrices stay in the node's local frame, and the shader composes
273
+ `mesh.world * instanceWorld`. Baking transforms only the prototype geometry and resets the mesh transform, but not the
274
+ instance matrices, so the instance offsets end up in the baked space: under an inherited uniform scale of `0.001`, an
275
+ instance translation of `(0, 1, 0)` contributes `0.001` before baking and `1` after, and the copies scatter. Flatten
276
+ such meshes with `setParent()` alone, or keep the hierarchy.
277
+ - **Triangle lists only.** The glTF loader keeps the topology of line, line-strip and triangle-strip primitives, but the
278
+ baker treats every index buffer as a triangle list. When the baked transform mirrors the geometry, it swaps the second
279
+ and third index of each group of three to keep the winding. Flattening a glTF import under an identity
280
+ `applicationRoot` includes the mirroring of its synthetic handedness root, so a line list `[0, 1, 2, 3, 4, 5]` becomes
281
+ `[0, 2, 1, 3, 5, 4]` and connects other vertices; strips lose their connectivity the same way. Flatten line and strip
282
+ primitives with `setParent()` alone.
283
+
284
+ `setParent()` also preserves mirrored transforms, including the synthetic handedness root of glTF imports (#456).
285
+
177
286
  ## Missing an API you need?
178
287
 
179
288
  The compat surface grows in response to real-world migration needs. If you hit a
package/index.d.ts CHANGED
@@ -5,7 +5,7 @@ import { AudioGraphHost } from '@babylonjs/lite';
5
5
  import { ClearCoatProps } from '@babylonjs/lite';
6
6
  import { ComputeShader as ComputeShader_2 } from '@babylonjs/lite';
7
7
  import { EngineContext } from '@babylonjs/lite';
8
- import { EngineOptions } from '@babylonjs/lite';
8
+ import { EngineOptions as EngineOptions_2 } from '@babylonjs/lite';
9
9
  import { IridescenceProps } from '@babylonjs/lite';
10
10
  import { LineMaterial } from '@babylonjs/lite';
11
11
  import { MaxTintMagnitude } from '@babylonjs/lite';
@@ -243,12 +243,19 @@ export declare abstract class AbstractEngine {
243
243
  private _ensureInitialized;
244
244
  }
245
245
 
246
+ /** Babylon.js `AbstractEngineOptions` subset accepted by the compat engine. */
247
+ export declare interface AbstractEngineOptions extends EngineOptions_2 {
248
+ antialias?: boolean;
249
+ adaptToDeviceRatio?: boolean;
250
+ useLargeWorldRendering?: boolean;
251
+ useReverseDepthBuffer?: boolean;
252
+ }
253
+
246
254
  /**
247
255
  * Babylon.js `AbstractMesh` — a renderable transform node with a material,
248
256
  * visibility, and shadow-receipt. Concrete meshes derive from this.
249
257
  */
250
- export declare class AbstractMesh extends TransformNode {
251
258
  private _material;
252
- private _meshBlendingTag;
259
+ export declare class AbstractMesh extends TransformNode {
253
260
  private _material;
254
261
  private _meshBlendingTag;
255
262
  protected _visible: boolean;
256
263
  constructor(name: string, lite: Mesh_2, scene?: Scene);
257
264
  getClassName(): string;
258
265
  get material(): CompatMaterial | null;
@@ -677,13 +684,13 @@ declare class Animation_2 {
677
684
  getKeys(): IAnimationKey[];
678
685
  getHighestFrame(): number;
679
686
  /**
680
- * Assigns the easing function used to transform each non-STEP segment's normalized progress.
681
- * @param easingFunction - A Babylon.js-shaped easing object, or `null` to restore linear progress.
687
+ * Assigns default easing for non-STEP segments without a key-specific easing function.
688
+ * @param easingFunction - A Babylon.js-shaped easing object, or `null` to use linear progress on keys without an override.
682
689
  */
683
690
  setEasingFunction(easingFunction: IEasingFunction | null): void;
684
691
  /**
685
692
  * Gets the easing function currently assigned to this animation.
686
- * @returns The assigned easing object, or `null` when interpolation uses linear progress.
693
+ * @returns The assigned default easing object, or `null` when keys without an override use linear progress.
687
694
  */
688
695
  getEasingFunction(): IEasingFunction | null;
689
696
  /** Evaluate the animated value at `frame`, clamped to the key range. */
@@ -811,6 +818,7 @@ export declare class ArcRotateCamera extends Camera {
811
818
  constructor(name: stri
812
819
  set beta(value: number);
813
820
  get radius(): number;
814
821
  set radius(value: number);
822
+ /** Live, as in Babylon.js: `camera.target.x = …` and in-place vector math move the target. */
815
823
  get target(): Vector3;
816
824
  set target(value: Vector3);
817
825
  /** Babylon.js `setTarget` — point the arc-rotate camera at a world-space target. */
@@ -1708,6 +1716,11 @@ export declare class CubeTexture extends BaseTexture {
1708
1716
  gammaSpace: boolean;
1709
1717
  level: number;
1710
1718
  /** Fires when the cube map is "ready" (resolved on a microtask in this compat layer). */
1711
1719
  readonly onLoadObservable: Observable<CubeTexture>;
1720
+ /**
1721
+ * Babylon.js `CubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
1722
+ * texture as its `environmentTexture` turns its image-based lighting with it (see `Scene.environmentTexture`).
1723
+ */
1724
+ rotationY: number;
1712
1725
  private _ready;
1713
1726
  private readonly _readyPromise;
1714
1727
  constructor(url: string, _scene?: unknown, _extensions?: unknown, _noMipmap?: boolean, _files?: unknown, onLoad?: (() => void) | null, _onError?: unknown, _format?: unknown, _prefiltered?: boolean);
@@ -1785,6 +1798,8 @@ export declare class DefaultRenderingPipeline {
1785
1798
  constructor();
1786
1799
  }
1787
1800
 
1801
+ export declare function defaultValueParseFunction(_key: string, _serializationObject: any, _assetsContainer: AssetContainer, _scene: Scene): any;
1802
+
1788
1803
  export declare const DepthOfFieldEffect: new () => never;
1789
1804
 
1790
1805
  export declare class DepthRenderer {
@@ -1976,6 +1991,11 @@ export declare class ElasticEase extends EasingFunction {
1976
1991
  * Lite WebGPU context; this class exists to mirror Babylon.js's name + hierarchy.
1977
1992
  */
1978
1993
  export declare class Engine extends ThinEngine {
1994
+ constructor(canvas: RenderCanvas, antialiasOrOptions?: boolean | EngineOptions, options?: EngineOptions, adaptToDeviceRatio?: boolean);
1995
+ }
1996
+
1997
+ /** Babylon.js `EngineOptions` subset accepted by the compat engine. */
1998
+ export declare interface EngineOptions extends AbstractEngineOptions {
1979
1999
  }
1980
2000
 
1981
2001
  /** Babylon.js-compatible scalar helpers and a small set of math constants. */
@@ -2143,6 +2163,15 @@ export declare type FBXNormalMapCoordinateSystem = "y-up" | "y-down";
2143
2163
 
2144
2164
  declare type FloatArray = number[] | Float32Array;
2145
2165
 
2166
+ export declare interface FlowGraphContext {
2167
+ _getGlobalContextVariable<T>(name: string, defaultValue: T): T;
2168
+ _setGlobalContextVariable<T>(name: string, value: T): void;
2169
+ }
2170
+
2171
+ export declare interface FlowGraphPlayAnimationBlock {
2172
+ getClassName(): string;
2173
+ }
2174
+
2146
2175
  export declare enum FlowGraphValidationSeverity {
2147
2176
  Error = 0,
2148
2177
  Warning = 1
@@ -2244,6 +2273,58 @@ export declare class GamepadCamera extends UniversalCamera {
2244
2273
  getClassName(): string;
2245
2274
  }
2246
2275
 
2276
+ export declare class GaussianPointSplattingBlitMaterial extends ShaderMaterial {
2247
2277
  constructor(_name: string, _scene: Scene);
2278
+ setAccumBuffer(_buffer: StorageBuffer): void;
2279
+ setAccumDepthBuffer(_buffer: StorageBuffer): void;
2280
+ setResolution(_width: number, _height: number): void;
2281
+ setProjectionZ(_m10: number, _m11: number, _m14: number, _m15: number): void;
2282
+ setInverseProjection(_inverseProjection: Matrix): void;
2283
+ setLogarithmicDepthConstant(_constant: number): void;
2284
+ }
2285
+
2286
+ export declare class GaussianPointSplattingDepthBlitMaterial extends ShaderMaterial {
2248
2287
  constructor(_name: string, _scene: Scene);
2288
+ setAccumBuffer(_buffer: StorageBuffer): void;
2289
+ setAccumDepthBuffer(_buffer: StorageBuffer): void;
2290
+ setResolution(_width: number, _height: number): void;
2291
+ setProjectionZ(_m10: number, _m11: number, _m14: number, _m15: number): void;
2292
+ setInverseProjection(_inverseProjection: Matrix): void;
2293
+ setDepthValues(_minZ: number, _minZPlusMaxZ: number): void;
2294
+ setReverseDepth(_reverse: boolean): void;
2295
+ }
2296
+
2297
+ export declare class GaussianPointSplattingRenderer {
2298
+ pointScale: number;
2299
+ kernelSize: number;
2300
+ minPixelSize: number;
2301
+ rightHandedSystem: boolean;
2302
+ debugActive: number;
2303
+ isOrthographic: boolean;
2304
+ compensation: boolean;
2305
+ occlusionCulling: boolean;
2306
+ maxAccumFrames: number;
2307
+ constructor(_engine: AbstractEngine);
2308
+ supportsWorkload(_gaussianCount: number, _shDegree: number, _outWidth: number, _outHeight: number): boolean;
2309
+ get accumBuffer(): StorageBuffer | null;
2310
+ get accumDepthBuffer(): StorageBuffer | null;
2311
+ get renderedFrameCount(): number;
2312
+ get accumulationVersion(): number;
2313
+ get pixelCycleLength(): number;
2314
+ readPointCountAsync(): Promise<number>;
2315
+ get width(): number;
2316
+ get height(): number;
2317
+ get outputWidth(): number;
2318
+ get outputHeight(): number;
2319
+ get gaussianCount(): number;
2320
+ isReady(): boolean;
2321
+ updateSplats(_means: Float32Array, _cov3d: Uint32Array, _colorOpacity: Uint32Array, _sh: Uint32Array | null, _shDegree: number, _count: number): void;
2322
+ resetAccumulation(): void;
2323
+ setCamera(_view: Matrix, _viewProjection: Matrix, _near: number, _far: number, _focalX: number, _focalY: number, _camX: number, _camY: number, _camZ: number, _viewZMin: number, _viewZMax: number): void;
2324
+ setProjectionZ(_m10: number, _m11: number, _m14: number, _m15: number): void;
2325
+ setProjectionMatrix(_projection: Matrix, _inverseProjection: Matrix, _reverseDepth?: boolean): void;
2326
+ setPartData(_packed: Float32Array, _count: number): void;
2249
2327
  renderToBuffer(_width: number, _height: number, _outWidth?: number, _outHeight?: number, _upsampleN?: number, _jitterX?: number, _jitterY?: number): boolean;
2328
+ dispose(): void;
2329
+ }
2330
+
2250
2331
  export declare class GaussianSplattingDebugMaterialPlugin extends MaterialPluginBase {
2251
2332
  constructor(material: GaussianSplattingMaterial);
2252
2333
  }
2253
2334
 
@@ -2271,6 +2352,17 @@ export declare class GaussianSplattingMesh extends TransformNode {
2271
2352
  /**
2272
2353
  * to Lite's splat loaders; the field is exposed here for shape parity so ported reads resolve.
2273
2354
  */
2274
2355
  safeOrbitCameraLimits: ISafeOrbitCameraLimits | null;
2356
+ get pointSplattingRenderScale(): number | "auto";
2357
+ set pointSplattingRenderScale(value: number | "auto");
2358
+ get pointSplattingOcclusionCulling(): boolean;
2359
+ set pointSplattingOcclusionCulling(value: boolean);
2360
+ get pointSplattingRenderMode(): boolean;
2361
+ set pointSplattingRenderMode(value: boolean);
2362
+ get pointSplattingDepthRenderMode(): boolean;
2363
+ set pointSplattingDepthRenderMode(value: boolean);
2364
+ get pointSplattingProgress(): IGaussianPointSplattingProgress | null;
2365
+ get pointSplattingScale(): number;
2366
+ set pointSplattingScale(value: number);
2275
2367
  constructor(name: string, url?: string | null, scene?: Scene, _keepInRam?: boolean);
2276
2368
  getClassName(): string;
2277
2369
  get position(): Vector3;
2278
2370
  set position(value: Vector3);
@@ -2362,6 +2454,10 @@ export declare class GaussianSplattingStream extends GaussianSplattingMesh {
2362
2454
  get debugLodSource(): never;
2363
2455
  set debugLodSource(_value: GaussianSplattingStreamDebugLodSource);
2364
2456
  evaluateOptimalLods(_camera?: unknown): never;
2457
+ getSourceRange(_fileId: number): Readonly<IGaussianSplattingStreamSourceRange> | null;
2458
+ isSplitPage(_fileId: number): boolean;
2459
+ cancelRangeLoads(_files: readonly number[], _keepSources?: readonly number[]): void;
2460
+ get rangeResidencyStats(): Readonly<IGaussianSplattingStreamRangeResidencyStats>;
2365
2461
  }
2366
2462
 
2367
2463
  export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
@@ -2416,6 +2512,8 @@ export declare function GetElementPixelFromUv(): never;
2416
2512
 
2417
2513
  export declare function GetGaussianSplattingMaxPartCount(engine: AbstractEngine): number;
2418
2514
 
2515
+ export declare function _GetPackedShBytesPerSplat(shDegree: number): number;
2516
+
2419
2517
  export declare function GetPartIndexVaryingDeclaration(shaderLanguage: ShaderLanguage): string;
2420
2518
 
2421
2519
  export declare function GetPointsCount(..._args: unknown[]): never;
@@ -2527,6 +2625,8 @@ export declare namespace GLTF2 {
2527
2625
  IKHRInteractivityTypeMapping,
2528
2626
  gltfTypeToBabylonType,
2529
2627
  IFlowGraphEventReferenceBlockConfiguration,
2628
+ IFlowGraphDelayReferenceBlockConfiguration,
2629
+ FlowGraphDelayReferenceBlock,
2530
2630
  FlowGraphEventReferenceBlock,
2531
2631
  IFlowGraphGLTFDataProviderBlockConfiguration,
2532
2632
  FlowGraphGLTFDataProvider,
@@ -2752,6 +2852,8 @@ export declare class HandConstraintBehavior {
2752
2852
  constructor();
2753
2853
  }
2754
2854
 
2855
+ export declare function _HasGaussianPointSplattingProjectedDepth(projection: Matrix): boolean;
2856
+
2755
2857
  /**
2756
2858
  * Babylon.js-shaped Havok V2 physics plugin, backed by Babylon Lite's native
2757
2859
  * `createHavokWorld` API.
@@ -2813,6 +2915,11 @@ export declare class HDRCubeTexture extends BaseTexture {
2813
2915
  gammaSpace: boolean;
2814
2916
  level: number;
2815
2917
  /** Fires when the HDR environment is "ready" (resolved on a microtask). */
2816
2918
  readonly onLoadObservable: Observable<HDRCubeTexture>;
2919
+ /**
2920
+ * Babylon.js `HDRCubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
2921
+ * texture as its `environmentTexture` turns its image-based lighting with it (see `Scene.environmentTexture`).
2922
+ */
2923
+ rotationY: number;
2817
2924
  private _ready;
2818
2925
  private readonly _readyPromise;
2819
2926
  constructor(url: string, _sceneOrEngine?: unknown, size?: number, _noMipmap?: boolean, _generateHarmonics?: boolean, _gammaSpace?: boolean, _prefilterOnLoad?: boolean, onLoad?: (() => void) | null);
@@ -2902,6 +3009,8 @@ export declare interface IAnimationKey {
2902
3009
  value: AnimationValue;
2903
3010
  /** Babylon.js per-key interpolation hint (`AnimationKeyInterpolation`). */
2904
3011
  interpolation?: number;
3012
+ /** Easing for the segment starting at this key; overrides animation-level easing. */
3013
+ easingFunction?: IEasingFunction;
2905
3014
  }
2906
3015
 
2907
3016
  /** Structural vector/quaternion value accepted by Babylon.js animation keys. */
@@ -3022,6 +3131,14 @@ export declare interface IEasingFunction {
3022
3131
  ease(gradient: number): number;
3023
3132
  }
3024
3133
 
3134
+ export declare interface IFlowGraphAnimationObserverSet {
3135
+ block: FlowGraphPlayAnimationBlock;
3136
+ groupEnd: Observer<AnimationGroup>;
3137
+ animationEnd: Observer<any>;
3138
+ animationLoop: Observer<any>;
3139
+ groupLoop: Observer<AnimationGroup>;
3140
+ }
3141
+
3025
3142
  export declare interface IFlowGraphValidationIssue {
3026
3143
  severity: FlowGraphValidationSeverity;
3027
3144
  message: string;
@@ -3037,6 +3154,12 @@ export declare interface IFlowGraphValidationResult {
3037
3154
  issuesByBlock: Map<string, IFlowGraphValidationIssue[]>;
3038
3155
  }
3039
3156
 
3157
+ export declare interface IGaussianPointSplattingProgress {
3158
+ renderedFrameCount: number;
3159
+ accumulationVersion: number;
3160
+ pixelCycleLength: number;
3161
+ }
3162
+
3040
3163
  export declare interface IGaussianSplattingDebugOptions {
3041
3164
  clippingBox: {
3042
3165
  min: Vector3;
@@ -3111,6 +3234,28 @@ export declare interface IGaussianSplattingStreamOptions {
3111
3234
  hostCompound?: GaussianSplattingMesh;
3112
3235
  decodeSh?: boolean;
3113
3236
  needsRotationScale?: boolean;
3237
+ rangeResidency?: boolean;
3238
+ rangePack?: (source: Readonly<IGaussianSplattingStreamSourceRange>, sourceData: SOGRootData) => IGaussianSplattingStreamRangePack | null;
3239
+ }
3240
+
3241
+ export declare interface IGaussianSplattingStreamRangePack {
3242
+ sogData: SOGRootData;
3243
+ subRootUrl: string;
3244
+ }
3245
+
3246
+ export declare interface IGaussianSplattingStreamRangeResidencyStats {
3247
+ enabled: boolean;
3248
+ pages: number;
3249
+ sourcePackLoads: number;
3250
+ sourcePackReuses: number;
3251
+ splitPackLoads: number;
3252
+ cachedSourceSplats: number;
3253
+ }
3254
+
3255
+ export declare interface IGaussianSplattingStreamSourceRange {
3256
+ file: number;
3257
+ offset: number;
3258
+ count: number;
3114
3259
  }
3115
3260
 
3116
3261
  /** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
@@ -3761,6 +3906,7 @@ export declare class Matrix {
3761
3906
  multiplyToRef(other: Matrix, result: Matrix): Matrix;
3762
3907
  transpose(): Matrix;
3763
3908
  determinant(): number;
3909
+ /** Babylon.js `invert`: inverts this matrix in place and returns it. */
3764
3910
  invert(): Matrix;
3765
3911
  invertToRef(result: Matrix): Matrix;
3766
3912
  getTranslation(): Vector3;
@@ -4214,6 +4360,14 @@ export declare class Observable<T> {
4214
4360
  cleanLastNotifiedState(): void;
4215
4361
  }
4216
4362
 
4363
+ export declare interface Observer<T> {
4364
+ callback: (eventData: T, eventState: unknown) => void;
4365
+ mask: number;
4366
+ scope: any;
4367
+ unregisterOnNextCall: boolean;
4368
+ remove(defer?: boolean): void;
4369
+ }
4370
+
4217
4371
  /**
4218
4372
  * Minimal Babylon.js-compatible `Observable`.
4219
4373
  *
@@ -4929,8 +5083,10 @@ export declare class PointerEventTypes {
4929
5083
  export declare class PointerInfo {
4930
5084
  type: number;
4931
5085
  event: PointerEvent | WheelEvent;
4932
- private readonly _pickInfo;
4933
- constructor(type: number, event: PointerEvent | WheelEvent, _pickInfo: PickingInfo | null);
5086
+ private _pickInfo;
5087
+ private _pick;
5088
+ constructor(type: number, event: PointerEvent | WheelEvent, _pickInfo: PickingInfo | null, _pick?: (() => PickingInfo) | null);
5089
+ /** Like Babylon.js lazy picking: without a precomputed pick, `_pick` runs on the first read only. */
4934
5090
  get pickInfo(): PickingInfo | null;
4935
5091
  }
4936
5092
 
@@ -5027,8 +5183,12 @@ export declare class PositionGizmo extends GizmoBase {
5027
5183
  private _attached;
5028
5184
  set updateGizmoRotationToMatchAttachedMesh(value: boolean);
5029
5185
  get attachedMesh(): AbstractMesh | null;
5030
5186
  set attachedMesh(value: AbstractMesh | null);
5031
- get attachedNode(): AbstractMesh | null;
5032
- set attachedNode(value: AbstractMesh | null);
5187
+ /**
5188
+ * Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
5189
+ * Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
5190
+ */
5191
+ get attachedNode(): Node_2 | null;
5192
+ set attachedNode(value: Node_2 | null);
5033
5193
  dispose(): void;
5034
5194
  }
5035
5195
 
@@ -5085,6 +5245,7 @@ export declare class Quaternion {
5085
5245
  constructor(x?: number, y?: number, z?: number, w?: number);
5086
5246
  set(x: number, y: number, z: number, w: number): this;
5087
5247
  copyFrom(source: Quaternion): this;
5248
+ /** Babylon.js `multiply`: the product `this · other` as a new quaternion. */
5088
5249
  multiply(other: Quaternion): Quaternion;
5089
5250
  length(): number;
5090
5251
  normalize(): this;
@@ -5319,6 +5480,8 @@ export declare function RegisterSPLATFileLoader(): void;
5319
5480
 
5320
5481
  export declare function RegisterUSDFileLoader(): void;
5321
5482
 
5483
+ export declare function RemoveFlowGraphAnimationGroupObservers(_context: FlowGraphContext, _animationGroup: AnimationGroup): FlowGraphPlayAnimationBlock | undefined;
5484
+
5322
5485
  /** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
5323
5486
  export declare class RenderTargetTexture {
5324
5487
  constructor();
@@ -5386,8 +5549,12 @@ export declare class RotationGizmo extends GizmoBase {
5386
5549
  private _attached;
5387
5550
  set updateGizmoRotationToMatchAttachedMesh(value: boolean);
5388
5551
  get attachedMesh(): AbstractMesh | null;
5389
5552
  set attachedMesh(value: AbstractMesh | null);
5390
- get attachedNode(): AbstractMesh | null;
5391
- set attachedNode(value: AbstractMesh | null);
5553
+ /**
5554
+ * Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
5555
+ * Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
5556
+ */
5557
+ get attachedNode(): Node_2 | null;
5558
+ set attachedNode(value: Node_2 | null);
5392
5559
  dispose(): void;
5393
5560
  }
5394
5561
 
@@ -5416,8 +5583,12 @@ export declare class ScaleGizmo extends GizmoBase {
5416
5583
  private _attached;
5417
5584
  set updateGizmoRotationToMatchAttachedMesh(value: boolean);
5418
5585
  get attachedMesh(): AbstractMesh | null;
5419
5586
  set attachedMesh(value: AbstractMesh | null);
5420
- get attachedNode(): AbstractMesh | null;
5421
- set attachedNode(value: AbstractMesh | null);
5587
+ /**
5588
+ * Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
5589
+ * Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
5590
+ */
5591
+ get attachedNode(): Node_2 | null;
5592
+ set attachedNode(value: Node_2 | null);
5422
5593
  dispose(): void;
5423
5594
  }
5424
5595
 
@@ -5451,6 +5622,9 @@ export declare class Scene extends AbstractScene {
5451
5622
  /** Babylon.js fog-mode c
5452
5623
  private readonly _engine;
5453
5624
  private _activeCamera;
5454
5625
  cameraToUseForPointers: Camera | null;
5626
+ /** Babylon.js `scene.pointerX` / `pointerY`: the last pointer position in CSS pixels relative to the canvas. */
5627
+ pointerX: number;
5628
+ pointerY: number;
5455
5629
  private _defaultMaterial;
5456
5630
  private _fogMode;
5457
5631
  private _fogStart;
@@ -5458,6 +5632,8 @@ export declare class Scene extends AbstractScene {
5458
5632
  /** Babylon.js fog-mode c
5459
5633
  private _fogDensity;
5460
5634
  private _fogColor;
5461
5635
  private _started;
5462
5636
  private _envTexture;
5637
+ /** Environment lighting rotation last forwarded to Lite. */
5638
+ private _envRotation;
5463
5639
  private _brdfTexture;
5464
5640
  private _defaultEnvOptions;
5465
5641
  private readonly _shadowGenerators;
@@ -5547,6 +5723,13 @@ export declare class Scene extends AbstractScene {
5547
5723
  /** Babylon.js fog-mode c
5548
5724
  set clipPlane(value: Plane | null);
5549
5725
  get environmentTexture(): CubeTexture | HDRCubeTexture | null;
5550
5726
  set environmentTexture(value: CubeTexture | HDRCubeTexture | null);
5727
+ /**
5728
+ * Forward the environment texture's `rotationY` to the image-based lighting only. As in Babylon.js, a skybox keeps the
5729
+ * orientation it was created with (see {@link createDefaultSkybox}) and the `createDefaultEnvironment` background never
5730
+ * turns. Also runs every frame, so the texture needs no link back to the scenes that use it. A scene whose
5731
+ * environment is never rotated never calls Lite.
5732
+ */
5733
+ private _syncEnvironmentRotation;
5551
5734
  /**
5552
5735
  * Babylon.js `scene.environmentBRDFTexture` — the BRDF lookup used by PBR materials.
5553
5736
  * Babylon.js defaults this to an embedded Base64 LUT and lets apps swap in one of the
@@ -5699,8 +5882,7 @@ export declare enum ShaderLanguage {
5699
5882
  WGSL = 1
5700
5883
  }
5701
5884
 
5702
- export declare class ShaderMaterial {
5703
- constructor();
5885
+ export declare class ShaderMaterial {
5704
5886
  constructor();
5705
5887
  }
5706
5888
 
5707
5889
  export declare class ShadowGenerator {
@@ -5811,6 +5993,28 @@ export declare class SmartArray<T> {
5811
5993
  dispose(): void;
5812
5994
  }
5813
5995
 
5996
+ declare interface SOGDataFile {
5997
+ shape: number[];
5998
+ dtype: string;
5999
+ mins?: number | number[];
6000
+ maxs?: number | number[];
6001
+ codebook?: number[];
6002
+ encoding?: string;
6003
+ quantization?: number;
6004
+ files: string[];
6005
+ bands?: number;
6006
+ }
6007
+
6008
+ declare interface SOGRootData {
6009
+ version?: number;
6010
+ means: SOGDataFile;
6011
+ scales: SOGDataFile;
6012
+ quats: SOGDataFile;
6013
+ sh0: SOGDataFile;
6014
+ shN?: SOGDataFile;
6015
+ count?: number;
6016
+ }
6017
+
5814
6018
  export declare class SolidParticleSystem {
5815
6019
  constructor();
5816
6020
  }
@@ -6440,8 +6644,8 @@ export declare const ToDegrees: number;
6440
6644
 
6441
6645
  /** Babylon.js-compatible `Tools` helpers (the small, pure subset). */
6442
6646
  export declare const Tools: {
6443
- /** High-resolution timestamp in milliseconds. */
6444
- Now(): number;
6647
+ /** Current high-resolution timestamp in milliseconds, matching Babylon.js's numeric property. */
6648
+ readonly Now: number;
6445
6649
  ToRadians(degrees: number): number;
6446
6650
  ToDegrees(radians: number): number;
6447
6651
  /** Clamp `value` into the inclusive `[min, max]` range. */
@@ -6884,10 +7088,7 @@ export declare class WebGPUEngine extends AbstractEngine {
6884
7088
  }
6885
7089
 
6886
7090
  /** Babylon.js `WebGPUEngineOptions` subset accepted by the compat engine. */
6887
- export declare interface WebGPUEngineOptions extends EngineOptions {
6888
- antialias?: boolean;
6889
- adaptToDeviceRatio?: boolean;
6890
- useLargeWorldRendering?: boolean;
7091
+ export declare interface WebGPUEngineOptions extends AbstractEngineOptions {
6891
7092
  canvasToneMapping?: GPUCanvasToneMapping;
6892
7093
  canvasColorSpace?: PredefinedColorSpace;
6893
7094
  }