@babylonjs/lite-compat 1.33.0-preview → 1.35.0-preview

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -117,18 +117,18 @@ overloads within a supported area may still be absent.
117
117
 
118
118
  | Feature area | Status | Notes |
119
119
  | ----------------------------------------------------------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
120
- | Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`, color temperature/white balance) | ✅ | `Angle` / `Curve3` / `Path3D` partial |
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
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 |
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
- | Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | sync `scene.pick` forwards to Lite's CPU triangle picker with thin-instance, predicate, normal, and UV detail; actively deformed meshes still require async `GPUPicker`; `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 |
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 |
125
- | Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `ClusteredLightContainer` clusters point lights (⚡ partial); `RectAreaLight` unsupported |
125
+ | Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `ClusteredLightContainer` clusters unshadowed point lights before engine start (⚡ partial); clustered spot lights and `RectAreaLight` unsupported |
126
126
  | Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` uses Lite's native 2–4 cascade CSM |
127
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
128
  | CSG / CSG2 | ✅ | over Lite boolean ops |
129
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 `DitheredTileFadeMaterialPlugin`, GLSL `ShaderMaterial`, `MultiMaterial`, `BackgroundMaterial`, and `OpenPBRMaterial` remain unsupported |
131
- | Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `HtmlTexture`, `CubeTexture`, `HDRCubeTexture`) | ⚡ | `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 |
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
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
133
  | Morph targets (`MorphTarget` / `MorphTargetManager`) | ✅ | over Lite morph targets |
134
134
  | Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported |
@@ -149,7 +149,7 @@ overloads within a supported area may still be absent.
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`) | ⚡ | via `GaussianSplattingMesh` and the binary-data `SPLATFileLoader` plugin surface; detached containers, unpackaged/streaming SOG, replaceable decoder policies, and full glTF-embedded (`KHR_gaussian_splatting`) variants remain unsupported |
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 |
153
153
  | `OBJ` / `STL` / `FBX` / `BVH` | ❌ | parser/materializer subsystems are not in Lite — convert to glTF |
154
154
 
155
155
  ### `@babylonjs/addons` · `@recast-navigation/*`
package/index.d.ts CHANGED
@@ -132,11 +132,11 @@ export declare abstract class AbstractEngine {
132
132
  */
133
133
  useReverseDepthBuffer: boolean;
134
134
  /** Babylon.js `engine.onResizeObservable` — fires after `resize()` / `setSize()`. */
135
- readonly onResizeObservable: Observable<AbstractEngine>;
136
135
  constructor(canvas: RenderCanvas, options?: ({
137
- antialias?: boolean;
138
- adaptToDeviceRatio?: boolean;
139
- useLargeWorldRendering?: boolean;
140
- } & EngineOptions) | boolean);
136
+ readonly onResizeObservable: Observable<AbstractEngine>;
137
+ /** Babylon.js context-loss signal, forwarded from Lite's device-loss subscription. */
138
+ readonly onContextLostObservable: Observable<AbstractEngine>;
139
+ /** Babylon.js context-restored signal. Lite does not expose a completed-recovery event, so this remains shape-only. */
140
+ readonly onContextRestoredObservable: Observable<AbstractEngine>;
141
141
  constructor(canvas: RenderCanvas, options?: WebGPUEngineOptions | boolean);
142
142
  /** Acquire the GPU device and build the Lite engine context. */
143
143
  initAsync(): Promise<void>;
144
144
  getRenderingCanvas(): RenderCanvas;
@@ -532,6 +532,10 @@ export declare class AbstractStereoAudio {
532
532
  set pan(value: number);
533
533
  }
534
534
 
