Class GaussianSplattingStreamExperimental

Creates a new SOG LOD streaming mesh and immediately starts streaming (non-blocking).

When true, renders a wireframe box per LOD node, colored by the LOD level selected by debugLodSource.

Selects which LOD value drives the debug wireframe colors: the distance-based "optimal" LOD (default, recomputed as the camera moves) or the "current" streamed/rendered LOD.

The splat cap actually in force this frame: a hosting compound's apportioned allocation when this stream is coordinated, otherwise this stream's own splatBudget, clamped to what can be kept resident. 0 means no cap (pure distance LOD). Unlike splatBudget, this reflects the compound override, so it is the value to display or reason about at runtime.

When true (default), nodes whose bounding box is outside the camera frustum are biased to the coarsest LOD instead of being hidden. They stay in the sort/render set (their off-screen splats are clipped), so turning the camera toward them shows low detail immediately with no invisible frames, then refines. Changes take effect in real time.

The total number of splats represented by valid level-0 leaf entries. This remains pending while source metadata is loading and is unavailable when no applicable level-0 entries exist or required metadata fails.

Finest (most detailed) LOD level any node is allowed to render. 0 allows full detail (level 0); 1 caps detail at the next-coarser level, and so on. Nodes already coarser than this cap (by distance) are unaffected. Changes take effect in real time.

Coarsest LOD level index in the scene (number of LOD levels minus one). Useful as the upper bound for maxDetailLod.

Minimum fixed work-buffer capacity required for the complete coarse representation: one invisible padding splat, the included environment, and every unique whole coarse source file. It is 0 until the required coarse metadata has resolved. Initial residency options below this value are raised to it.

The resolved maximum number of splats kept resident in the work buffer. This combines IGaussianSplattingStreamOptions.maxResidentSplats and IGaussianSplattingStreamOptions.memoryBudgetMb, taking the smaller positive limit and raising it to minimumResidentSplats. With neither limit set, the complete source size is retained when known; otherwise a bounded device-tiered default is used. The fixed capacity is capped at the device texture limit. 0 means initial capacity has not been resolved.

This stream's own budget-driven LOD cap in splats (see 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 effectiveSplatBudget, not this getter (which always reports the configured own cap).

Hosted mode only: the compound part proxy this stream drives (world transform + visibility of the reserved region), or null before the part has been reserved (or when running standalone).

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.

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.

When _hostCompound is set (i.e. this stream was created via AddGaussianSplattingStreamPart to drive a reserved region of another compound mesh, rather than rendering itself), this instance is disabled and never drawn — so it never runs its own depth-sort worker and the base class's readiness check (which waits for one) would never pass. Report ready unconditionally in that case; the host compound is the one actually rendering, and its own isReady() already covers real sort completion.

IGaussianSplattingLodBudgetParticipant: sets the compound's apportioned share of the shared budget. null releases coordination (revert to this stream's own 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.

Hosted mode only: resolves once the reserved part exists and its base layer has decoded (so the proxy's bounds are real and the part is ready to be placed/framed), or rejects if streaming fails/disposes first. Resolves immediately for a standalone stream. Used by AddGaussianSplattingStreamPartAsync.

Resolves once the scene is fully streamed and displayed for the current camera: a LOD re-evaluation has run for the current point of view, every reachable LOD file has finished downloading and decoding (no downloads, decodes, or queued work remain), and the depth sort for the resulting splats has been applied and rendered. Intended for deterministic automated testing and screenshot/image comparison.

Streaming and settling require rendered frames. If an external render loop is already running, this waits on it passively; otherwise (e.g. when awaited inside an async createScene before the host starts its render loop) it drives scene.render() itself until settled, so it never deadlocks.

Note: the promise only resolves while the camera is still — if the camera keeps moving, the target LODs (and the depth sort) keep changing and the stream never settles. Position the camera, then await this.

Returns true when the parsed JSON looks like a PlayCanvas-style lod-meta.json payload.