@babylonjs/lite-compat 1.39.1 → 1.39.3

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/CHANGELOG.md CHANGED
@@ -1,8 +1,36 @@
1
1
  # Changelog
2
2
 
3
- ## @babylonjs/lite v1.39.1
3
+ ## @babylonjs/lite v1.39.3
4
4
 
5
- _No notable changes since npm-lite-v1.39.0._
5
+ ### ⚠️ BREAKING CHANGES
6
+
7
+ - **scene:** add per-family scene collections for text, depth-hosted sprites, and billboards ([#907](https://github.com/BabylonJS/Babylon-Lite/pull/907))
8
+
9
+ ### ✨ Features
10
+
11
+ - **compat:** wrap native SSAO2 rendering pipeline ([#908](https://github.com/BabylonJS/Babylon-Lite/pull/908))
12
+ - add public texture pixel readback ([#906](https://github.com/BabylonJS/Babylon-Lite/pull/906))
13
+ - **compat:** wrap HTML-in-Canvas polyfill lifecycle ([#903](https://github.com/BabylonJS/Babylon-Lite/pull/903))
14
+ - **compat:** support texture replacement and stub indirect submeshes ([#901](https://github.com/BabylonJS/Babylon-Lite/pull/901))
15
+ - **compat:** sync bent normals and BJS 9.35 APIs ([#896](https://github.com/BabylonJS/Babylon-Lite/pull/896))
16
+ - **engine:** add createDevice for early WebGPU device acquisition ([#900](https://github.com/BabylonJS/Babylon-Lite/pull/900))
17
+
18
+ ### 🐛 Bug Fixes
19
+
20
+ - **ktx2:** retry failed transcoder WASM fetches ([#905](https://github.com/BabylonJS/Babylon-Lite/pull/905))
21
+ - **texture:** restore HTML texture elements relocated by HTML-in-Canvas polyfills ([#897](https://github.com/BabylonJS/Babylon-Lite/pull/897))
22
+ - **build:** rewrite all static Lite error messages ([#899](https://github.com/BabylonJS/Babylon-Lite/pull/899))
23
+ - **demos:** repair ambient occlusion deployment and controls ([#894](https://github.com/BabylonJS/Babylon-Lite/pull/894))
24
+
25
+ ### 🏗️ Build & CI
26
+
27
+ - add dependency review workflow ([#904](https://github.com/BabylonJS/Babylon-Lite/pull/904))
28
+
29
+ ### 🔧 Other Changes
30
+
31
+ - Clone rotation fix ([#893](https://github.com/BabylonJS/Babylon-Lite/pull/893))
32
+
33
+ **Full Changelog**: https://github.com/BabylonJS/Babylon-Lite/compare/npm-lite-v1.39.0...npm-lite-v1.39.3
6
34
 
7
35
  ## @babylonjs/lite v1.39.0
8
36
 
package/README.md CHANGED
@@ -127,8 +127,8 @@ overloads within a supported area may still be absent.
127
127
  | Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `clone`, `VertexData`, `Mesh.MergeMeshes`) | ⚡ | Gaussian GPU-sort helper math is available and GPU-sort preferences preserve Lite's CPU-worker fallback; explicit GPU sorter/output resource classes still throw. `CreateLines`/`CreateLineSystem`, dashed lines, mesh metadata/blending tags, and common merges work; polygon/decal/text/tiled builders, thick lines, instances, LOD/edges/outline remain unsupported |
128
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 Gaussian-splat visualization plugins, `DitheredTileFadeMaterialPlugin`, BJS-preprocessed `ShaderMaterial`, `MultiMaterial`, `BackgroundMaterial`, and `OpenPBRMaterial` remain unsupported |
131
- | Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `HtmlTexture`, `ExternalTexture`, cube textures) | ⚡ | New texture/scatter processors support exact constant-only paths; textured operands need BJS's missing procedural render-target pipeline and throw. Arrays, base-level 3D volumes, dynamic/HTML/external textures, and cube environments work; `RenderTargetTexture` / `MirrorTexture` remain unsupported |
130
+ | Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | Includes native bent-normal IBL occlusion and cloned loaded PBR materials; BJS parallax scale semantics, Gaussian-splat plugins, preprocessed `ShaderMaterial`, `MultiMaterial`, `BackgroundMaterial`, and `OpenPBRMaterial` remain unsupported |
131
+ | Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `HtmlTexture`, `ExternalTexture`, cube textures) | ⚡ | URL textures support ready-image replacement with material rebinding. Texture/scatter processors support exact constant-only paths; textured operands need BJS's missing procedural render-target pipeline and throw. Arrays, base-level 3D volumes, dynamic/HTML/external textures, and cube environments work; `RenderTargetTexture` / `MirrorTexture` remain unsupported |
132
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, including named loader-produced targets and live influence writes |
134
134
  | Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported |
@@ -137,7 +137,7 @@ overloads within a supported area may still be absent.
137
137
  | Audio V2 (`AudioEngineV2`, `StaticSound`, `StreamingSound`, `AudioBus`, buses/sources/analyzer) | ⚡ | over Lite's AudioV2 port; `MainAudioBus` spatial/analyzer and a second main bus unsupported |
138
138
  | Physics (`HavokPlugin`, `scene.enablePhysics`/`getPhysicsEngine`, `PhysicsAggregate`/`PhysicsBody`/`PhysicsShape`) | ⚡ | Native Havok V2 forwarding for common body/shape operations, thin-instance bodies, and filtered raycasts with instance indices; unrecognized enum values throw at the compat boundary |
139
139
  | Particles (`NodeParticleSystemSet` / `ParticleSystemSet` — Node Particle Editor) | ⚡ | NPE snippet/JSON graphs: `Parse`/`ParseFromSnippetAsync` → `buildAsync` → `start`, with stable named systems through both `set.systems` and `scene.particleSystems`, plus `isStarted`; imperative classic/GPU/solid construction and programmatic block authoring remain unsupported |
140
- | Post-processes, layers (glow/highlight), probes, WebXR | ❌ | Babylon.js wrapper classes are not implemented — use native Lite `create*Task` functions, including `createMeshBlendingPostProcessTask` with geometry-renderer tag/depth/albedo outputs |
140
+ | Post-processes, layers (glow/highlight), probes, WebXR | ❌ | Babylon.js wrapper classes remain unsupported; Lite SSAO has materially different sampling/intensity/blur semantics and is available through native tasks |
141
141
 
142
142
  ### `@babylonjs/loaders`
143
143
 
@@ -148,7 +148,7 @@ overloads within a supported area may still be absent.
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
- | `SceneLoader` (`ImportMeshAsync` / `AppendAsync` / `LoadAssetContainerAsync`), `AssetsManager` | ⚡ | `AssetContainer` partial |
151
+ | `SceneLoader` (`ImportMeshAsync` / `AppendAsync` / `LoadAssetContainerAsync`), `AssetsManager` | ⚡ | `AssetContainer` supports canonical loaded handles and clone-backed `instantiateModelsToScene` for non-animated/non-skinned hierarchies |
152
152
  | Gaussian Splatting (`.ply` / `.splat` / `.sog` / `.spz`) | ⚡ | `GaussianSplattingMesh` wraps eager Lite loaders and Lite's opt-in point renderer; point render scale supports `"auto"` or exact `1 / n` multipliers for divisors 1–8. BJS streaming and standalone point-renderer/blit classes remain named stubs |
153
153
  | `OBJ` / `STL` / `FBX` / `BVH` | ❌ | parser/materializer subsystems are not in Lite — convert to glTF |
154
154
 
package/index.d.ts CHANGED
@@ -132,6 +132,9 @@ export declare abstract class AbstractEngine {
132
132
  * configuration internally, so this is a settable no-op kept for API shape.
133
133
  */
134
134
  useReverseDepthBuffer: boolean;
135
+ private _maxFramesInFlight;
136
+ get maxFramesInFlight(): number;
137
+ set maxFramesInFlight(value: number);
135
138
  /** Babylon.js `engine.onResizeObservable` — fires after `resize()` / `setSize()`. */
136
139
  readonly onResizeObservable: Observable<AbstractEngine>;
137
140
  /** Babylon.js context-loss signal, forwarded from Lite's device-loss subscription. */
@@ -878,7 +881,7 @@ export declare class AreaLightTextureTools {
878
881
  constructor(engine: AbstractEng
879
882
 
880
883
  export declare class AssetContainer {
881
884
  private readonly _dispose;
882
885
  private _sceneDisposeObserver;
883
886
  private _disposed;
884
- constructor(lite: AssetContainer_2, dispose?: () => void, ownedMeshes?: readonly Mesh_2[]);
887
+ constructor(lite: AssetContainer_2, dispose?: () => void, ownedMeshes?: readonly Mesh_2[], scene?: Scene);
885
888
  get animationGroups(): AnimationGroup_2[];
886
889
  /**
887
890
  * Flat list of the loaded meshes as canonical, stable-identity compat `Mesh`
@@ -888,6 +891,18 @@ export declare class AssetContainer {
888
891
  private readonly _dispose;
889
892
  private
890
893
  */
891
894
  get meshes(): Mesh[];
892
895
  get skeletons(): Skeleton[];
896
+ /**
897
+ * Babylon.js `AssetContainer.instantiateModelsToScene` for clone-backed Lite
898
+ * hierarchies. Materials can be cloned independently; animation/skeleton
899
+ * retargeting remains outside Lite's clone contract.
900
+ */
901
+ instantiateModelsToScene(nameFunction?: (sourceName: string) => string, cloneMaterials?: boolean, options?: {
902
+ doNotInstantiate?: boolean;
903
+ }): {
904
+ rootNodes: TransformNode[];
905
+ skeletons: Skeleton[];
906
+ animationGroups: AnimationGroup_2[];
907
+ };
893
908
  /** Add every entity, animation group, camera, and clear colour to the scene. */
894
909
  addAllToScene(scene: Scene): void;
895
910
  dispose(): void;
896
911
  private _detachFromScene;
@@ -1088,7 +1103,9 @@ export declare class BaseSixDofDragBehavior {
1088
1103
  }
1089
1104
 
1090
1105
  export declare abstract class BaseTexture {
1091
- name: string;
1092
1106
  getClassName(): string;
1093
1107
  /**
1108
+ name: string;
1109
+ private _level;
1094
1110
  get level(): number;
1111
+ set level(value: number);
1095
1112
  getClassName(): string;
1096
1113
  /**
1097
1114
  * Babylon.js `BaseTexture.getInternalTexture()` — the backend texture handle. Babylon.js
1098
1115
  * returns an `InternalTexture`; the compat layer's equivalent is the Lite texture handle,
1099
1116
  * which is what the compat engine's texture methods accept.
@@ -1787,8 +1804,7 @@ export declare class CubeTexture extends BaseTexture {
1787
1804
  readonly url: string;
1788
1805
  /** Babylon.js `coordinatesMode` (skybox = 5). Recorded for API parity. */
1789
1806
  coordinatesMode: number;
1790
- gammaSpace: boolean;
1791
- level: number;
1792
1807
  /** Fires when the cube map is "ready" (resolved on a microtask in this compat layer). */
1808
+ gammaSpace: boolean;
1793
1809
  /** Fires when the cube map is "ready" (resolved on a microtask in this compat layer). */
1794
1810
  readonly onLoadObservable: Observable<CubeTexture>;
1795
1811
  /**
1796
1812
  * Babylon.js `CubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
@@ -1870,6 +1886,23 @@ declare interface DefaultEnvironmentOptions {
1870
1886
  /** Babylon.js EnvironmentHelper tone-mapping toggle (default true). */
1871
1887
  toneMappingEnabled?: boolean;
1872
1888
 
1889
+ export declare class DefaultKTX2EncoderOptions {
1890
+ private _dirty;
1891
+ private _etc1sQualityLevel;
1892
+ private _etc1sCompressionLevel;
1893
+ private _uastcQualityLevel;
1894
+ private _zstandard;
1895
+ get isDirty(): boolean;
1896
+ get etc1sQualityLevel(): number | undefined;
1897
+ set etc1sQualityLevel(value: number | undefined);
1898
+ get etc1sCompressionLevel(): number | undefined;
1899
+ set etc1sCompressionLevel(value: number | undefined);
1900
+ get uastcQualityLevel(): number | undefined;
1901
+ set uastcQualityLevel(value: number | undefined);
1902
+ get zstandard(): boolean | undefined;
1903
+ set zstandard(value: boolean | undefined);
1904
+ }
1905
+
1873
1906
  export declare class DefaultRenderingPipeline {
1874
1907
  constructor();
1875
1908
  }
@@ -3127,8 +3160,7 @@ export declare class HDRCubeTexture extends BaseTexture {
3127
3160
  readonly size: number;
3128
3161
  /** Babylon.js `coordinatesMode` (skybox = 5). Recorded for API parity. */
3129
3162
  coordinatesMode: number;
3130
- gammaSpace: boolean;
3131
- level: number;
3132
3163
  /** Fires when the HDR environment is "ready" (resolved on a microtask). */
3164
+ gammaSpace: boolean;
3133
3165
  /** Fires when the HDR environment is "ready" (resolved on a microtask). */
3134
3166
  readonly onLoadObservable: Observable<HDRCubeTexture>;
3135
3167
  /**
3136
3168
  * Babylon.js `HDRCubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
@@ -3553,6 +3585,16 @@ export declare interface IKeyboardEvent extends IUIEvent {
3553
3585
  repeat?: boolean;
3554
3586
  }
3555
3587
 
3588
+ export declare interface IKTX2EncoderOptions {
3589
+ usage: KTX2EncoderUsage;
3590
+ generateMipmaps?: boolean;
3591
+ flipY?: boolean;
3592
+ etc1sQualityLevel?: number;
3593
+ etc1sCompressionLevel?: number;
3594
+ uastcQualityLevel?: number;
3595
+ zstandard?: boolean;
3596
+ }
3597
+
3556
3598
  /**
3557
3599
  * Minimal Babylon.js `ImageProcessingConfiguration` facade over Lite's image
3558
3600
  * processing state.
@@ -3665,7 +3707,13 @@ export declare class IncrementValueAction extends Action {
3665
3707
  /** Babylon.js `InitializeCSG2Async()` — load the Manifold runtime before any `CSG2` use. */
3666
3708
  export declare function InitializeCSG2Async(): Promise<void>;
3667
3709
 
3668
- /** Babylon.js `InstallHtmlInCanvasPolyfill` — the HTML-in-canvas polyfill is unsupported by the compat layer. */
3710
+ /**
3711
+ * Babylon.js `InstallHtmlInCanvasPolyfill`.
3712
+ *
3713
+ * The installed polyfill would redirect Lite to an incompatible positional
3714
+ * upload API, so exposing the installer without changing Lite's hot path would
3715
+ * break otherwise-working HTML textures.
3716
+ */
3669
3717
  export declare function InstallHtmlInCanvasPolyfill(): never;
3670
3718
 
3671
3719
  /** Babylon.js `InstancedMesh` — hardware instances are not modelled; use thin instances. */
@@ -3743,7 +3791,13 @@ export declare interface ISceneLoaderProgressEvent {
3743
3791
  /** Babylon.js internal polyfill-state query. Compat never installs the unsupported polyfill. */
3744
3792
  export declare function _IsHtmlInCanvasPolyfillInstalled(): boolean;
3745
3793
 
3746
- /** Babylon.js `IsHtmlInCanvasSupportedNatively` — the HTML-in-canvas feature is unsupported by the compat layer. */
3794
+ /**
3795
+ * Babylon.js `IsHtmlInCanvasSupportedNatively`.
3796
+ *
3797
+ * The legacy polyfill uses a positional upload signature that Lite's existing
3798
+ * HTML texture module cannot consume without adding feature branches to a
3799
+ * module already included by HTML-texture users.
3800
+ */
3747
3801
  export declare function IsHtmlInCanvasSupportedNatively(): never;
3748
3802
 
3749
3803
  /** Babylon.js `IsHtmlInCanvasUploadSupported` — kept in lockstep with the unavailable upload helper. */
@@ -3979,6 +4033,19 @@ export declare const KHR_materials_variants: {
3979
4033
  Reset(rootMesh: unknown): void;
3980
4034
  };
3981
4035
 
4036
+ export declare class KhronosTextureContainer2Encoder {
4037
+ static get URLConfig(): {
4038
+ jsEncoderModule: string;
4039
+ jsBasisEncoder: string;
4040
+ wasmBasisEncoder: string;
4041
+ };
4042
+ static DefaultNumWorkers: number;
4043
+ static get DefaultEncoderOptions(): DefaultKTX2EncoderOptions;
4044
+ constructor();
4045
+ }
4046
+
4047
+ export declare type KTX2EncoderUsage = "color" | "data" | "normal";
4048
+
3982
4049
  /** Babylon.js `LastCreatedAudioEngine()` — the most recently created engine, if any. */
3983
4050
  export declare function LastCreatedAudioEngine(): AudioEngineV2 | null;
3984
4051
 
@@ -4127,6 +4194,8 @@ export declare class MainAudioBus extends AbstractAudioBus {
4127
4194
  getClassName():
4128
4195
  protected _spatialHost(): AudioGraphHost;
4129
4196
  }
4130
4197
 
4198
+ export declare function MapSRGBToLinear(format: number): number | null;
4199
+
4131
4200
  /** Babylon.js `Material` — base class for all materials. */
4132
4201
  export declare abstract class Material {
4133
4202
  name: string;
4134
4203
  /** Babylon.js plugin manager, created lazily by the first `MaterialPluginBase`. */
@@ -4936,8 +5005,7 @@ export declare class PBRIridescenceConfiguration {
4936
5005
 
4937
5006
  export declare class PBRMaterial extends PushMaterial {
4938
5007
  private _albedoFactor;
4939
5008
  constructor(name: string, scene?: Scene);
4940
- getClassName(): string;
4941
- get albedoColor(): Color3;
5009
+ getClassName(): string;
4942
5010
  get albedoColor(): Color3;
4943
5011
  set albedoColor(value: Color3);
4944
5012
  /**
4945
5013
  * Babylon.js `pbr.albedoTexture` (glTF base-color map). The texture loads
@@ -4947,6 +5015,11 @@ export declare class PBRMaterial extends PushMaterial {
4947
5015
  private _albedoFacto
4948
5016
  get albedoTexture(): BaseTexture | null;
4949
5017
  set albedoTexture(texture: BaseTexture | null);
4950
5018
  private _albedoTexture;
5019
+ private _bentNormalTexture;
5020
+ private _bentNormalLevelUnsubscribe;
5021
+ /** Babylon.js `PBRMaterial.bentNormalTexture` over Lite's native IBL occlusion extension. */
5022
+ get bentNormalTexture(): BaseTexture | null;
5023
+ set bentNormalTexture(texture: BaseTexture | null);
4951
5024
  /**
4952
5025
  * Enumerate every bound PBR texture slot, including extension sub-configurations
4953
5026
  * (Babylon.js `PBRMaterial.getActiveTextures`).
@@ -5005,7 +5078,8 @@ export declare class PBRMaterial extends PushMaterial {
5005
5078
  private _albedoFacto
5006
5079
  * clearcoat/sheen/anisotropy/iridescence sub-configurations (sharing any nested
5007
5080
  * texture), and a fresh Lite PBR renderable.
5008
5081
  */
5009
- clone(name: string): PBRMaterial;
5082
+ clone(name: string): PBRMaterial;
5010
5083
  dispose(): void;
5084
+ }
5011
5085
 
5012
5086
  /**
5013
5087
  * Babylon.js `PBRMetallicRoughnessMaterial` — a simplified façade over
@@ -5023,7 +5097,8 @@ export declare class PBRMetallicRoughnessMaterial extends PBRMaterial {
5023
5097
  export declare class PBRSheenConfiguration {
5024
5098
  private readonly _props;
5025
5099
  private readonly _markDirty;
5026
- constructor(_props: SheenProps, _markDirty: () => void);
5100
+ private readonly _watchTexture;
5101
+ constructor(_props: SheenProps, _markDirty: () => void, _watchTexture: (texture: BaseTexture | null) => void);
5027
5102
  get isEnabled(): boolean;
5028
5103
  set isEnabled(value: boolean);
5029
5104
  get intensity(): number;
@@ -5036,9 +5111,9 @@ export declare class PBRSheenConfiguration {
5036
5111
  get texture(): BaseTexture | null;
5037
5112
  set texture(value: BaseTexture | null);
5038
5113
  private _texture;
5114
+ private _textureAssigned;
5039
5115
  /** Enumerate the sheen texture slot for `Material.getActiveTextures`. */
5040
- getActiveTextures(): BaseTexture[];
5041
- }
5116
+ getActiveTextures(): BaseTexture[];
5042
5117
 
5043
5118
  /**
5044
5119
  * Babylon.js `PBRSpecularGlossinessMaterial` — the spec/gloss workflow is
@@ -5570,6 +5645,27 @@ export declare class PostProcess {
5570
5645
  constructor();
5571
5646
  }
5572
5647
 
5648
+ /** Babylon.js post-process pipeline shape consumed by the manager. */
5649
+ export declare interface PostProcessRenderPipeline {
5573
5650
  readonly isSupported: boolean;
5574
5651
  dispose(): void;
5652
+ }
5653
+
5654
+ /** Babylon.js-compatible post-process pipeline registry for native Lite-backed pipelines. */
5655
+ export declare class PostProcessRenderPipelineManager {
5656
+ private readonly _renderPipelines;
5657
+ private readonly _onNewPipelineAddedObservable;
5658
+ private readonly _onPipelineRemovedObservable;
5659
+ get onNewPipelineAddedObservable(): Observable<PostProcessRenderPipeline>;
5660
+ get onPipelineRemovedObservable(): Observable<PostProcessRenderPipeline>;
5661
+ get supportedPipelines(): PostProcessRenderPipeline[];
5662
+ addPipeline(renderPipeline: PostProcessRenderPipeline): void;
5663
+ removePipeline(renderPipelineName: string): void;
5664
+ attachCamerasToRenderPipeline(renderPipelineName: string, cameras: Camera[] | Camera, unique?: boolean): void;
5665
+ detachCamerasFromRenderPipeline(renderPipelineName: string, cameras: Camera[] | Camera): void;
5666
+ enableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras: Camera[] | Camera): void;
5667
+ disableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras: Camera[] | Camera): void;
5668
+ update(): void;
5575
5669
  dispose(): void;
5670
+ }
5671
+
5576
5672
  /**
5577
5673
  * Babylon.js-compatible power easing class.
5578
5674
  */
@@ -5688,6 +5784,11 @@ export declare class QuinticEase extends EasingFunction {
5688
5784
  */
5689
5785
  export declare function RandomGUID(): string;
5690
5786
 
5787
+ declare type Ratio = number | {
5788
+ ssaoRatio?: number;
5789
+ blurRatio?: number;
5790
+ };
5791
+
5691
5792
  /**
5692
5793
  * Babylon.js `RawTexture` — a texture created from raw pixel bytes. Backed by
5693
5794
  * Babylon Lite's `createTexture2DFromPixels`; the GPU handle is available
@@ -6051,15 +6152,18 @@ export declare class Scene extends AbstractScene {
6051
6152
  /** Babylon.js fog-mode c
6052
6153
  private readonly _skeletonCache;
6053
6154
  private readonly _skeletons;
6054
6155
  private readonly _particleSystemCache;
6156
+ private readonly _loadedMaterialCache;
6055
6157
  private readonly _particleSystems;
6056
6158
  private readonly _retiredParticleSystems;
6057
6159
  private _disposed;
6058
6160
  private _ambientColor;
6059
6161
  private _environmentIntensity;
6060
- private _imageProcessingConfiguration;
6061
6162
  /** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
6163
+ private _imageProcessingConfiguration;
6164
+ private _postProcessRenderPipelineManager;
6062
6165
  /** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
6063
6166
  readonly uniqueId: number;
6064
6167
  constructor(engine: WebGPUEngine);
6065
6168
  private _attachPointerEvents;
6066
6169
  private _detachPointerEvents;
6067
6170
  getEngine(): WebGPUEngine;
6171
+ get postProcessRenderPipelineManager(): PostProcessRenderPipelineManager;
6068
6172
  /** Babylon.js `scene.getClassName()`. */
6069
6173
  getClassName(): string;
6070
6174
  /** Babylon.js `scene.getUniqueId()` — the process-unique scene id. */
@@ -6738,15 +6842,83 @@ export declare class SpriteRenderer {
6738
6842
  */
6739
6843
  render(sprites: readonly ThinSpriteLike[], _deltaTime?: number, _view?: unknown, _projection?: unknown): void;
6740
6844
 
6845
+ /** Babylon.js-shaped adapter over Babylon Lite's native scene SSAO pipeline. */
6741
6846
  export declare class SSAO2RenderingPipeline {
6742
- constructor();
6847
+ private static _uniqueIdSource;
6848
+ readonly SSAOOriginalSceneColorEffect = "SSAOOriginalSceneColorEffect";
6849
+ readonly SSAORenderEffect = "SSAORenderEffect";
6850
+ readonly SSAOBlurHRenderEffect = "SSAOBlurHRenderEffect";
6851
+ readonly SSAOBlurVRenderEffect = "SSAOBlurVRenderEffect";
6852
+ readonly SSAOCombineRenderEffect = "SSAOCombineRenderEffect";
6853
+ readonly isSupported: boolean;
6854
+ readonly uniqueId: number;
6743
6855
  private readonly _scene;
6856
+ private readonly _ratio;
6857
+ private readonly _forceGeometryBuffer;
6858
+ private readonly _textureType;
6859
+ private readonly _resolutionScale;
6860
+ private _native;
6861
+ private _camera;
6862
+ private _disposed;
6863
+ private _radius;
6864
+ private _totalStrength;
6865
+ private _base;
6866
+ private _maxZ;
6867
+ private _minZAspect;
6868
+ private _epsilon;
6869
+ private _samples;
6870
+ private _expensiveBlur;
6871
+ private _bypassBlur;
6872
+ private _bilateralSamples;
6873
+ private _bilateralSoften;
6874
+ private _bilateralTolerance;
6875
+ private _useViewportInCombineStage;
6876
+ private _textureSamples;
6877
+ private readonly _warned;
6878
+ readonly cameras: Camera[];
6879
+ constructor(name: string, scene: Scene, ratio: Ratio, cameras?: Camera[], forceGeometryBuffer?: boolean | object, textureType?: number);
6880
+ get radius(): number;
6881
+ set radius(value: number);
6882
+ get totalStrength(): number;
6883
+ set totalStrength(value: number);
6884
+ get base(): number;
6885
+ set base(value: number);
6886
+ get maxZ(): number;
6887
+ set maxZ(value: number);
6888
+ get minZAspect(): number;
6889
+ set minZAspect(value: number);
6890
+ get epsilon(): number;
6891
+ set epsilon(value: number);
6892
+ get samples(): number;
6893
+ set samples(value: number);
6894
+ get expensiveBlur(): boolean;
6895
+ get bypassBlur(): boolean;
6896
+ set bypassBlur(value: boolean);
6897
+ get bilateralSamples(): number;
6898
+ set bilateralSamples(value: number);
6899
+ get bilateralSoften(): number;
6900
+ set bilateralSoften(value: number);
6901
+ get bilateralTolerance(): number;
6902
+ set bilateralTolerance(value: number);
6903
+ get useViewportInCombineStage(): boolean;
6904
+ set useViewportInCombineStage(value: boolean);
6905
+ set expensiveBlur(value: boolean);
6906
+ get textureSamples(): number;
6907
+ set textureSamples(value: number);
6908
+ getClassName(): string;
6909
+ get name(): string;
6910
+ get engine(): AbstractEngine;
6911
+ get scene(): Scene;
6912
+ static get IsSupported(): boolean;
6913
+ static Parse(source: Record<string, unknown>, scene: Scene): SSAO2RenderingPipeline;
6914
+ isReady(): boolean;
6915
+ serialize(): Record<string, unknown>;
6744
6916
  dispose(_disableGeometryBufferRenderer?: boolean): void;
6917
+ private _warnUnsupported;
6745
6918
  }
6746
6919
 
6747
6920
  export declare class StandardMaterial extends PushMaterial {
6748
6921
  /** Diffuse colour as the app set it. Kept apart from `_lite.diffuseColor`, which is forced to white
6749
6922
  * while the material is unlit (see `_syncDiffuse`). */
6750
6923
  private _diffuse;
6751
- constructor(name: string, scene?: Scene);
6752
- /**
6924
+ constructor(name: string, scene?: Scene);
6753
6925
  /**
6754
6926
  * Babylon.js shades an unlit StandardMaterial as `emissive + ambient`: the diffuse colour only scales
6755
6927
  * the accumulated light, and there is none. Lite's unlit path is `emissive × diffuse`, so the usual
6756
6928
  * "unlit colour" setup (black diffuse, colour in emissive) rendered black. Hand Lite a neutral white
@@ -6923,6 +7095,12 @@ export declare class StringDictionary<T> {
6923
7095
  forEach(callback: (key: string, value: T) => void): void;
6924
7096
  }
6925
7097
 
7098
+ /** Babylon.js `SubMesh`; pass-specific indirect drawing requires Lite renderer integration. */
7099
+ export declare class SubMesh {
7100
+ constructor(_materialIndex: number, _verticesStart: number, _verticesCount: number, _indexStart: number, _indexCount: number, _mesh: AbstractMesh, _renderingMesh?: Mesh, _createBoundingBox?: boolean, _addToMesh?: boolean);
7101
+ setIndirectDrawBuffer(_buffer: unknown | null, _byteOffset: number, _renderPassId: number): void;
7102
+ }
7103
+
6926
7104
  export declare class SurfaceMagnetismBehavior {
6927
7105
  constructor();
6928
7106
  }
@@ -7005,9 +7183,9 @@ export declare class Texture extends BaseTexture {
7005
7183
  hasAlpha: boolean;
7006
7184
  coordinatesIndex: number;
7007
7185
  /** Babylon.js sampling mode passed at construction (`NEAREST_SAMPLINGMODE` = 1, etc.). */
7008
- readonly samplingMode: number;
7009
7186
  constructor(url: string, sceneOrEngine: Scene | {
7187
+ samplingMode: number;
7010
7188
  constructor(url: string, sceneOrEngine: Scene | {
7011
7189
  _lite: EngineContext;
7012
- }, noMipmapOrOptions?: unknown, invertY?: boolean, _samplingMode?: number, onLoad?: (() => void) | null);
7013
7190
  private readonly _noMipmap;
7191
+ }, noMipmapOrOptions?: unknown, invertY?: boolean, _samplingMode?: number, onLoad?: (() => void) | null);
7014
7192
  private _noMipmap;
7015
7193
  getClassName(): string;
7016
7194
  /**
7017
7195
  * Babylon.js `texture.clone()` — a new `Texture` over the same source URL.
@@ -7015,6 +7193,12 @@ export declare class Texture extends BaseTexture {
7015
7193
  * handle (tracked against the same scene so it is ready at build).
7016
7194
  */
7017
7195
  clone(): Texture;
7196
+ /**
7197
+ * Babylon.js `Texture.replaceImage` — reuse another ready URL texture's Lite
7198
+ * handle without reloading it. Wrapper UV state remains local; loading state
7199
+ * follows the source so later clones resolve the same image.
7200
+ */
7201
+ replaceImage(source: Texture): boolean;
7018
7202
  whenReadyAsync(): Promise<void>;
7019
7203
  /** Babylon.js `Texture.onLoadObservable`, allocated only when code subscribes. */
7020
7204
  get onLoadObservable(): Observable<Texture>;
@@ -7149,7 +7333,8 @@ export declare class TransformNode extends Node_2 {
7149
7333
  physicsBody: PhysicsBody
7150
7334
  private _nativeRotationVersion;
7151
7335
  private readonly _nativeRotationValues;
7152
7336
  private _isSyncingRotationFromNative;
7153
- private _sceneDisposeObserver?;
7154
7337
  constructor(name: string, scene?: Scene, liteNode?: SceneNode);
7338
+ private _sceneDisposeObserver?;
7339
+ private _loadedSceneRegistered;
7155
7340
  constructor(name: string, scene?: Scene, liteNode?: SceneNode);
7156
7341
  getClassName(): string;
7157
7342
  get position(): Vector3;
7158
7343
  set position(value: Vector3);
@@ -7263,7 +7448,7 @@ export declare class UniformBuffer {
7263
7448
  private _setInteger;
7264
7449
  }
7265
7450
 
7266
- /** Babylon.js `UninstallHtmlInCanvasPolyfill` — the HTML-in-canvas polyfill is unsupported by the compat layer. */
7451
+ /** Babylon.js `UninstallHtmlInCanvasPolyfill`; paired with the structurally blocked installer. */
7267
7452
  export declare function UninstallHtmlInCanvasPolyfill(): never;
7268
7453
 
7269
7454
  /** Babylon.js `UniversalCamera` — touch-friendly free camera. */
@@ -7586,6 +7771,16 @@ export declare interface WebGPUEngineOptions extends AbstractEngineOptions {
7586
7771
  canvasColorSpace?: PredefinedColorSpace;
7587
7772
  }
7588
7773
 
7774
+ export declare class WebGPURenderPassCommandStream {
7775
+ constructor();
7776
+ }
7777
+
7778
+ export declare type WebGPURenderPassCommandStreamDisableReason = "protocol-mismatch" | "atomic-recording-unsupported" | "recorder-missing" | "recording-rejected" | "recording-threw";
7779
+
7780
+ export declare const WebGPURenderPassCommandStreamMaxDrawsPerBatch = 1024;
7781
+
7782
+ export declare const WebGPURenderPassCommandStreamProtocolVersion = 1;
7783
+
7589
7784
  /** Babylon.js `WebXRCamera` — WebXR is not part of Babylon Lite. */
7590
7785
  export declare class WebXRCamera {
7591
7786
  constructor();