535
+ declare type AccessibilityAria = "aria-autocomplete" | "aria-checked" | "aria-disabled" | "aria-errormessage" | "aria-expanded" | "aria-haspopup" | "aria-hidden" | "aria-invalid" | "aria-label" | "aria-level" | "aria-modal" | "aria-multiline" | "aria-multiselectable" | "aria-orientation" | "aria-placeholder" | "aria-pressed" | "aria-readonly" | "aria-required" | "aria-selected" | "aria-sort" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "aria-busy" | "aria-live" | "aria-relevant" | "aria-atomic" | "aria-dropeffect" | "aria-grabbed" | "aria-activedescendant" | "aria-colcount" | "aria-colindex" | "aria-colspan" | "aria-controls" | "aria-describedby" | "aria-description" | "aria-details" | "aria-flowto" | "aria-labelledby" | "aria-owns" | "aria-posinset" | "aria-rowcount" | "aria-rowindex" | "aria-rowspan" | "aria-setsize";
536
+
537
+ declare type AccessibilityRole = "toolbar" | "tooltip" | "feed" | "math" | "presentation" | "none" | "note" | "application" | "article" | "cell" | "columnheader" | "definition" | "directory" | "document" | "figure" | "group" | "heading" | "img" | "list" | "listitem" | "meter" | "row" | "rowgroup" | "rowheader" | "separator" | "table" | "term" | "scrollbar" | "searchbox" | "slider" | "spinbutton" | "switch" | "tab" | "tabpanel" | "treeitem" | "combobox" | "menu" | "menubar" | "tablist" | "tree" | "treegrid" | "banner" | "complementary" | "contentinfo" | "form" | "main" | "navigation" | "region" | "search" | "alert" | "log" | "marquee" | "status" | "timer" | "alertdialog" | "dialog";
538
+
535
539
  /** Base class for actions. `execute` is implemented by subclasses. */
