@babylonjs/lite-compat 1.32.0-preview → 1.34.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
@@ -120,15 +120,15 @@ overloads within a supported area may still be absent.
120
120
  | Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`, color temperature/white balance) | ✅ | `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/AABB picker; triangle-level positions, normals, and UVs 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) | ⚡ | 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 |
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
125
  | Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `ClusteredLightContainer` clusters point lights (⚡ partial); `RectAreaLight` unsupported |
126
126
  | Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` uses Lite's native 2–4 cascade CSM |
127
- | Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `clone`, `VertexData`, `Mesh.MergeMeshes`) | ⚡ | `CreateLines`/`CreateLineSystem` support fixed-topology line lists and RGBA point colors; `CreateDashedLines` supports uniform-color dashed line lists; mesh-blending tag helpers and validated mesh metadata forward to native Lite; `MergeMeshes` bakes positions/normals/UVs and rejects unsupported attributes/animation; `CreateDecal`/`CreateText`/`CreateTiledBox`/`CreateTiledPlane`, `GreasedLine*` (thick lines), `InstancedMesh`, LOD/edges/outline, hardware instances unsupported |
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; `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 `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;
@@ -595,11 +595,9 @@ export declare const ActionManagerTriggers: {
595
595
  readonly OnEveryFrameTrigger: 14;
596
596
  };
597
597
 
598
- /** Babylon.js `AddGaussianSplattingStreamPart` — appends a streamed LOD part to a GS compound mesh. */
599
- export declare function AddGaussianSplattingStreamPart(..._args: unknown[]): never;
598
+ export declare function AddGaussianSplattingStreamPart(_compound: GaussianSplattingMesh, _name: string, _metadata: ISOGLODMetadata, _rootUrl: string, _options?: IGaussianSplattingStreamOptions): never;
600
599
 
601
- /** Babylon.js `AddGaussianSplattingStreamPartAsync` — async variant of {@link AddGaussianSplattingStreamPart}. */
602
- export declare function AddGaussianSplattingStreamPartAsync(..._args: unknown[]): never;
600
+ export declare function AddGaussianSplattingStreamPartAsync(_compound: GaussianSplattingMesh, _name: string, _metadata: ISOGLODMetadata, _rootUrl: string, _options?: IGaussianSplattingStreamOptions): Promise<GaussianSplattingPartProxyMesh>;
603
601
 
604
602
  export declare class AmmoJSPlugin {
605
603
  constructor();
@@ -1586,6 +1584,12 @@ export declare function CreateMicrophoneSoundSourceAsync(name: string, options?:
1586
1584
  /** Babylon.js `CreatePlane(name, options, scene)` (planeBuilder). */
1587
1585
  export declare function CreatePlane(name: string, options: PlaneOptions, scene: Scene): Mesh;
1588
1586
 
1587
+ /** Babylon.js `CreatePolygon(name, options, scene?, earcutInjection?)` — throwing stub (see `MeshBuilder.CreatePolygon`). */
1588
+ export declare function CreatePolygon(name: string, options: PolygonBuilderOptions, scene?: Scene | null, earcutInjection?: unknown): never;
1589
+
1590
+ /** Babylon.js `CreatePolygonVertexData` — the polygon geometry generator requires the unsupported polygon subsystem. */
1591
+ export declare function CreatePolygonVertexData(_polygon: Mesh, _sideOrientation: number, _faceUV?: Vector4[], _faceColors?: Color4[], _frontUVs?: Vector4, _backUVs?: Vector4, _wrap?: boolean): never;
1592
+
1589
1593
  /** Babylon.js `CreateSoundAsync`. */
1590
1594
  export declare function CreateSoundAsync(name: string, source: StaticSoundSource, options?: Partial<IStaticSoundOptions>, engine?: AudioEngineV2 | null): Promise<StaticSound>;
1591
1595
 
@@ -1904,10 +1908,57 @@ export declare class EdgesRenderer {
1904
1908
  constructor();
1905
1909
  }
1906
1910
 
1911
+ export declare class Effect {
1912
+ constructor();
1913
+ isReady(): never;
1914
+ getEngine(): AbstractEngine;
1915
+ getCompilationError(): string;
1916
+ setTexture(_channel: string, _texture: BaseTexture): never;
1917
+ setFloat(_uniformName: string, _value: number): never;
1918
+ }
1919
+
1907
1920
  export declare class EffectLayer {
1908
1921
  constructor();
1909
1922
  }
1910
1923
 
1924
+ export declare class EffectWrapper {
1925
+ static ForceGLSL: boolean;
1926
+ static RegisterShaderCodeProcessing(_effectWrapperName: string | null, _customShaderCodeProcessing?: EffectWrapperCustomShaderCodeProcessing): never;
1927
+ constructor(_options: EffectWrapperCreationOptions);
1928
+ }
1929
+
1930
+ export declare interface EffectWrapperCreationOptions {
1931
+ engine?: AbstractEngine;
1932
+ fragmentShader?: string;
1933
+ useShaderStore?: boolean;
1934
+ vertexShader?: string;
1935
+ vertexUrl?: string;
1936
+ attributeNames?: string[];
1937
+ uniformNames?: string[];
1938
+ uniforms?: string[] | null;
1939
+ samplerNames?: string[];
1940
+ samplers?: string[] | null;
1941
+ uniformBuffers?: string[] | null;
1942
+ defines?: string | string[] | null;
1943
+ indexParameters?: any;
1944
+ blockCompilation?: boolean;
1945
+ onCompiled?: ((effect: Effect) => void) | null;
1946
+ onError?: (effect: Effect, errors: string) => void;
1947
+ name?: string;
1948
+ shaderLanguage?: ShaderLanguage;
1949
+ extraInitializations?: (useWebGPU: boolean, list: Promise<any>[]) => void;
1950
+ extraInitializationsAsync?: () => Promise<void>;
1951
+ useAsPostProcess?: boolean;
1952
+ allowEmptySourceTexture?: boolean;
1953
+ }
1954
+
1955
+ export declare type EffectWrapperCustomShaderCodeProcessing = {
1956
+ processCodeAfterIncludes?: (postProcessName: string, shaderType: string, code: string) => string;
1957
+ processFinalCode?: (postProcessName: string, shaderType: string, code: string) => string;
1958
+ defineCustomBindings?: (postProcessName: string, defines: string | null, uniforms: string[], samplers: string[]) => string | null;
1959
+ bindCustomBindings?: (postProcessName: string, effect: Effect) => void;
1960
+ };
1961
+
1911
1962
  export declare class ElasticEase extends EasingFunction {
1912
1963
  oscillations: number;
1913
1964
  springiness: number;
@@ -1940,6 +1991,23 @@ export declare class ExponentialEase extends EasingFunction {
1940
1991
  easeInCore(gradient: number): number;
1941
1992
  }
1942
1993
 
1994
+ /** Babylon.js `ExternalTexture` over Lite's caller-owned video wrapper. */
1995
+ export declare class ExternalTexture {
1996
+ private readonly _video;
1943
1997
  useMipMaps: boolean;
1998
+ readonly type = 16;
1999
+ readonly format = 4294967295;
2000
+ readonly uniqueId: number;
2001
+ static IsExternalTexture(texture: unknown): texture is ExternalTexture;
2002
+ constructor(_video: HTMLVideoElement);
2003
+ getClassName(): string;
2004
+ get underlyingResource(): HTMLVideoElement;
2005
+ isReady(): boolean;
2006
+ dispose(): void;
2007
+ }
2008
+
2009
+ /** Babylon.js `ExtrudePolygon(name, options, scene?, earcutInjection?)` — throwing stub (see `MeshBuilder.ExtrudePolygon`). */
2010
+ export declare function ExtrudePolygon(name: string, options: PolygonBuilderOptions, scene?: Scene | null, earcutInjection?: unknown): never;
2011
+
1944
2012
  /** A gradient value bound to a [0, 1] position (Babylon.js `FactorGradient`). */
1945
2013
  export declare class FactorGradient {
1946
2014
  gradient: number;
@@ -2132,6 +2200,11 @@ export declare class FrameGraphMeshBlendingTask {
2132
2200
  constructor(..._args: unknown[]);
2133
2201
  }
2134
2202
 
2203
+ /** Babylon.js 9.29 frame-graph min/max reduction task. */
2204
+ export declare class FrameGraphMinMaxReducerTask {
2205
+ constructor(..._args: unknown[]);
2206
+ }
2207
+
2135
2208
  /** Frames an `ArcRotateCamera` on a target by setting its radius (no zoom tween). */
2136
2209
  export declare class FramingBehavior implements Behavior<ArcRotateCamera> {
2137
2210
  readonly name = "Framing";
@@ -2212,15 +2285,54 @@ export declare class GaussianSplattingMesh extends TransformNode {
2212
2285
  /**
2213
2286
  /** Babylon.js `gs.bakeCurrentTransformIntoVertices()` — fold the node transform into the splat data. */
2214
2287
  bakeCurrentTransformIntoVertices(): void;
2215
2288
 
2216
- export declare class GaussianSplattingStream {
2217
- constructor(..._args: unknown[]);
2289
+ export declare class GaussianSplattingPartProxyMesh extends Mesh {
2290
+ readonly compoundSplatMesh: GaussianSplattingMesh;
2218
2291
  private readonly _partIndex;
2292
+ private _visibility;
2293
+ constructor(name: string, _scene: Scene | null, compoundSplatMesh: GaussianSplattingMesh, partIndex: number, _boundingInfo: BoundingInfo, vertexCount: number, splatsDataOffset: number, shDataOffset?: number);
2294
+ get partIndex(): number;
2295
+ get proxiedMesh(): GaussianSplattingMesh;
2296
+ getClassName(): string;
2297
+ get isVisible(): boolean;
2298
+ set isVisible(value: boolean);
2299
+ get visibility(): number;
2300
+ set visibility(value: number);
2301
+ updateBoundingInfoFromPartData(): never;
2302
+ updateBoundingInfoFromProxiedMesh(): never;
2303
+ updatePartIndex(_newPartIndex: number): never;
2304
+ updatePartMetadata(_vertexCount: number, _splatsDataOffset: number, _shDataOffset?: number): never;
2305
+ }
2306
+
2307
+ /** Babylon.js `GaussianSplattingStream` exact-shape stub pending a compatible Lite construction contract. */
2308
+ export declare class GaussianSplattingStream extends GaussianSplattingMesh {
2309
+ static IsLODMetadata(data: unknown): data is ISOGLODMetadata;
2310
+ constructor(name: string, _metadata: ISOGLODMetadata, _rootUrl: string, scene: Scene, _options?: IGaussianSplattingStreamOptions);
2311
+ getClassName(): string;
2312
+ isReady(_completeCheck?: boolean): never;
2313
+ get streamingPartProxy(): never;
2314
+ whenPartReadyAsync(): Promise<never>;
2315
+ whenSettledAsync(_stableFrames?: number): Promise<never>;
2316
+ get maxDetailLod(): never;
2317
+ set maxDetailLod(_value: number);
2318
+ get splatBudget(): never;
2319
+ set splatBudget(_value: number);
2320
+ get effectiveSplatBudget(): never;
2321
+ get residentSplatBudget(): never;
2219
2322
  get minimumResidentSplats(): never;
2323
+ get lod0SplatCount(): GaussianSplattingStreamLod0SplatCount;
2324
+ getBudgetDemand(): never;
2325
+ setBudgetAllocation(_splats: number | null): never;
2326
+ get maxLodLevel(): never;
2327
+ get frustumCulling(): never;
2328
+ set frustumCulling(_value: boolean);
2329
+ get debugDisplay(): never;
2330
+ set debugDisplay(_value: boolean);
2331
+ get debugLodSource(): never;
2332
+ set debugLodSource(_value: GaussianSplattingStreamDebugLodSource);
2333
+ evaluateOptimalLods(_camera?: unknown): never;
2220
2334
  }
2221
2335
 
2222
- /** Babylon.js `GaussianSplattingStreamDebugLodSource` — LOD debug source selector (shape-only stub for type parity). */
2223
2336
  export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
2224
2337
 
2225
- /** Babylon.js finest-LOD splat-count resolution state. */
2226
2338
  export declare type GaussianSplattingStreamLod0SplatCount = Readonly<{
2227
2339
  status: "pending";
2228
2340
  }> | Readonly<{
@@ -2877,14 +2989,58 @@ export declare interface IFlowGraphValidationResult {
2877
2989
  issuesByBlock: Map<string, IFlowGraphValidationIssue[]>;
2878
2990
  }
2879
2991
 
2880
- /** Babylon.js `IGaussianSplattingStreamingPart` — a streamed part of a GS compound mesh (shape-only stub for type parity). */
2881
2992
  export declare interface IGaussianSplattingStreamingPart {
2882
- [key: string]: unknown;
2993
+ readonly proxy: GaussianSplattingPartProxyMesh;
2994
+ readonly partIndex: number;
2995
+ readonly base: number;
2996
+ readonly capacity: number;
2997
+ readonly centersTexture: BaseTexture | null;
2998
+ readonly covariancesATexture: BaseTexture | null;
2999
+ readonly covariancesBTexture: BaseTexture | null;
3000
+ readonly colorsTexture: BaseTexture | null;
3001
+ readonly splatPositions: Float32Array | null;
3002
+ readonly mrtAtlas: unknown | null;
3003
+ readonly shMrtAtlas: unknown[] | null;
3004
+ readonly rotMrtAtlas: unknown | null;
3005
+ readonly atlasWidth: number;
3006
+ readonly isDepthSortSettled: boolean;
3007
+ setActiveRanges(localRanges: readonly {
3008
+ offset: number;
3009
+ count: number;
3010
+ }[] | null): void;
3011
+ writeSplats(localOffset: number, count: number, splatsData: ArrayBuffer | ArrayBufferView): void;
3012
+ postPositionsRange(localOffset: number, count: number): void;
3013
+ expandBounds(min: Vector3, max: Vector3): void;
3014
+ notifyDataChanged(): void;
3015
+ onBeforeAtlasRebuild(callback: (oldAtlas: unknown) => void): () => void;
3016
+ onAfterAtlasRebuild(callback: (newAtlas: unknown) => void): () => void;
2883
3017
  }
2884
3018
 
2885
- /** Babylon.js `IGaussianSplattingStreamOptions` — GS LOD stream options (shape-only stub for type parity). */
2886
3019
  export declare interface IGaussianSplattingStreamOptions {
2887
- [key: string]: unknown;
3020
+ deflateURL?: string;
3021
+ fflate?: unknown;
3022
+ debugDisplay?: boolean;
3023
+ debugLodSource?: GaussianSplattingStreamDebugLodSource;
3024
+ lodBaseDistance?: number;
3025
+ lodMultiplier?: number;
3026
+ lodBehindPenalty?: number;
3027
+ lodRangeMin?: number;
3028
+ lodRangeMax?: number;
3029
+ maxDecodesPerFrame?: number;
3030
+ lodCooldownFrames?: number;
3031
+ lodUpdateInterval?: number;
3032
+ lodUpdateDistance?: number;
3033
+ maxDetailLod?: number;
3034
+ frustumCulling?: boolean;
3035
+ maxConcurrentDownloads?: number;
3036
+ maxDownloadRetries?: number;
3037
+ memoryBudgetMb?: number;
3038
+ maxResidentSplats?: number;
3039
+ evictionCooldownFrames?: number;
3040
+ splatBudget?: number | "auto";
3041
+ hostCompound?: GaussianSplattingMesh;
3042
+ decodeSh?: boolean;
3043
+ needsRotationScale?: boolean;
2888
3044
  }
2889
3045
 
2890
3046
  /** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
@@ -3092,9 +3248,27 @@ export declare function IsHtmlInCanvasSupportedNatively(): never;
3092
3248
  /** Babylon.js `IsHtmlInCanvasUploadSupported` — kept in lockstep with the unavailable upload helper. */
3093
3249
  export declare function IsHtmlInCanvasUploadSupported(engine: AbstractEngine): boolean;
3094
3250
 
3095
- /** Babylon.js `ISOGLODMetadata` — SOG LOD octree metadata (shape-only stub for type parity). */
3251
+ declare interface ISOGLODEntry {
3252
+ file: number;
3253
+ offset: number;
3254
+ count: number;
3255
+ }
3256
+
3257
+ /** Babylon.js parsed PlayCanvas-style `lod-meta.json` shape. */
3096
3258
  export declare interface ISOGLODMetadata {
3097
- [key: string]: unknown;
3259
+ lodLevels: number;
3260
+ filenames: string[];
3261
+ environment?: string;
3262
+ tree: ISOGLODNode;
3263
+ }
3264
+
3265
+ declare interface ISOGLODNode {
3266
+ bound: {
3267
+ min: number[];
3268
+ max: number[];
3269
+ };
3270
+ children?: ISOGLODNode[];
3271
+ lods?: Record<string, ISOGLODEntry>;
3098
3272
  }
3099
3273
 
3100
3274
  /** Babylon.js `ISoundSourceOptions` (subset). */
@@ -3588,6 +3762,10 @@ export declare class Mesh extends AbstractMesh {
3588
3762
  static CreateCylinder(name: string, height: number, diameterTop: number, diameterBottom: number, tessellation: number, _subdivisions: number, scene: Scene): Mesh;
3589
3763
  /** Legacy `Mesh.CreateTorus(name, diameter, thickness, tessellation, scene)`. */
3590
3764
  static CreateTorus(name: string, diameter: number, thickness: number, tessellation: number, scene: Scene): Mesh;
3765
+ /** Legacy `Mesh.CreatePolygon(name, shape, scene, holes?, updatable?, sideOrientation?, earcutInjection?)`. */
3766
+ static CreatePolygon(_name: string, _shape: Vector3[], _scene: Scene, _holes?: Vector3[][], _updatable?: boolean, _sideOrientation?: number, _earcutInjection?: unknown): never;
3767
+ /** Legacy `Mesh.ExtrudePolygon(name, shape, depth, scene, holes?, updatable?, sideOrientation?, earcutInjection?)`. */
3768
+ static ExtrudePolygon(_name: string, _shape: Vector3[], _depth: number, _scene: Scene, _holes?: Vector3[][], _updatable?: boolean, _sideOrientation?: number, _earcutInjection?: unknown): never;
3591
3769
  /** Hardware-instanced copy — unsupported. Use native thin instances instead. */
3592
3770
  createInstance(): never;
3593
3771
  /**
@@ -3706,11 +3884,13 @@ export declare const MeshBuilder: {
3706
3884
  CreateText(): never;
3707
3885
  CreateTiledBox(_name?: string, _options?: object, _scene?: Scene): never;
3708
3886
  CreateTiledPlane(_name?: string, _options?: object, _scene?: Scene): never;
3887
+ CreatePolygon(_name: string, _options: PolygonBuilderOptions, _scene?: Scene | null, _earcutInjection?: unknown): never;
3888
+ ExtrudePolygon(_name: string, _options: PolygonBuilderOptions, _scene?: Scene | null, _earcutInjection?: unknown): never;
3709
3889
  };
3710
3890
 
3711
3891
  /** A compat mesh exposes its backing Lite mesh as `_lite`. */
3712
3892
  declare interface MeshLike {
3713
- _lite: Mesh_2;
3893
+ _lite: Mesh;
3714
3894
  }
3715
3895
 
3716
3896
  /**
@@ -3740,6 +3920,8 @@ export declare class MeshoptCompression {
3740
3920
  static get Default(): MeshoptCompression;
3741
3921
  }
3742
3922
 
3923
+ export declare type MeshPredicate = (mesh: AbstractMesh, thinInstanceIndex: number) => boolean;
3924
+
3743
3925
  export { MinTemperatureKelvin }
3744
3926
 
3745
3927
  export declare class MirrorTexture {
@@ -3899,6 +4081,11 @@ export declare class NodeRenderGraphMeshBlendingPostProcessBlock {
3899
4081
  constructor(..._args: unknown[]);
3900
4082
  }
3901
4083
 
4084
+ /** Babylon.js 9.29 node-render-graph min/max reduction block. */
4085
+ export declare class NodeRenderGraphMinMaxReducerBlock {
4086
+ constructor(..._args: unknown[]);
4087
+ }
4088
+
3902
4089
  /**
3903
4090
  * Babylon.js's `NullEngine` — a headless engine with no GPU device, used to run
3904
4091
  * scene logic (animations, observables, physics stepping, frame timing) without
@@ -4583,8 +4770,11 @@ export declare class PickingInfo {
4583
4770
  aimTransform: TransformNode | null;
4584
4771
  gripTransform: TransformNode | null;
4585
4772
  private _normal;
4586
- private _worldNormal;
4587
4773
  getNormal(useWorldCoordinates?: boolean, _useVerticesNormals?: boolean): Vector3 | null;
4588
- getTextureCoordinates(_uvSet?: string): Vector2 | null;
4774
+ private _worldNormal;
4775
+ private _faceNormal;
4776
+ private _faceWorldNormal;
4777
+ private _uv;
4589
4778
  getNormal(useWorldCoordinates?: boolean, useVerticesNormals?: boolean): Vector3 | null;
4779
+ getTextureCoordinates(uvSet?: string): Vector2 | null;
4590
4780
  }
4591
4781
 
4592
4782
  declare type PickListItem = PickableMesh | {
@@ -4718,6 +4908,26 @@ export declare class Polar {
4718
4908
  static FromArray(array: number[]): Polar;
4719
4909
  }
4720
4910
 
4911
+ /** Babylon.js polygon-builder namespace object. */
4912
+ export declare const PolygonBuilder: {
4913
+ ExtrudePolygon: typeof ExtrudePolygon;
4914
+ CreatePolygon: typeof CreatePolygon;
4915
+ };
4916
+
4917
+ declare interface PolygonBuilderOptions {
4918
+ shape: Vector3[];
4919
+ holes?: Vector3[][];
4920
+ depth?: number;
4921
+ smoothingThreshold?: number;
4922
+ faceUV?: Vector4[];
4923
+ faceColors?: Color4[];
4924
+ updatable?: boolean;
4925
+ sideOrientation?: number;
4926
+ frontUVs?: Vector4;
4927
+ backUVs?: Vector4;
4928
+ wrap?: boolean;
4929
+ }
4930
+
4721
4931
  export declare class PositionGizmo extends GizmoBase {
4722
4932
  private _attached;
4723
4933
  private _xGizmo;
4724
4934
  private _yGizmo;
@@ -4921,7 +5131,7 @@ export declare class RawTexture3D extends BaseTexture {
4921
5131
  readonly is3D = true;
4922
5132
  constructor(data: ArrayBufferView | null, width: number, height: number, depth: number,
4923
5133
  /** Babylon.js texture format (recorded for parity; Lite uploads RGBA8). */
4924
- format: number, scene: Scene, _generateMipMaps?: boolean, _invertY?: boolean, _samplingMode?: number, _textureType?: number, _creationFlags?: number);
5134
+ format: number, scene: Scene, generateMipMaps?: boolean, _invertY?: boolean, _samplingMode?: number, _textureType?: number, _creationFlags?: number);
4925
5135
  getClassName(): string;
4926
5136
  /** Gets the width of the texture. */
4927
5137
  get width(): number;
@@ -4993,8 +5203,17 @@ export declare function RegisterImageProcessingConfiguration(): void;
4993
5203
 
4994
5204
  export declare function RegisterMeshBlendingPostProcessBlock(): never;
4995
5205
 
5206
+ /** Babylon.js 9.29 node-render-graph registration function. */
5207
+ export declare function RegisterMinMaxReducerBlock(): never;
5208
+
4996
5209
  export declare function RegisterOpenpbrMaterial(): void;
4997
5210
 
5211
+ /**
5212
+ * Babylon.js side-effect registration shim. Compat defines the corresponding
5213
+ * methods directly, so importing or calling this function requires no mutation.
5214
+ */
5215
+ export declare function RegisterPolygonBuilder(): void;
5216
+
4998
5217
  export declare function RegisterSPLATFileLoader(): void;
4999
5218
 
5000
5219
  export declare function RegisterUSDFileLoader(): void;
@@ -5277,14 +5496,14 @@ export declare class Scene extends AbstractScene {
5277
5496
  /** Babylon.js fog-mode c
5278
5497
  /** Babylon.js synchronous readiness check — always ready in the compat layer. */
5279
5498
  isReady(): boolean;
5280
5499
  /** Babylon.js synchronous screen-coordinate picking over Lite's CPU ray picker. */
5281
- pick(x: number, y: number, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, camera?: Camera | null, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
5500
+ pick(x: number, y: number, predicate?: MeshPredicate, fastCheck?: boolean, camera?: Camera | null, trianglePredicate?: TrianglePickingPredicate): PickingInfo;
5282
5501
  /**
5283
5502
  * Babylon.js `Scene.createPickingRay` — translate CSS coordinates and camera
5284
5503
  * transforms into Lite's reverse-Z unprojection helper.
5285
5504
  */
5286
5505
  createPickingRay(x: number, y: number, world?: Matrix | null, camera?: Camera | null, cameraViewSpace?: boolean): Ray;
5287
5506
  /** Synchronous CPU ray picking over Babylon Lite's scene-mesh picker. */
5288
- pickWithRay(ray: Ray, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
5289
5507
  /**
5508
+ pickWithRay(ray: Ray, predicate?: MeshPredicate, fastCheck?: boolean, trianglePredicate?: TrianglePickingPredicate): PickingInfo;
5290
5509
  /**
5291
5510
  * Babylon.js `scene.enablePhysics(gravity, plugin)`. Wires the given Havok V2
5292
5511
  * {@link HavokPlugin} to this scene, creating the native Lite physics world and
5293
5512
  * registering per-frame stepping. The plugin's `useDeltaForWorldStep` flag
@@ -6174,6 +6393,8 @@ export declare class TransformNode extends Node_2 {
6174
6393
  physicsBody: PhysicsBody
6175
6394
 
6176
6395
  export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
6177
6396
 
6397
+ export declare type TrianglePickingPredicate = (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray, i0: number, i1: number, i2: number) => boolean;
6398
+
6178
6399
  /** Minimum Babylon.js UniformBuffer surface needed to author compute bindings. */
6179
6400
  export declare class UniformBuffer {
6180
6401
  private readonly _engine;
@@ -6525,6 +6746,8 @@ export declare class VertexData {
6525
6746
  uvs: number[] | Float32Array | null;
6526
6747
  colors: number[] | Float32Array | null;
6527
6748
  indices: number[] | Uint32Array | Uint16Array | null;
6749
+ /** Deprecated Babylon.js polygon vertex-data entry point. */
6750
+ static CreatePolygon(polygon: Mesh, sideOrientation: number, faceUV?: Vector4[], faceColors?: Color4[], frontUVs?: Vector4, backUVs?: Vector4, wrap?: boolean): never;
6528
6751
  /**
6529
6752
  * Babylon.js `VertexData.applyToMesh(mesh)` — upload this CPU geometry onto a
6530
6753
  * mesh (typically one created via `new Mesh(name, scene)`). Replaces the Lite
@@ -6559,6 +6782,15 @@ export declare class VirtualJoystick {
6559
6782
  export declare class WebGPUEngine extends AbstractEngine {
6560
6783
  }
6561
6784
 
6785
+ /** Babylon.js `WebGPUEngineOptions` subset accepted by the compat engine. */
6786
+ export declare interface WebGPUEngineOptions extends EngineOptions {
6787
+ antialias?: boolean;
6788
+ adaptToDeviceRatio?: boolean;
6789
+ useLargeWorldRendering?: boolean;
6790
+ canvasToneMapping?: GPUCanvasToneMapping;
6791
+ canvasColorSpace?: PredefinedColorSpace;
6792
+ }
6793
+
6562
6794
  /** Babylon.js `WebXRCamera` — WebXR is not part of Babylon Lite. */
6563
6795
  export declare class WebXRCamera {
6564
6796
  constructor();