@babylonjs/lite-compat 1.37.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 streaming 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 |
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;
@@ -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
@@ -2425,6 +2454,10 @@ export declare class GaussianSplattingStream extends GaussianSplattingMesh {
2425
2454
  get debugLodSource(): never;
2426
2455
  set debugLodSource(_value: GaussianSplattingStreamDebugLodSource);
2427
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>;
2428
2461
  }
2429
2462
 
2430
2463
  export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
@@ -2592,6 +2625,8 @@ export declare namespace GLTF2 {
2592
2625
  IKHRInteractivityTypeMapping,
2593
2626
  gltfTypeToBabylonType,
2594
2627
  IFlowGraphEventReferenceBlockConfiguration,
2628
+ IFlowGraphDelayReferenceBlockConfiguration,
2629
+ FlowGraphDelayReferenceBlock,
2595
2630
  FlowGraphEventReferenceBlock,
2596
2631
  IFlowGraphGLTFDataProviderBlockConfiguration,
2597
2632
  FlowGraphGLTFDataProvider,
@@ -2880,6 +2915,11 @@ export declare class HDRCubeTexture extends BaseTexture {
2880
2915
  gammaSpace: boolean;
2881
2916
  level: number;
2882
2917
  /** Fires when the HDR environment is "ready" (resolved on a microtask). */
2883
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;
2884
2924
  private _ready;
2885
2925
  private readonly _readyPromise;
2886
2926
  constructor(url: string, _sceneOrEngine?: unknown, size?: number, _noMipmap?: boolean, _generateHarmonics?: boolean, _gammaSpace?: boolean, _prefilterOnLoad?: boolean, onLoad?: (() => void) | null);
@@ -3091,6 +3131,14 @@ export declare interface IEasingFunction {
3091
3131
  ease(gradient: number): number;
3092
3132
  }
3093
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
+
3094
3142
  export declare interface IFlowGraphValidationIssue {
3095
3143
  severity: FlowGraphValidationSeverity;
3096
3144
  message: string;
@@ -3186,6 +3234,28 @@ export declare interface IGaussianSplattingStreamOptions {
3186
3234
  hostCompound?: GaussianSplattingMesh;
3187
3235
  decodeSh?: boolean;
3188
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;
3189
3259
  }
3190
3260
 
3191
3261
  /** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
@@ -3836,6 +3906,7 @@ export declare class Matrix {
3836
3906
  multiplyToRef(other: Matrix, result: Matrix): Matrix;
3837
3907
  transpose(): Matrix;
3838
3908
  determinant(): number;
3909
+ /** Babylon.js `invert`: inverts this matrix in place and returns it. */
3839
3910
  invert(): Matrix;
3840
3911
  invertToRef(result: Matrix): Matrix;
3841
3912
  getTranslation(): Vector3;
@@ -4289,6 +4360,14 @@ export declare class Observable<T> {
4289
4360
  cleanLastNotifiedState(): void;
4290
4361
  }
4291
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
+
4292
4371
  /**
4293
4372
  * Minimal Babylon.js-compatible `Observable`.
4294
4373
  *
@@ -5004,8 +5083,10 @@ export declare class PointerEventTypes {
5004
5083
  export declare class PointerInfo {
5005
5084
  type: number;
5006
5085
  event: PointerEvent | WheelEvent;
5007
- private readonly _pickInfo;
5008
- 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. */
5009
5090
  get pickInfo(): PickingInfo | null;
5010
5091
  }
5011
5092
 
@@ -5102,8 +5183,12 @@ export declare class PositionGizmo extends GizmoBase {
5102
5183
  private _attached;
5103
5184
  set updateGizmoRotationToMatchAttachedMesh(value: boolean);
5104
5185
  get attachedMesh(): AbstractMesh | null;
5105
5186
  set attachedMesh(value: AbstractMesh | null);
5106
- get attachedNode(): AbstractMesh | null;
5107
- 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);
5108
5193
  dispose(): void;
5109
5194
  }
5110
5195
 
@@ -5160,6 +5245,7 @@ export declare class Quaternion {
5160
5245
  constructor(x?: number, y?: number, z?: number, w?: number);
5161
5246
  set(x: number, y: number, z: number, w: number): this;
5162
5247
  copyFrom(source: Quaternion): this;
5248
+ /** Babylon.js `multiply`: the product `this · other` as a new quaternion. */
5163
5249
  multiply(other: Quaternion): Quaternion;
5164
5250
  length(): number;
5165
5251
  normalize(): this;
@@ -5394,6 +5480,8 @@ export declare function RegisterSPLATFileLoader(): void;
5394
5480
 
5395
5481
  export declare function RegisterUSDFileLoader(): void;
5396
5482
 
5483
+ export declare function RemoveFlowGraphAnimationGroupObservers(_context: FlowGraphContext, _animationGroup: AnimationGroup): FlowGraphPlayAnimationBlock | undefined;
5484
+
5397
5485
  /** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
5398
5486
  export declare class RenderTargetTexture {
5399
5487
  constructor();
@@ -5461,8 +5549,12 @@ export declare class RotationGizmo extends GizmoBase {
5461
5549
  private _attached;
5462
5550
  set updateGizmoRotationToMatchAttachedMesh(value: boolean);
5463
5551
  get attachedMesh(): AbstractMesh | null;
5464
5552
  set attachedMesh(value: AbstractMesh | null);
5465
- get attachedNode(): AbstractMesh | null;
5466
- 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);
5467
5559
  dispose(): void;
5468
5560
  }
5469
5561
 
@@ -5491,8 +5583,12 @@ export declare class ScaleGizmo extends GizmoBase {
5491
5583
  private _attached;
5492
5584
  set updateGizmoRotationToMatchAttachedMesh(value: boolean);
5493
5585
  get attachedMesh(): AbstractMesh | null;
5494
5586
  set attachedMesh(value: AbstractMesh | null);
5495
- get attachedNode(): AbstractMesh | null;
5496
- 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);
5497
5593
  dispose(): void;
5498
5594
  }
5499
5595
 
@@ -5526,6 +5622,9 @@ export declare class Scene extends AbstractScene {
5526
5622
  /** Babylon.js fog-mode c
5527
5623
  private readonly _engine;
5528
5624
  private _activeCamera;
5529
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;
5530
5629
  private _defaultMaterial;
5531
5630
  private _fogMode;
5532
5631
  private _fogStart;
@@ -5533,6 +5632,8 @@ export declare class Scene extends AbstractScene {
5533
5632
  /** Babylon.js fog-mode c
5534
5633
  private _fogDensity;
5535
5634
  private _fogColor;
5536
5635
  private _started;
5537
5636
  private _envTexture;
5637
+ /** Environment lighting rotation last forwarded to Lite. */
5638
+ private _envRotation;
5538
5639
  private _brdfTexture;
5539
5640
  private _defaultEnvOptions;
5540
5641
  private readonly _shadowGenerators;
@@ -5622,6 +5723,13 @@ export declare class Scene extends AbstractScene {
5622
5723
  /** Babylon.js fog-mode c
5623
5724
  set clipPlane(value: Plane | null);
5624
5725
  get environmentTexture(): CubeTexture | HDRCubeTexture | null;
5625
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;
5626
5734
  /**
5627
5735
  * Babylon.js `scene.environmentBRDFTexture` — the BRDF lookup used by PBR materials.
5628
5736
  * Babylon.js defaults this to an embedded Base64 LUT and lets apps swap in one of the
@@ -5885,6 +5993,28 @@ export declare class SmartArray<T> {
5885
5993
  dispose(): void;
5886
5994
  }
5887
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
+
5888
6018
  export declare class SolidParticleSystem {
5889
6019
  constructor();
5890
6020
  }
@@ -6958,10 +7088,7 @@ export declare class WebGPUEngine extends AbstractEngine {
6958
7088
  }
6959
7089
 
6960
7090
  /** Babylon.js `WebGPUEngineOptions` subset accepted by the compat engine. */
6961
- export declare interface WebGPUEngineOptions extends EngineOptions {
6962
- antialias?: boolean;
6963
- adaptToDeviceRatio?: boolean;
6964
- useLargeWorldRendering?: boolean;
7091
+ export declare interface WebGPUEngineOptions extends AbstractEngineOptions {
6965
7092
  canvasToneMapping?: GPUCanvasToneMapping;
6966
7093
  canvasColorSpace?: PredefinedColorSpace;
6967
7094
  }