536
540
  export declare abstract class Action {
537
541
  trigger: number;
@@ -595,11 +599,9 @@ export declare const ActionManagerTriggers: {
595
599
  readonly OnEveryFrameTrigger: 14;
596
600
  };
597
601
 
598
- /** Babylon.js `AddGaussianSplattingStreamPart` — appends a streamed LOD part to a GS compound mesh. */
599
- export declare function AddGaussianSplattingStreamPart(..._args: unknown[]): never;
602
+ export declare function AddGaussianSplattingStreamPart(_compound: GaussianSplattingMesh, _name: string, _metadata: ISOGLODMetadata, _rootUrl: string, _options?: IGaussianSplattingStreamOptions): never;
600
603
 
601
- /** Babylon.js `AddGaussianSplattingStreamPartAsync` — async variant of {@link AddGaussianSplattingStreamPart}. */
602
- export declare function AddGaussianSplattingStreamPartAsync(..._args: unknown[]): never;
604
+ export declare function AddGaussianSplattingStreamPartAsync(_compound: GaussianSplattingMesh, _name: string, _metadata: ISOGLODMetadata, _rootUrl: string, _options?: IGaussianSplattingStreamOptions): Promise<GaussianSplattingPartProxyMesh>;
603
605
 
604
606
  export declare class AmmoJSPlugin {
605
607
  constructor();
@@ -1314,15 +1316,14 @@ export declare class CircleEase extends EasingFunction {
1314
1316
  export declare class ClusteredLightContainer extends Light {
1315
1317
  private _maxRange;
1316
1318
  private _selfIntensity;
1317
1319
  /**
1318
- * True if a point/spot light can be clustered by this container. Babylon Lite
1319
- * clusters point lights only.
1320
+ * True if this point light can be represented by Lite's clustered payload.
1320
1321
  */
1321
1322
  static IsLightSupported(light: Light): boolean;
1322
1323
  /**
1323
1324
  * Creates a new clustered light container.
1324
1325
  *
1325
1326
  * @param name - The container's node name.
1326
- * @param lights - Initial lights to cluster (point lights).
1327
+ * @param lights - Initial point lights to cluster.
1327
1328
  * @param scene - Owning scene; when supplied the container is registered and
1328
1329
  * built into the Lite scene at engine start.
1329
1330
  */
@@ -1350,7 +1351,7 @@ export declare class ClusteredLightContainer extends Light {
1350
1351
  private _maxRan
1351
1352
  */
1352
1353
  get maxRange(): number;
1353
1354
  set maxRange(value: number);
1354
- /** Babylon.js `container.addLight(light)`. Only point lights are clustered. */
1355
+ /** Babylon.js `container.addLight(light)`. */
1355
1356
  addLight(light: Light): void;
1356
1357
  /**
1357
1358
  * Babylon.js `container.removeLight(light)`. Returns the index the light held
@@ -1910,10 +1911,57 @@ export declare class EdgesRenderer {
1910
1911
  constructor();
1911
1912
  }
1912
1913
 
1914
+ export declare class Effect {
1915
+ constructor();
1916
+ isReady(): never;
1917
+ getEngine(): AbstractEngine;
1918
+ getCompilationError(): string;
1919
+ setTexture(_channel: string, _texture: BaseTexture): never;
1920
+ setFloat(_uniformName: string, _value: number): never;
1921
+ }
1922
+
1913
1923
  export declare class EffectLayer {
1914
1924
  constructor();
1915
1925
  }
1916
1926
 
1927
+ export declare class EffectWrapper {
1928
+ static ForceGLSL: boolean;
1929
+ static RegisterShaderCodeProcessing(_effectWrapperName: string | null, _customShaderCodeProcessing?: EffectWrapperCustomShaderCodeProcessing): never;
1930
+ constructor(_options: EffectWrapperCreationOptions);
1931
+ }
1932
+
1933
+ export declare interface EffectWrapperCreationOptions {
1934
+ engine?: AbstractEngine;
1935
+ fragmentShader?: string;
1936
+ useShaderStore?: boolean;
1937
+ vertexShader?: string;
1938
+ vertexUrl?: string;
1939
+ attributeNames?: string[];
1940
+ uniformNames?: string[];
1941
+ uniforms?: string[] | null;
1942
+ samplerNames?: string[];
1943
+ samplers?: string[] | null;
1944
+ uniformBuffers?: string[] | null;
1945
+ defines?: string | string[] | null;
1946
+ indexParameters?: any;
1947
+ blockCompilation?: boolean;
1948
+ onCompiled?: ((effect: Effect) => void) | null;
1949
+ onError?: (effect: Effect, errors: string) => void;
1950
+ name?: string;
1951
+ shaderLanguage?: ShaderLanguage;
1952
+ extraInitializations?: (useWebGPU: boolean, list: Promise<any>[]) => void;
1953
+ extraInitializationsAsync?: () => Promise<void>;
1954
+ useAsPostProcess?: boolean;
1955
+ allowEmptySourceTexture?: boolean;
1956
+ }
1957
+
1958
+ export declare type EffectWrapperCustomShaderCodeProcessing = {
1959
+ processCodeAfterIncludes?: (postProcessName: string, shaderType: string, code: string) => string;
1960
+ processFinalCode?: (postProcessName: string, shaderType: string, code: string) => string;
1961
+ defineCustomBindings?: (postProcessName: string, defines: string | null, uniforms: string[], samplers: string[]) => string | null;
1962
+ bindCustomBindings?: (postProcessName: string, effect: Effect) => void;
1963
+ };
1964
+
1917
1965
  export declare class ElasticEase extends EasingFunction {
1918
1966
  oscillations: number;
1919
1967
  springiness: number;
@@ -1946,6 +1994,20 @@ export declare class ExponentialEase extends EasingFunction {
1946
1994
  easeInCore(gradient: number): number;
1947
1995
  }
1948
1996
 
1997
+ /** Babylon.js `ExternalTexture` over Lite's caller-owned video wrapper. */
1998
+ export declare class ExternalTexture {
1999
+ private readonly _video;
1949
2000
  useMipMaps: boolean;
2001
+ readonly type = 16;
2002
+ readonly format = 4294967295;
2003
+ readonly uniqueId: number;
2004
+ static IsExternalTexture(texture: unknown): texture is ExternalTexture;
2005
+ constructor(_video: HTMLVideoElement);
2006
+ getClassName(): string;
2007
+ get underlyingResource(): HTMLVideoElement;
2008
+ isReady(): boolean;
2009
+ dispose(): void;
2010
+ }
2011
+
1950
2012
  /** Babylon.js `ExtrudePolygon(name, options, scene?, earcutInjection?)` — throwing stub (see `MeshBuilder.ExtrudePolygon`). */
1951
2013
  export declare function ExtrudePolygon(name: string, options: PolygonBuilderOptions, scene?: Scene | null, earcutInjection?: unknown): never;
1952
2014
 
@@ -2141,6 +2203,11 @@ export declare class FrameGraphMeshBlendingTask {
2141
2203
  constructor(..._args: unknown[]);
2142
2204
  }
2143
2205
 
2206
+ /** Babylon.js 9.29 frame-graph min/max reduction task. */
2207
+ export declare class FrameGraphMinMaxReducerTask {
2208
+ constructor(..._args: unknown[]);
2209
+ }
2210
+
2144
2211
  /** Frames an `ArcRotateCamera` on a target by setting its radius (no zoom tween). */
2145
2212
  export declare class FramingBehavior implements Behavior<ArcRotateCamera> {
2146
2213
  readonly name = "Framing";
@@ -2177,6 +2244,19 @@ export declare class GamepadCamera extends UniversalCamera {
2177
2244
  getClassName(): string;
2178
2245
  }
2179
2246
 
2247
+ export declare class GaussianSplattingDebugMaterialPlugin extends MaterialPluginBase {
2180
2248
  constructor(material: GaussianSplattingMaterial);
2249
+ }
2250
+
2251
+ export declare class GaussianSplattingGpuPickingMaterialPlugin extends MaterialPluginBase {
2252
+ static EncodeIdToColor(id: number): [number, number, number];
2181
2253
  constructor(material: GaussianSplattingMaterial, _maxPartCount?: number);
2254
+ }
2255
+
2256
+ export declare class GaussianSplattingMaterial extends PushMaterial {
2182
2257
  constructor(name: string, scene?: Scene);
2258
+ clone(_name: string): GaussianSplattingMaterial;
2259
+ }
2260
+
2261
+ export declare const GaussianSplattingMaxPartCount = 128;
2262
+
2183
2263
  /**
2184
2264
  * Babylon.js `GaussianSplattingMesh`. Derives from `TransformNode` so the loaded
2185
2265
  * cloud's `position` / `rotation` / `scaling` proxy onto the Lite splat node.
@@ -2221,15 +2301,71 @@ export declare class GaussianSplattingMesh extends TransformNode {
2221
2301
  /**
2222
2302
  /** Babylon.js `gs.bakeCurrentTransformIntoVertices()` — fold the node transform into the splat data. */
2223
2303
  bakeCurrentTransformIntoVertices(): void;
2224
2304
 
2225
- export declare class GaussianSplattingStream {
2226
- constructor(..._args: unknown[]);
2305
+ export declare class GaussianSplattingOverdrawMaterialPlugin extends MaterialPluginBase {
2227
2306
  constructor(material: GaussianSplattingMaterial);
2307
+ get isEnabled(): boolean;
2308
+ set isEnabled(_value: boolean);
2309
+ get intensity(): number;
2310
+ set intensity(_value: number);
2311
+ }
2312
+
2313
+ export declare class GaussianSplattingPartProxyMesh extends Mesh {
2314
+ readonly compoundSplatMesh: GaussianSplattingMesh;
2228
2315
  private readonly _partIndex;
2316
+ private _visibility;
2317
+ constructor(name: string, _scene: Scene | null, compoundSplatMesh: GaussianSplattingMesh, partIndex: number, _boundingInfo: BoundingInfo, vertexCount: number, splatsDataOffset: number, shDataOffset?: number);
2318
+ get partIndex(): number;
2319
+ get proxiedMesh(): GaussianSplattingMesh;
2320
+ getClassName(): string;
2321
+ get isVisible(): boolean;
2322
+ set isVisible(value: boolean);
2323
+ get visibility(): number;
2324
+ set visibility(value: number);
2325
+ updateBoundingInfoFromPartData(): never;
2326
+ updateBoundingInfoFromProxiedMesh(): never;
2327
+ updatePartIndex(_newPartIndex: number): never;
2328
+ updatePartMetadata(_vertexCount: number, _splatsDataOffset: number, _shDataOffset?: number): never;
2329
+ }
2330
+
2331
+ export declare class GaussianSplattingSizeMaterialPlugin extends MaterialPluginBase {
2229
2332
  constructor(material: GaussianSplattingMaterial);
2333
+ get isEnabled(): boolean;
2334
+ set isEnabled(_value: boolean);
2335
+ get sizeScale(): number;
2336
+ set sizeScale(_value: number);
2337
+ }
2338
+
2339
+ export declare class GaussianSplattingSolidColorMaterialPlugin extends MaterialPluginBase {
2230
2340
  constructor(material: GaussianSplattingMaterial, _partColors: Color3[], _maxPartCount?: number);
2341
+ }
2342
+
2343
+ /** Babylon.js `GaussianSplattingStream` exact-shape stub pending a compatible Lite construction contract. */
2344
+ export declare class GaussianSplattingStream extends GaussianSplattingMesh {
2345
+ static IsLODMetadata(data: unknown): data is ISOGLODMetadata;
2346
+ constructor(name: string, _metadata: ISOGLODMetadata, _rootUrl: string, scene: Scene, _options?: IGaussianSplattingStreamOptions);
2347
+ getClassName(): string;
2348
+ isReady(_completeCheck?: boolean): never;
2349
+ get streamingPartProxy(): never;
2350
+ whenPartReadyAsync(): Promise<never>;
2351
+ whenSettledAsync(_stableFrames?: number): Promise<never>;
2352
+ get maxDetailLod(): never;
2353
+ set maxDetailLod(_value: number);
2354
+ get splatBudget(): never;
2355
+ set splatBudget(_value: number);
2356
+ get effectiveSplatBudget(): never;
2357
+ get residentSplatBudget(): never;
2231
2358
  get minimumResidentSplats(): never;
2359
+ get lod0SplatCount(): GaussianSplattingStreamLod0SplatCount;
2360
+ getBudgetDemand(): never;
2361
+ setBudgetAllocation(_splats: number | null): never;
2362
+ get maxLodLevel(): never;
2363
+ get frustumCulling(): never;
2364
+ set frustumCulling(_value: boolean);
2365
+ get debugDisplay(): never;
2366
+ set debugDisplay(_value: boolean);
2367
+ get debugLodSource(): never;
2368
+ set debugLodSource(_value: GaussianSplattingStreamDebugLodSource);
2369
+ evaluateOptimalLods(_camera?: unknown): never;
2232
2370
  }
2233
2371
 
2234
- /** Babylon.js `GaussianSplattingStreamDebugLodSource` — LOD debug source selector (shape-only stub for type parity). */
2235
2372
  export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
2236
2373
 
2237
- /** Babylon.js finest-LOD splat-count resolution state. */
2238
2374
  export declare type GaussianSplattingStreamLod0SplatCount = Readonly<{
2239
2375
  status: "pending";
2240
2376
  }> | Readonly<{
@@ -2278,6 +2414,10 @@ export declare class GeospatialClippingBehavior {
2278
2414
  /** Babylon.js `GetElementPixelFromUv` — HTML overlay raycast interaction is unsupported by the compat layer. */
2279
2415
  export declare function GetElementPixelFromUv(): never;
2280
2416
 
2417
+ export declare function GetGaussianSplattingMaxPartCount(engine: AbstractEngine): number;
2418
+
2419
+ export declare function GetPartIndexVaryingDeclaration(shaderLanguage: ShaderLanguage): string;
2420
+
2281
2421
  export declare function GetPointsCount(..._args: unknown[]): never;
2282
2422
 
2283
2423
  /**
@@ -2746,6 +2886,17 @@ export declare interface IAbstractSoundOptions extends Partial<IVolumeAudioOptio
2746
2886
  outBus?: PrimaryAudioBus;
2747
2887
  }
2748
2888
 
2889
+ export declare interface IAccessibilityTag {
2890
+ description?: string;
2891
+ eventHandler?: {
2892
+ [K in keyof HTMLElementEventMap]: (event?: Event) => void;
2893
+ };
2894
+ role?: AccessibilityRole;
2895
+ aria?: {
2896
+ [K in AccessibilityAria]: any;
2897
+ };
2898
+ }
2899
+
2749
2900
  export declare interface IAnimationKey {
2750
2901
  frame: number;
2751
2902
  value: AnimationValue;
@@ -2886,14 +3037,80 @@ export declare interface IFlowGraphValidationResult {
2886
3037
  issuesByBlock: Map<string, IFlowGraphValidationIssue[]>;
2887
3038
  }
2888
3039
 
2889
- /** Babylon.js `IGaussianSplattingStreamingPart` — a streamed part of a GS compound mesh (shape-only stub for type parity). */
3040
+ export declare interface IGaussianSplattingDebugOptions {
3041
+ clippingBox: {
3042
+ min: Vector3;
3043
+ max: Vector3;
3044
+ } | null;
3045
+ opacityCulling: {
3046
+ min: number;
3047
+ max: number;
3048
+ } | null;
3049
+ sizeCulling: {
3050
+ min: number;
3051
+ max: number;
3052
+ } | null;
3053
+ opacityScale: number;
3054
+ opacitySaturate: boolean;
3055
+ shDc: boolean;
3056
+ shOrder1: boolean;
3057
+ shOrder2: boolean;
3058
+ shOrder3: boolean;
3059
+ shOrder4: boolean;
3060
+ }
3061
+
2890
3062
  export declare interface IGaussianSplattingStreamingPart {
2891
- [key: string]: unknown;
3063
+ readonly proxy: GaussianSplattingPartProxyMesh;
3064
+ readonly partIndex: number;
3065
+ readonly base: number;
3066
+ readonly capacity: number;
3067
+ readonly centersTexture: BaseTexture | null;
3068
+ readonly covariancesATexture: BaseTexture | null;
3069
+ readonly covariancesBTexture: BaseTexture | null;
3070
+ readonly colorsTexture: BaseTexture | null;
3071
+ readonly splatPositions: Float32Array | null;
3072
+ readonly mrtAtlas: unknown | null;
3073
+ readonly shMrtAtlas: unknown[] | null;
3074
+ readonly rotMrtAtlas: unknown | null;
3075
+ readonly atlasWidth: number;
3076
+ readonly isDepthSortSettled: boolean;
3077
+ setActiveRanges(localRanges: readonly {
3078
+ offset: number;
3079
+ count: number;
3080
+ }[] | null): void;
3081
+ writeSplats(localOffset: number, count: number, splatsData: ArrayBuffer | ArrayBufferView): void;
3082
+ postPositionsRange(localOffset: number, count: number): void;
3083
+ expandBounds(min: Vector3, max: Vector3): void;
3084
+ notifyDataChanged(): void;
3085
+ onBeforeAtlasRebuild(callback: (oldAtlas: unknown) => void): () => void;
3086
+ onAfterAtlasRebuild(callback: (newAtlas: unknown) => void): () => void;
2892
3087
  }
2893
3088
 
2894
- /** Babylon.js `IGaussianSplattingStreamOptions` — GS LOD stream options (shape-only stub for type parity). */
2895
3089
  export declare interface IGaussianSplattingStreamOptions {
2896
- [key: string]: unknown;
3090
+ deflateURL?: string;
3091
+ fflate?: unknown;
3092
+ debugDisplay?: boolean;
3093
+ debugLodSource?: GaussianSplattingStreamDebugLodSource;
3094
+ lodBaseDistance?: number;
3095
+ lodMultiplier?: number;
3096
+ lodBehindPenalty?: number;
3097
+ lodRangeMin?: number;
3098
+ lodRangeMax?: number;
3099
+ maxDecodesPerFrame?: number;
3100
+ lodCooldownFrames?: number;
3101
+ lodUpdateInterval?: number;
3102
+ lodUpdateDistance?: number;
3103
+ maxDetailLod?: number;
3104
+ frustumCulling?: boolean;
3105
+ maxConcurrentDownloads?: number;
3106
+ maxDownloadRetries?: number;
3107
+ memoryBudgetMb?: number;
3108
+ maxResidentSplats?: number;
3109
+ evictionCooldownFrames?: number;
3110
+ splatBudget?: number | "auto";
3111
+ hostCompound?: GaussianSplattingMesh;
3112
+ decodeSh?: boolean;
3113
+ needsRotationScale?: boolean;
2897
3114
  }
2898
3115
 
2899
3116
  /** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
@@ -3101,9 +3318,27 @@ export declare function IsHtmlInCanvasSupportedNatively(): never;
3101
3318
  /** Babylon.js `IsHtmlInCanvasUploadSupported` — kept in lockstep with the unavailable upload helper. */
3102
3319
  export declare function IsHtmlInCanvasUploadSupported(engine: AbstractEngine): boolean;
3103
3320
 
3104
- /** Babylon.js `ISOGLODMetadata` — SOG LOD octree metadata (shape-only stub for type parity). */
3321
+ declare interface ISOGLODEntry {
3322
+ file: number;
3323
+ offset: number;
3324
+ count: number;
3325
+ }
3326
+
3327
+ /** Babylon.js parsed PlayCanvas-style `lod-meta.json` shape. */
3105
3328
  export declare interface ISOGLODMetadata {
3106
- [key: string]: unknown;
3329
+ lodLevels: number;
3330
+ filenames: string[];
3331
+ environment?: string;
3332
+ tree: ISOGLODNode;
3333
+ }
3334
+
3335
+ declare interface ISOGLODNode {
3336
+ bound: {
3337
+ min: number[];
3338
+ max: number[];
3339
+ };
3340
+ children?: ISOGLODNode[];
3341
+ lods?: Record<string, ISOGLODEntry>;
3107
3342
  }
3108
3343
 
3109
3344
  /** Babylon.js `ISoundSourceOptions` (subset). */
@@ -3549,6 +3784,14 @@ export declare class Matrix {
3549
3784
  static RotationZ(angle: number): Matrix;
3550
3785
  /** Babylon.js `Matrix.LookAtLH(eye, target, up)` — left-handed view matrix. */
3551
3786
  static LookAtLH(eye: Vector3, target: Vector3, up: Vector3): Matrix;
3787
+ /** Babylon.js `Matrix.LookDirectionLH(forward, up)` orientation matrix. */
3788
+ static LookDirectionLH(forward: Vector3, up: Vector3): Matrix;
3789
+ /** Babylon.js `Matrix.LookDirectionLHToRef(forward, up, result)`. */
3790
+ static LookDirectionLHToRef<T extends Matrix>(forward: Vector3, up: Vector3, result: T): T;
3791
+ /** Babylon.js `Matrix.LookDirectionRH(forward, up)` orientation matrix. */
3792
+ static LookDirectionRH(forward: Vector3, up: Vector3): Matrix;
3793
+ /** Babylon.js `Matrix.LookDirectionRHToRef(forward, up, result)`. */
3794
+ static LookDirectionRHToRef<T extends Matrix>(forward: Vector3, up: Vector3, result: T): T;
3552
3795
  /** Babylon.js `Matrix.OrthoOffCenterLH(left, right, bottom, top, znear, zfar, halfZRange?)` — LH ortho projection. */
3553
3796
  static OrthoOffCenterLH(left: number, right: number, bottom: number, top: number, znear: number, zfar: number, _halfZRange?: boolean): Matrix;
3554
3797
  /**
@@ -3803,14 +4046,16 @@ declare abstract class Node_2 {
3803
4046
  readonly uniqueId: number;
3804
4047
  /** Free-form user data slot (Babylon.js `Node.metadata`). */
3805
4048
  metadata: unknown;
3806
- readonly onDisposeObservable: Observable<Node_2>;
3807
4049
  protected constructor(name: string, scene?: Scene);
4050
+ readonly onDisposeObservable: Observable<Node_2>;
4051
+ onAccessibilityTagChangedObservable: Observable<IAccessibilityTag | null>;
3808
4052
  protected constructor(name: string, scene?: Scene);
3809
4053
  /** The runtime class name (overridden by each subclass). */
3810
4054
  getClassName(): string;
3811
4055
  /** The scene this node belongs to, if any. */
3812
4056
  getScene(): Scene | undefined;
3813
4057
  /** The engine backing this node's scene, if any. */
3814
4058
  getEngine(): WebGPUEngine | undefined;
3815
- get parent(): Node_2 | null;
4059
+ get accessibilityTag(): IAccessibilityTag | null;
4060
+ set accessibilityTag(value: IAccessibilityTag | null);
3816
4061
  get parent(): Node_2 | null;
3817
4062
  set parent(value: Node_2 | null);
3818
4063
  /**
3819
4064
  * Babylon.js `node.getDescendants(directDescendantsOnly?, predicate?)` — the
3820
4065
  * nodes parented (directly or transitively) under this one, optionally filtered.
@@ -3916,6 +4161,11 @@ export declare class NodeRenderGraphMeshBlendingPostProcessBlock {
3916
4161
  constructor(..._args: unknown[]);
3917
4162
  }
3918
4163
 
4164
+ /** Babylon.js 9.29 node-render-graph min/max reduction block. */
4165
+ export declare class NodeRenderGraphMinMaxReducerBlock {
4166
+ constructor(..._args: unknown[]);
4167
+ }
4168
+
3919
4169
  /**
3920
4170
  * Babylon.js's `NullEngine` — a headless engine with no GPU device, used to run
3921
4171
  * scene logic (animations, observables, physics stepping, frame timing) without
@@ -4864,6 +5114,15 @@ export declare class Quaternion {
4864
5114
  * `matrix` into `result`. Backed by Lite's `createQuatFromRotationMat4`.
4865
5115
  */
4866
5116
  static FromRotationMatrixToRef(matrix: Matrix, result: Quaternion): Quaternion;
5117
+ /** Babylon.js `Quaternion.FromLookDirectionLH(forward, up)`. */
5118
+ static FromLookDirectionLH(forward: Vector3, up: Vector3): Quaternion;
5119
+ /** Babylon.js `Quaternion.FromLookDirectionLHToRef(forward, up, result)`. */
5120
+ static FromLookDirectionLHToRef<T extends Quaternion>(forward: Vector3, up: Vector3, result: T): T;
5121
+ /** Babylon.js `Quaternion.FromLookDirectionRH(forward, up)`. */
5122
+ static FromLookDirectionRH(forward: Vector3, up: Vector3): Quaternion;
5123
+ /** Babylon.js `Quaternion.FromLookDirectionRHToRef(forward, up, result)`. */
5124
+ static FromLookDirectionRHToRef<T extends Quaternion>(forward: Vector3, up: Vector3, result: T): T;
5125
+ private static _FromRotationStorageToRef;
4867
5126
  static FromEulerAngles(x: number, y: number, z: number): Quaternion;
4868
5127
  static RotationYawPitchRoll(yaw: number, pitch: number, roll: number): Quaternion;
4869
5128
  static RotationAxis(axis: Vector3, angle: number): Quaternion;
@@ -5026,6 +5285,18 @@ export declare function RegisterEnginesWebGPUExtensionsEngineTexture2DArrayImage
5026
5285
 
5027
5286
  export declare function RegisterFluidRenderer(): void;
5028
5287
 
5288
+ export declare function RegisterGaussianSplattingDebugMaterialPlugin(): void;
5289
+
5290
+ export declare function RegisterGaussianSplattingGpuPickingMaterialPlugin(): void;
5291
+
5292
+ export declare function RegisterGaussianSplattingMaterial(): void;
5293
+
5294
+ export declare function RegisterGaussianSplattingOverdrawMaterialPlugin(): void;
5295
+
5296
+ export declare function RegisterGaussianSplattingSizeMaterialPlugin(): void;
5297
+
5298
+ export declare function RegisterGaussianSplattingSolidColorMaterialPlugin(): void;
5299
+
5029
5300
  export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
5030
5301
 
5031
5302
  /** Babylon.js pure-module registration hook. */
@@ -5033,6 +5304,9 @@ export declare function RegisterImageProcessingConfiguration(): void;
5033
5304
 
5034
5305
  export declare function RegisterMeshBlendingPostProcessBlock(): never;
5035
5306
 
5307
+ /** Babylon.js 9.29 node-render-graph registration function. */
5308
+ export declare function RegisterMinMaxReducerBlock(): never;
5309
+
5036
5310
  export declare function RegisterOpenpbrMaterial(): void;
5037
5311
 
5038
5312
  /**
@@ -6609,6 +6883,15 @@ export declare class VirtualJoystick {
6609
6883
  export declare class WebGPUEngine extends AbstractEngine {
6610
6884
  }
6611
6885
 
6886
+ /** 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;
6891
+ canvasToneMapping?: GPUCanvasToneMapping;
6892
+ canvasColorSpace?: PredefinedColorSpace;
6893
+ }
6894
+
6612
6895
  /** Babylon.js `WebXRCamera` — WebXR is not part of Babylon Lite. */
6613
6896
  export declare class WebXRCamera {
6614
6897
  constructor();