babylonjs-loaders 9.22.2 → 9.23.0

package/babylonjs.loaders.module.d.ts

@@ -755,6 +755,7 @@ export * from "babylonjs-loaders/glTF/2.0/glTFLoader.pure";
 export * from "babylonjs-loaders/glTF/2.0/glTFLoaderExtension";
 export * from "babylonjs-loaders/glTF/2.0/glTFLoaderExtensionRegistry";
 export * from "babylonjs-loaders/glTF/2.0/glTFLoaderInterfaces";
+export * from "babylonjs-loaders/glTF/2.0/glTFLoaderAnimation.pure";
 export * from "babylonjs-loaders/glTF/2.0/openpbrMaterialLoadingAdapter";
 export * from "babylonjs-loaders/glTF/2.0/pbrMaterialLoadingAdapter";
 export * from "babylonjs-loaders/glTF/2.0/Extensions/pure";
@@ -3081,7 +3082,8 @@ export interface IGLTFLoaderExtension extends IGLTFBaseLoaderExtension, IDisposa
 }
 
 }
-declare module "babylonjs-loaders/glTF/2.0/glTFLoaderAnimation" {
+declare module "babylonjs-loaders/glTF/2.0/glTFLoaderAnimation.pure" {
+/** This file must only contain pure code and pure imports */
 import { Animation } from "babylonjs/Animations/animation.pure";
 import { Quaternion, Vector3 } from "babylonjs/Maths/math.vector.pure";
 import { INode } from "babylonjs-loaders/glTF/2.0/glTFLoaderInterfaces";
@@ -3124,6 +3126,14 @@ export class WeightAnimationPropertyInfo extends AnimationPropertyInfo {
         babylonAnimation: Animation;
     }[];
 }
+/**
+ * Registers the core glTF animation interpolation mappings.
+ */
+export function RegisterGLTFLoaderAnimation(): void;
+
+}
+declare module "babylonjs-loaders/glTF/2.0/glTFLoaderAnimation" {
+export * from "babylonjs-loaders/glTF/2.0/glTFLoaderAnimation.pure";
 
 }
 declare module "babylonjs-loaders/glTF/2.0/glTFLoader.pure" {
@@ -3147,7 +3157,7 @@ import { IDataBuffer } from "babylonjs/Misc/dataReader";
 import { Light } from "babylonjs/Lights/light";
 import { BoundingInfo } from "babylonjs/Culling/boundingInfo";
 import { AssetContainer } from "babylonjs/assetContainer";
-import { AnimationPropertyInfo } from "babylonjs-loaders/glTF/2.0/glTFLoaderAnimation";
+import { AnimationPropertyInfo } from "babylonjs-loaders/glTF/2.0/glTFLoaderAnimation.pure";
 import { IObjectInfo } from "babylonjs/ObjectModel/objectModelInterfaces";
 import { GLTFExtensionFactory } from "babylonjs-loaders/glTF/2.0/glTFLoaderExtensionRegistry";
 import { IInterpolationPropertyInfo } from "babylonjs/FlowGraph/typeDefinitions";
@@ -5112,6 +5122,11 @@ export class KHR_node_visibility implements IGLTFLoaderExtension {
     onReady(): void;
     dispose(): void;
 }
+/**
+ * @internal
+ * Registers KHR_node_visibility runtime dependencies without changing the extension registry.
+ */
+export function _RegisterKHRNodeVisibilityRuntime(): void;
 /**
  * Registers the KHR_node_visibility glTF loader extension.
  * Safe to call multiple times; only the first call has an effect.
@@ -5163,6 +5178,11 @@ export class KHR_node_selectability implements IGLTFLoaderExtension {
     onReady(): Promise<void>;
     dispose(): void;
 }
+/**
+ * @internal
+ * Registers KHR_node_selectability runtime dependencies without changing the extension registry.
+ */
+export function _RegisterKHRNodeSelectabilityRuntime(): void;
 /**
  * Registers the KHR_node_selectability glTF loader extension.
  * Safe to call multiple times; only the first call has an effect.
@@ -5215,6 +5235,11 @@ export class KHR_node_hoverability implements IGLTFLoaderExtension {
     onReady(): Promise<void>;
     dispose(): void;
 }
+/**
+ * @internal
+ * Registers KHR_node_hoverability runtime dependencies without changing the extension registry.
+ */
+export function _RegisterKHRNodeHoverabilityRuntime(): void;
 /**
  * Registers the KHR_node_hoverability glTF loader extension.
  * Safe to call multiple times; only the first call has an effect.
@@ -6620,6 +6645,11 @@ export class KHR_interactivity implements IGLTFLoaderExtension {
  * populates the object model with the interactivity extension
  */
 export function _AddInteractivityObjectModel(scene: Scene): void;
+/**
+ * @internal
+ * Registers KHR_interactivity runtime dependencies without changing the extension registry.
+ */
+export function _RegisterKHRInteractivityRuntime(): void;
 /**
  * Registers the KHR_interactivity glTF loader extension.
  * Safe to call multiple times; only the first call has an effect.
@@ -9617,7 +9647,7 @@ export class GaussianSplattingWorkBuffer {
 
 }
 declare module "babylonjs-loaders/SPLAT/gaussianSplattingStream" {
-import { GaussianSplattingMesh } from "babylonjs/Meshes/GaussianSplatting/gaussianSplattingMesh";
+import { GaussianSplattingMesh, IGaussianSplattingLodBudgetParticipant } from "babylonjs/Meshes/GaussianSplatting/gaussianSplattingMesh";
 import { GaussianSplattingPartProxyMesh } from "babylonjs/Meshes/GaussianSplatting/gaussianSplattingPartProxyMesh";
 import { Scene } from "babylonjs/scene";
 import { Nullable } from "babylonjs/types";
@@ -9650,6 +9680,9 @@ interface ISOGLODNode {
     activeLod?: number;
     /** Distance-based ideal LOD level for this node, recomputed per frame. */
     optimalLod?: number;
+    /** Projected screen size (pixels) of the node's AABB — the max across active cameras. Larger nodes keep finer
+     * detail under the splat budget. Only computed while the budget is enabled. */
+    pixelSize?: number;
     /** Available LOD levels for this leaf, sorted ascending (0 = finest). Set during the tree walk. */
     availableLevels?: number[];
     /** Coarsest available level (= max key), always streamed as the permanent base layer. */
@@ -9751,6 +9784,17 @@ export interface IGaussianSplattingStreamOptions {
      * return to it avoids a re-download. Only used when a budget enables eviction. PlayCanvas default `100`.
      */
     evictionCooldownFrames?: number;
+    /**
+     * Enables budget-driven LOD: caps the total rendered splats by converging a screen-space (size + distance)
+     * pixel-size threshold to the budget. Selection is view-direction-independent, so it is consistent across any
+     * number of active cameras (each node takes the finest level and largest projected size any camera demands).
+     * A number is an explicit splat cap; `"auto"` picks a device-tiered default (desktop 2.5M / iOS 1.5M /
+     * other mobile 1M; XR shares the mobile tier). **Undefined (default) disables the cap** — LOD is pure
+     * distance, identical to prior behavior. Runtime-mutable via the {@link splatBudget} accessor. When this stream
+     * is hosted in a compound, the compound's {@link GaussianSplattingMesh.splatBudget} (if set) overrides this and
+     * apportions a shared budget across all its streams.
+     */
+    splatBudget?: number | "auto";
     /**
      * When set, the stream does not render itself; instead it reserves a region of this compound mesh and
      * decodes/sorts into it, so its splats are depth-sorted and drawn in ONE pass together with the compound's
@@ -9790,7 +9834,7 @@ export interface IGaussianSplattingStreamOptions {
  *
  * @experimental
  */
-export class GaussianSplattingStream extends GaussianSplattingMesh {
+export class GaussianSplattingStream extends GaussianSplattingMesh implements IGaussianSplattingLodBudgetParticipant {
     private readonly _metadata;
     private readonly _rootUrl;
     private readonly _streamOptions;
@@ -9805,9 +9849,12 @@ export class GaussianSplattingStream extends GaussianSplattingMesh {
     private _lodUpdateInterval;
     private _lodUpdateDistance;
     private _maxDetailLod;
+    private _lodPixelThreshold;
+    private _hostBudgetAllocation;
     private _frustumCulling;
     private readonly _frustumPlanes;
     private readonly _cullViewProj;
+    private readonly _frustumScratch;
     private _workBuffer;
     private _decodeSh;
     private _streamShDegree;
@@ -9838,7 +9885,8 @@ export class GaussianSplattingStream extends GaussianSplattingMesh {
     private _lodObserver;
     private _baseLayerReady;
     private _framesSinceLodUpdate;
-    private readonly _lastLodCamPos;
+    private readonly _lastLodCamPositions;
+    private _lastLodSignature;
     private _forceLodUpdate;
     private readonly _boundsMin;
     private readonly _boundsMax;
@@ -9937,6 +9985,66 @@ export class GaussianSplattingStream extends GaussianSplattingMesh {
      */
     get maxDetailLod(): number;
     set maxDetailLod(value: number);
+    /**
+     * This stream's own budget-driven LOD cap in splats (see {@link IGaussianSplattingStreamOptions.splatBudget}).
+     * `0` disables the budget (pure distance LOD). Setting it caps the rendered splat count, taking effect on the
+     * next frame. When this stream is hosted in a compound whose own budget is set, that shared budget overrides
+     * this value — read the actual runtime cap from {@link effectiveSplatBudget}, not this getter (which always
+     * reports the configured own cap).
+     * @experimental
+     */
+    get splatBudget(): number;
+    set splatBudget(value: number);
+    /**
+     * The splat cap actually in force this frame: a hosting compound's apportioned allocation when this stream is
+     * coordinated, otherwise this stream's own {@link splatBudget}, clamped to what can be kept resident. `0` means
+     * no cap (pure distance LOD). Unlike {@link splatBudget}, this reflects the compound override, so it is the value
+     * to display or reason about at runtime.
+     * @experimental
+     */
+    get effectiveSplatBudget(): number;
+    /**
+     * Resolves the raw {@link splatBudget} option to a concrete cap: `undefined` ⇒ 0 (disabled), `"auto"` ⇒ a
+     * device-tiered default, a positive number ⇒ itself (floored).
+     * @param option the raw option value
+     * @returns the resolved splat cap (0 = disabled)
+     */
+    private _resolveSplatBudget;
+    /**
+     * Device-tiered default splat budget for {@link splatBudget} `"auto"`: desktop 2.5M, iOS 1.5M, other mobile
+     * (incl. Android/XR) 1M. XR is folded into the mobile tier (no reliable at-construction detection).
+     * @returns the default splat cap for this device
+     */
+    private _computeDefaultSplatBudget;
+    /**
+     * The splat budget this stream converges against this frame: the compound's apportioned allocation when hosted
+     * and coordinated, else this stream's own resolved budget. Clamped to the resident budget so the stream never
+     * targets more splats than can be kept resident. `0` means the budget is disabled.
+     * @returns the effective splat cap (0 = disabled)
+     */
+    private _effectiveSplatBudget;
+    /**
+     * Whether budget-driven LOD is active this frame.
+     * @returns true when a positive effective budget is in force
+     */
+    private _splatBudgetEnabled;
+    /**
+     * {@link IGaussianSplattingLodBudgetParticipant}: the splats this stream would render at full (distance-optimal)
+     * detail — its demand on a host compound's shared budget. Computed from the current per-node distance-optimal
+     * levels (no pixel threshold), so it does not depend on the allocation it is helping to compute.
+     * @returns the full-detail rendered splat count (0 before the base layer is ready)
+     */
+    getBudgetDemand(): number;
+    /**
+     * {@link IGaussianSplattingLodBudgetParticipant}: sets the compound's apportioned share of the shared budget.
+     * `null` releases coordination (revert to this stream's own {@link splatBudget}); a number (incl. 0, meaning
+     * "coordinated at the coarsest level") drives the pixel-threshold convergence. Any change to the (already integer)
+     * allocation forces a next-frame re-eval: a decrease may put the current selection over the new cap, and even a
+     * small increase can unlock a finer level that a stationary camera would otherwise never re-evaluate to. The
+     * apportioned demand is allocation-independent, so this settles in one step and does not churn frame to frame.
+     * @param splats the apportioned allocation, or null to release coordination
+     */
+    setBudgetAllocation(splats: Nullable<number>): void;
     /**
      * Coarsest LOD level index in the scene (number of LOD levels minus one). Useful as the upper bound
      * for {@link maxDetailLod}.
@@ -9980,10 +10088,17 @@ export class GaussianSplattingStream extends GaussianSplattingMesh {
      */
     private _getEffectiveWorldMatrix;
     /**
-     * Re-evaluates the optimal LOD for every node based on the camera position. The result is stored in
-     * each node's `optimalLod`. Rendering is unaffected; this currently drives only diagnostics and the
-     * debug wireframe display.
-     * @param camera camera to evaluate against (defaults to the scene's active camera)
+     * The cameras the LOD should serve: `scene.activeCameras` when set (split-view / multi-view), else the single
+     * `scene.activeCamera`. Mirrors the sort path's multi-camera handling.
+     * @returns the non-null active cameras (may be empty)
+     */
+    private _getActiveLodCameras;
+    /**
+     * Re-evaluates the optimal LOD for every node from the active cameras. Each node takes the finest level and the
+     * largest projected pixel size any active camera demands (so every pane of a split view is served), and the
+     * frustum bias uses the union of the frusta. Selection is view-direction-independent, so single- and multi-camera
+     * rendering are consistent. The results are stored in each node's `optimalLod` / `pixelSize`.
+     * @param camera when provided, evaluate against just this camera; otherwise use the active-camera set
      */
     evaluateOptimalLods(camera?: Nullable<Camera>): void;
     /**
@@ -10167,10 +10282,61 @@ export class GaussianSplattingStream extends GaussianSplattingMesh {
      */
     private _cappedLevelForNode;
     /**
-     * Computes each node's {@link ISOGLODNode.targetLevel}: the distance-based optimal level snapped to an
-     * available level, capped so no node renders finer (more detailed) than {@link maxDetailLod}.
+     * Computes each node's {@link ISOGLODNode.targetLevel}. With the splat budget disabled this is the
+     * distance-optimal level snapped to an available level (capped by {@link maxDetailLod}) — unchanged prior
+     * behavior. With the budget enabled it converges a global pixel-size threshold to the budget and coarsens each
+     * node from its distance-optimal ceiling by how far its projected size falls below that threshold.
      */
     private _computeTargetLevels;
+    /**
+     * Splat count of the always-rendered environment layer (0 when none), coerced to a finite non-negative integer.
+     * Counted as a fixed cost in both the budget demand and the leaf convergence so it is never over-drawn.
+     * @returns the environment's rendered splat count
+     */
+    private _environmentSplatCount;
+    /**
+     * The level a node renders at for a given pixel-size threshold `t`: its distance-optimal ceiling, coarsened by
+     * `round(log_mult(t / pixelSize))` geometric steps when its projected size is below `t`. Snapped to
+     * an available level honoring {@link maxDetailLod}.
+     * @param node leaf node
+     * @param t pixel-size threshold (pixels)
+     * @returns the chosen available LOD level
+     */
+    private _budgetedLevel;
+    /**
+     * Splat count of a node's file at a given (already snapped) available level.
+     * @param node leaf node
+     * @param level available LOD level
+     * @returns the level's splat count (0 if absent)
+     */
+    private _countAtLevel;
+    /**
+     * Sum of every leaf's rendered splat count at pixel-size threshold `t`.
+     * @param t pixel-size threshold (pixels)
+     * @returns total rendered splats
+     */
+    private _totalSplatsAtThreshold;
+    /**
+     * Converges the global pixel-size threshold {@link _lodPixelThreshold} to the largest detail whose total rendered
+     * splats is still within `budget` (the pixel-scale cut, floored at the true sub-pixel limit of 1 px). The
+     * total is monotonically non-increasing in the threshold, so a bisection on `[floorT, ceilT]` — where `ceilT`
+     * coarsens every node to its coarsest available level — gives a GUARANTEED result at or under the cap. When even
+     * that coarsest state exceeds the budget (the budget is below the pinned minimum detail), the threshold is set to
+     * `ceilT` so every node renders at minimum detail — the best achievable; the cap is then unavoidable. O(leaves)
+     * per iteration; no decode.
+     * @param budget target maximum rendered splat count
+     */
+    private _convergePixelThreshold;
+    /**
+     * The finest already-decoded level of a node that is at least as coarse as `level` (index >= level). Used to
+     * enforce the budget cap immediately without waiting for a download. Returns `null` when no such level is resident
+     * — including when eviction has freed the base layer — so the caller keeps the currently-visible (resident) file
+     * rather than switching to a non-resident one, which would render a hole.
+     * @param node leaf node
+     * @param level the minimum coarseness (level index) required
+     * @returns a resident level index >= level, or null when none is resident
+     */
+    private _residentLevelAtLeast;
     /**
      * Applies each node's {@link ISOGLODNode.targetLevel}: switches a node to its target level when that
      * level's file is already decoded, otherwise records a pending download request for the file and leaves
@@ -10224,17 +10390,28 @@ export class GaussianSplattingStream extends GaussianSplattingMesh {
      */
     private _onLodFrame;
     /**
-     * Updates each leaf node's {@link ISOGLODNode.inFrustum} flag from a per-node frustum test against the
-     * active camera. When {@link frustumCulling} is disabled (or there is no camera) every node is marked
-     * in-frustum. Bounds are static (from the LOD tree), so flags are valid for all nodes regardless of
-     * decode state. Returns true when any node's in-frustum state changed (so the LOD bias must be re-applied).
+     * A cheap signature of the discrete inputs (besides camera translation, tracked separately) that affect projected
+     * pixel size: each camera's identity, FOV, FOV mode and viewport, plus the engine render size and the effective
+     * world matrix revision. A change invalidates the throttled budget LOD so a colocated camera swap / viewport
+     * resize / FOV change — or the stream (or its hosted proxy) being moved or scaled while still in frustum, which
+     * shifts every node's distance and projected size — can't leave it stale.
+     * @param cameras the active cameras
+     * @returns the signature string
+     */
+    private _computeLodSignature;
+    /**
+     * Updates each leaf node's {@link ISOGLODNode.inFrustum} flag: a node is in-frustum if it is inside ANY
+     * active camera's frustum (the union). When {@link frustumCulling} is disabled (or there are no cameras)
+     * every node is marked in-frustum. Bounds are static (from the LOD tree), so flags are valid for all nodes
+     * regardless of decode state. Returns true when any node's in-frustum state changed (so the LOD bias must be re-applied).
      * @returns whether any node's in-frustum state changed
      */
     private _updateNodeFrustum;
     /**
-     * Reads the splat count from SOG metadata.
+     * Reads the splat count from SOG metadata, coerced to a finite non-negative integer (metadata is untrusted, so
+     * `count` / `shape[0]` may be a string or malformed — a non-numeric value must not leak into count arithmetic).
      * @param data SOG metadata
-     * @returns the splat count
+     * @returns the splat count (0 when absent/invalid)
      */
     private static _GetSplatCount;
     /**
@@ -10897,6 +11074,12 @@ import { Vector2 } from "babylonjs/Maths/math.vector";
  * Options for loading OBJ/MTL files
  */
 export type OBJLoadingOptions = {
+    /**
+     * Defines the character encoding used to decode OBJ and MTL files.
+     * Use "auto" to detect UTF-8/UTF-16 and fall back to GB18030, or provide an encoding label supported by TextDecoder.
+     * Defaults to "auto".
+     */
+    encoding?: string;
     /**
      * Defines if UVs are optimized by default during load.
      */
@@ -10966,6 +11149,10 @@ import { OBJLoadingOptions } from "babylonjs-loaders/OBJ/objLoadingOptions";
  * This is a babylon scene loader plugin.
  */
 export class OBJFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPluginFactory {
+    /**
+     * Defines the character encoding used to decode OBJ and MTL files.
+     */
+    static ENCODING: string;
     /**
      * Defines if UVs are optimized by default during load.
      */
@@ -11017,7 +11204,11 @@ export class OBJFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPlugi
     /**
      * Defines the extension the plugin is able to load.
      */
-    readonly extensions: ".obj";
+    readonly extensions: {
+        readonly ".obj": {
+            readonly isBinary: true;
+        };
+    };
     private _assetContainer;
     private _loadingOptions;
     /**
@@ -11039,6 +11230,7 @@ export class OBJFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPlugi
      * @param onFailure
      */
     private _loadMTL;
+    private _decode;
     /** @internal */
     createPlugin(options: SceneLoaderPluginOptions): ISceneLoaderPluginAsync | ISceneLoaderPlugin;
     /**
@@ -11062,7 +11254,7 @@ export class OBJFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPlugi
      * @param rootUrl root url to load from
      * @returns a promise which completes when objects have been loaded to the scene
      */
-    loadAsync(scene: Scene, data: string, rootUrl: string): Promise<void>;
+    loadAsync(scene: Scene, data: string | ArrayBuffer, rootUrl: string): Promise<void>;
     /**
      * Load into an asset container.
      * @param scene The scene to load into
@@ -11070,7 +11262,7 @@ export class OBJFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPlugi
      * @param rootUrl The root url for scene and resources
      * @returns The loaded asset container
      */
-    loadAssetContainerAsync(scene: Scene, data: string, rootUrl: string): Promise<AssetContainer>;
+    loadAssetContainerAsync(scene: Scene, data: string | ArrayBuffer, rootUrl: string): Promise<AssetContainer>;
     /**
      * Read the OBJ file and create an Array of meshes.
      * Each mesh contains all information given by the OBJ and the MTL file.
@@ -11093,7 +11285,11 @@ export function RegisterOBJFileLoader(): void;
 declare module "babylonjs-loaders/OBJ/objFileLoader.metadata" {
 export const OBJFileLoaderMetadata: {
     readonly name: "obj";
-    readonly extensions: ".obj";
+    readonly extensions: {
+        readonly ".obj": {
+            readonly isBinary: true;
+        };
+    };
 };
 
 }
@@ -15334,7 +15530,8 @@ declare namespace BABYLON {
 
 }
 declare namespace BABYLON.GLTF2 {
-        /** @internal */
+        /** This file must only contain pure code and pure imports */
+    /** @internal */
     export type GetValueFn = (target: any, source: Float32Array, offset: number, scale: number) => any;
     /** @internal */
     export function getVector3(_target: any, source: Float32Array, offset: number, scale: number): Vector3;
@@ -15372,7 +15569,20 @@ declare namespace BABYLON.GLTF2 {
             babylonAnimation: Animation;
         }[];
     }
+    /**
+     * Registers the core glTF animation interpolation mappings.
+     */
+    export function RegisterGLTFLoaderAnimation(): void;
+
+
+
+}
+declare namespace BABYLON {
+
 
+}
+declare namespace BABYLON.GLTF2 {
+    
 
 
 }
@@ -17327,6 +17537,11 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
         onReady(): void;
         dispose(): void;
     }
+    /**
+     * @internal
+     * Registers KHR_node_visibility runtime dependencies without changing the extension registry.
+     */
+    export function _RegisterKHRNodeVisibilityRuntime(): void;
     /**
      * Registers the KHR_node_visibility glTF loader extension.
      * Safe to call multiple times; only the first call has an effect.
@@ -17388,6 +17603,11 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
         onReady(): Promise<void>;
         dispose(): void;
     }
+    /**
+     * @internal
+     * Registers KHR_node_selectability runtime dependencies without changing the extension registry.
+     */
+    export function _RegisterKHRNodeSelectabilityRuntime(): void;
     /**
      * Registers the KHR_node_selectability glTF loader extension.
      * Safe to call multiple times; only the first call has an effect.
@@ -17450,6 +17670,11 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
         onReady(): Promise<void>;
         dispose(): void;
     }
+    /**
+     * @internal
+     * Registers KHR_node_hoverability runtime dependencies without changing the extension registry.
+     */
+    export function _RegisterKHRNodeHoverabilityRuntime(): void;
     /**
      * Registers the KHR_node_hoverability glTF loader extension.
      * Safe to call multiple times; only the first call has an effect.
@@ -19006,6 +19231,11 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
      * populates the object model with the interactivity extension
      */
     export function _AddInteractivityObjectModel(scene: Scene): void;
+    /**
+     * @internal
+     * Registers KHR_interactivity runtime dependencies without changing the extension registry.
+     */
+    export function _RegisterKHRInteractivityRuntime(): void;
     /**
      * Registers the KHR_interactivity glTF loader extension.
      * Safe to call multiple times; only the first call has an effect.
@@ -22061,6 +22291,9 @@ declare namespace BABYLON {
         activeLod?: number;
         /** Distance-based ideal LOD level for this node, recomputed per frame. */
         optimalLod?: number;
+        /** Projected screen size (pixels) of the node's AABB — the max across active cameras. Larger nodes keep finer
+         * detail under the splat budget. Only computed while the budget is enabled. */
+        pixelSize?: number;
         /** Available LOD levels for this leaf, sorted ascending (0 = finest). Set during the tree walk. */
         availableLevels?: number[];
         /** Coarsest available level (= max key), always streamed as the permanent base layer. */
@@ -22162,6 +22395,17 @@ declare namespace BABYLON {
          * return to it avoids a re-download. Only used when a budget enables eviction. PlayCanvas default `100`.
          */
         evictionCooldownFrames?: number;
+        /**
+         * Enables budget-driven LOD: caps the total rendered splats by converging a screen-space (size + distance)
+         * pixel-size threshold to the budget. Selection is view-direction-independent, so it is consistent across any
+         * number of active cameras (each node takes the finest level and largest projected size any camera demands).
+         * A number is an explicit splat cap; `"auto"` picks a device-tiered default (desktop 2.5M / iOS 1.5M /
+         * other mobile 1M; XR shares the mobile tier). **Undefined (default) disables the cap** — LOD is pure
+         * distance, identical to prior behavior. Runtime-mutable via the {@link splatBudget} accessor. When this stream
+         * is hosted in a compound, the compound's {@link GaussianSplattingMesh.splatBudget} (if set) overrides this and
+         * apportions a shared budget across all its streams.
+         */
+        splatBudget?: number | "auto";
         /**
          * When set, the stream does not render itself; instead it reserves a region of this compound mesh and
          * decodes/sorts into it, so its splats are depth-sorted and drawn in ONE pass together with the compound's
@@ -22201,7 +22445,7 @@ declare namespace BABYLON {
      *
      * @experimental
      */
-    export class GaussianSplattingStream extends GaussianSplattingMesh {
+    export class GaussianSplattingStream extends GaussianSplattingMesh implements IGaussianSplattingLodBudgetParticipant {
         private readonly _metadata;
         private readonly _rootUrl;
         private readonly _streamOptions;
@@ -22216,9 +22460,12 @@ declare namespace BABYLON {
         private _lodUpdateInterval;
         private _lodUpdateDistance;
         private _maxDetailLod;
+        private _lodPixelThreshold;
+        private _hostBudgetAllocation;
         private _frustumCulling;
         private readonly _frustumPlanes;
         private readonly _cullViewProj;
+        private readonly _frustumScratch;
         private _workBuffer;
         private _decodeSh;
         private _streamShDegree;
@@ -22249,7 +22496,8 @@ declare namespace BABYLON {
         private _lodObserver;
         private _baseLayerReady;
         private _framesSinceLodUpdate;
-        private readonly _lastLodCamPos;
+        private readonly _lastLodCamPositions;
+        private _lastLodSignature;
         private _forceLodUpdate;
         private readonly _boundsMin;
         private readonly _boundsMax;
@@ -22348,6 +22596,66 @@ declare namespace BABYLON {
          */
         get maxDetailLod(): number;
         set maxDetailLod(value: number);
+        /**
+         * This stream's own budget-driven LOD cap in splats (see {@link IGaussianSplattingStreamOptions.splatBudget}).
+         * `0` disables the budget (pure distance LOD). Setting it caps the rendered splat count, taking effect on the
+         * next frame. When this stream is hosted in a compound whose own budget is set, that shared budget overrides
+         * this value — read the actual runtime cap from {@link effectiveSplatBudget}, not this getter (which always
+         * reports the configured own cap).
+         * @experimental
+         */
+        get splatBudget(): number;
+        set splatBudget(value: number);
+        /**
+         * The splat cap actually in force this frame: a hosting compound's apportioned allocation when this stream is
+         * coordinated, otherwise this stream's own {@link splatBudget}, clamped to what can be kept resident. `0` means
+         * no cap (pure distance LOD). Unlike {@link splatBudget}, this reflects the compound override, so it is the value
+         * to display or reason about at runtime.
+         * @experimental
+         */
+        get effectiveSplatBudget(): number;
+        /**
+         * Resolves the raw {@link splatBudget} option to a concrete cap: `undefined` ⇒ 0 (disabled), `"auto"` ⇒ a
+         * device-tiered default, a positive number ⇒ itself (floored).
+         * @param option the raw option value
+         * @returns the resolved splat cap (0 = disabled)
+         */
+        private _resolveSplatBudget;
+        /**
+         * Device-tiered default splat budget for {@link splatBudget} `"auto"`: desktop 2.5M, iOS 1.5M, other mobile
+         * (incl. Android/XR) 1M. XR is folded into the mobile tier (no reliable at-construction detection).
+         * @returns the default splat cap for this device
+         */
+        private _computeDefaultSplatBudget;
+        /**
+         * The splat budget this stream converges against this frame: the compound's apportioned allocation when hosted
+         * and coordinated, else this stream's own resolved budget. Clamped to the resident budget so the stream never
+         * targets more splats than can be kept resident. `0` means the budget is disabled.
+         * @returns the effective splat cap (0 = disabled)
+         */
+        private _effectiveSplatBudget;
+        /**
+         * Whether budget-driven LOD is active this frame.
+         * @returns true when a positive effective budget is in force
+         */
+        private _splatBudgetEnabled;
+        /**
+         * {@link IGaussianSplattingLodBudgetParticipant}: the splats this stream would render at full (distance-optimal)
+         * detail — its demand on a host compound's shared budget. Computed from the current per-node distance-optimal
+         * levels (no pixel threshold), so it does not depend on the allocation it is helping to compute.
+         * @returns the full-detail rendered splat count (0 before the base layer is ready)
+         */
+        getBudgetDemand(): number;
+        /**
+         * {@link IGaussianSplattingLodBudgetParticipant}: sets the compound's apportioned share of the shared budget.
+         * `null` releases coordination (revert to this stream's own {@link splatBudget}); a number (incl. 0, meaning
+         * "coordinated at the coarsest level") drives the pixel-threshold convergence. Any change to the (already integer)
+         * allocation forces a next-frame re-eval: a decrease may put the current selection over the new cap, and even a
+         * small increase can unlock a finer level that a stationary camera would otherwise never re-evaluate to. The
+         * apportioned demand is allocation-independent, so this settles in one step and does not churn frame to frame.
+         * @param splats the apportioned allocation, or null to release coordination
+         */
+        setBudgetAllocation(splats: Nullable<number>): void;
         /**
          * Coarsest LOD level index in the scene (number of LOD levels minus one). Useful as the upper bound
          * for {@link maxDetailLod}.
@@ -22391,10 +22699,17 @@ declare namespace BABYLON {
          */
         private _getEffectiveWorldMatrix;
         /**
-         * Re-evaluates the optimal LOD for every node based on the camera position. The result is stored in
-         * each node's `optimalLod`. Rendering is unaffected; this currently drives only diagnostics and the
-         * debug wireframe display.
-         * @param camera camera to evaluate against (defaults to the scene's active camera)
+         * The cameras the LOD should serve: `scene.activeCameras` when set (split-view / multi-view), else the single
+         * `scene.activeCamera`. Mirrors the sort path's multi-camera handling.
+         * @returns the non-null active cameras (may be empty)
+         */
+        private _getActiveLodCameras;
+        /**
+         * Re-evaluates the optimal LOD for every node from the active cameras. Each node takes the finest level and the
+         * largest projected pixel size any active camera demands (so every pane of a split view is served), and the
+         * frustum bias uses the union of the frusta. Selection is view-direction-independent, so single- and multi-camera
+         * rendering are consistent. The results are stored in each node's `optimalLod` / `pixelSize`.
+         * @param camera when provided, evaluate against just this camera; otherwise use the active-camera set
          */
         evaluateOptimalLods(camera?: Nullable<Camera>): void;
         /**
@@ -22578,10 +22893,61 @@ declare namespace BABYLON {
          */
         private _cappedLevelForNode;
         /**
-         * Computes each node's {@link ISOGLODNode.targetLevel}: the distance-based optimal level snapped to an
-         * available level, capped so no node renders finer (more detailed) than {@link maxDetailLod}.
+         * Computes each node's {@link ISOGLODNode.targetLevel}. With the splat budget disabled this is the
+         * distance-optimal level snapped to an available level (capped by {@link maxDetailLod}) — unchanged prior
+         * behavior. With the budget enabled it converges a global pixel-size threshold to the budget and coarsens each
+         * node from its distance-optimal ceiling by how far its projected size falls below that threshold.
          */
         private _computeTargetLevels;
+        /**
+         * Splat count of the always-rendered environment layer (0 when none), coerced to a finite non-negative integer.
+         * Counted as a fixed cost in both the budget demand and the leaf convergence so it is never over-drawn.
+         * @returns the environment's rendered splat count
+         */
+        private _environmentSplatCount;
+        /**
+         * The level a node renders at for a given pixel-size threshold `t`: its distance-optimal ceiling, coarsened by
+         * `round(log_mult(t / pixelSize))` geometric steps when its projected size is below `t`. Snapped to
+         * an available level honoring {@link maxDetailLod}.
+         * @param node leaf node
+         * @param t pixel-size threshold (pixels)
+         * @returns the chosen available LOD level
+         */
+        private _budgetedLevel;
+        /**
+         * Splat count of a node's file at a given (already snapped) available level.
+         * @param node leaf node
+         * @param level available LOD level
+         * @returns the level's splat count (0 if absent)
+         */
+        private _countAtLevel;
+        /**
+         * Sum of every leaf's rendered splat count at pixel-size threshold `t`.
+         * @param t pixel-size threshold (pixels)
+         * @returns total rendered splats
+         */
+        private _totalSplatsAtThreshold;
+        /**
+         * Converges the global pixel-size threshold {@link _lodPixelThreshold} to the largest detail whose total rendered
+         * splats is still within `budget` (the pixel-scale cut, floored at the true sub-pixel limit of 1 px). The
+         * total is monotonically non-increasing in the threshold, so a bisection on `[floorT, ceilT]` — where `ceilT`
+         * coarsens every node to its coarsest available level — gives a GUARANTEED result at or under the cap. When even
+         * that coarsest state exceeds the budget (the budget is below the pinned minimum detail), the threshold is set to
+         * `ceilT` so every node renders at minimum detail — the best achievable; the cap is then unavoidable. O(leaves)
+         * per iteration; no decode.
+         * @param budget target maximum rendered splat count
+         */
+        private _convergePixelThreshold;
+        /**
+         * The finest already-decoded level of a node that is at least as coarse as `level` (index >= level). Used to
+         * enforce the budget cap immediately without waiting for a download. Returns `null` when no such level is resident
+         * — including when eviction has freed the base layer — so the caller keeps the currently-visible (resident) file
+         * rather than switching to a non-resident one, which would render a hole.
+         * @param node leaf node
+         * @param level the minimum coarseness (level index) required
+         * @returns a resident level index >= level, or null when none is resident
+         */
+        private _residentLevelAtLeast;
         /**
          * Applies each node's {@link ISOGLODNode.targetLevel}: switches a node to its target level when that
          * level's file is already decoded, otherwise records a pending download request for the file and leaves
@@ -22635,17 +23001,28 @@ declare namespace BABYLON {
          */
         private _onLodFrame;
         /**
-         * Updates each leaf node's {@link ISOGLODNode.inFrustum} flag from a per-node frustum test against the
-         * active camera. When {@link frustumCulling} is disabled (or there is no camera) every node is marked
-         * in-frustum. Bounds are static (from the LOD tree), so flags are valid for all nodes regardless of
-         * decode state. Returns true when any node's in-frustum state changed (so the LOD bias must be re-applied).
+         * A cheap signature of the discrete inputs (besides camera translation, tracked separately) that affect projected
+         * pixel size: each camera's identity, FOV, FOV mode and viewport, plus the engine render size and the effective
+         * world matrix revision. A change invalidates the throttled budget LOD so a colocated camera swap / viewport
+         * resize / FOV change — or the stream (or its hosted proxy) being moved or scaled while still in frustum, which
+         * shifts every node's distance and projected size — can't leave it stale.
+         * @param cameras the active cameras
+         * @returns the signature string
+         */
+        private _computeLodSignature;
+        /**
+         * Updates each leaf node's {@link ISOGLODNode.inFrustum} flag: a node is in-frustum if it is inside ANY
+         * active camera's frustum (the union). When {@link frustumCulling} is disabled (or there are no cameras)
+         * every node is marked in-frustum. Bounds are static (from the LOD tree), so flags are valid for all nodes
+         * regardless of decode state. Returns true when any node's in-frustum state changed (so the LOD bias must be re-applied).
          * @returns whether any node's in-frustum state changed
          */
         private _updateNodeFrustum;
         /**
-         * Reads the splat count from SOG metadata.
+         * Reads the splat count from SOG metadata, coerced to a finite non-negative integer (metadata is untrusted, so
+         * `count` / `shape[0]` may be a string or malformed — a non-numeric value must not leak into count arithmetic).
          * @param data SOG metadata
-         * @returns the splat count
+         * @returns the splat count (0 when absent/invalid)
          */
         private static _GetSplatCount;
         /**
@@ -23289,6 +23666,12 @@ declare namespace BABYLON {
      * Options for loading OBJ/MTL files
      */
     export type OBJLoadingOptions = {
+        /**
+         * Defines the character encoding used to decode OBJ and MTL files.
+         * Use "auto" to detect UTF-8/UTF-16 and fall back to GB18030, or provide an encoding label supported by TextDecoder.
+         * Defaults to "auto".
+         */
+        encoding?: string;
         /**
          * Defines if UVs are optimized by default during load.
          */
@@ -23346,6 +23729,10 @@ declare namespace BABYLON {
      * This is a babylon scene loader plugin.
      */
     export class OBJFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPluginFactory {
+        /**
+         * Defines the character encoding used to decode OBJ and MTL files.
+         */
+        static ENCODING: string;
         /**
          * Defines if UVs are optimized by default during load.
          */
@@ -23397,7 +23784,11 @@ declare namespace BABYLON {
         /**
          * Defines the extension the plugin is able to load.
          */
-        readonly extensions: ".obj";
+        readonly extensions: {
+            readonly ".obj": {
+                readonly isBinary: true;
+            };
+        };
         private _assetContainer;
         private _loadingOptions;
         /**
@@ -23419,6 +23810,7 @@ declare namespace BABYLON {
          * @param onFailure
          */
         private _loadMTL;
+        private _decode;
         /** @internal */
         createPlugin(options: SceneLoaderPluginOptions): ISceneLoaderPluginAsync | ISceneLoaderPlugin;
         /**
@@ -23442,7 +23834,7 @@ declare namespace BABYLON {
          * @param rootUrl root url to load from
          * @returns a promise which completes when objects have been loaded to the scene
          */
-        loadAsync(scene: Scene, data: string, rootUrl: string): Promise<void>;
+        loadAsync(scene: Scene, data: string | ArrayBuffer, rootUrl: string): Promise<void>;
         /**
          * Load into an asset container.
          * @param scene The scene to load into
@@ -23450,7 +23842,7 @@ declare namespace BABYLON {
          * @param rootUrl The root url for scene and resources
          * @returns The loaded asset container
          */
-        loadAssetContainerAsync(scene: Scene, data: string, rootUrl: string): Promise<AssetContainer>;
+        loadAssetContainerAsync(scene: Scene, data: string | ArrayBuffer, rootUrl: string): Promise<AssetContainer>;
         /**
          * Read the OBJ file and create an Array of meshes.
          * Each mesh contains all information given by the OBJ and the MTL file.
@@ -23472,7 +23864,11 @@ declare namespace BABYLON {
 
     export var OBJFileLoaderMetadata: {
         readonly name: "obj";
-        readonly extensions: ".obj";
+        readonly extensions: {
+            readonly ".obj": {
+                readonly isBinary: true;
+            };
+        };
     };