@onerjs/core 8.54.3 → 8.54.5

package/Meshes/GaussianSplatting/gaussianSplattingMeshBase.pure.d.ts

@@ -7,6 +7,7 @@ import { type AbstractMesh } from "../abstractMesh.pure.js";
 import { Mesh } from "../mesh.pure.js";
 import { Matrix, Vector2, Vector3 } from "../../Maths/math.vector.pure.js";
 import { Observable } from "../../Misc/observable.js";
+import { MultiRenderTarget } from "../../Materials/Textures/multiRenderTarget.pure.js";
 import { type InternalTexture } from "../../Materials/Textures/internalTexture.js";
 import { type Material } from "../../Materials/material.pure.js";
 import { type Effect } from "../../Materials/effect.pure.js";
@@ -303,9 +304,16 @@ export declare class GaussianSplattingMeshBase extends Mesh {
     protected _covariancesBTexture: Nullable<BaseTexture>;
     protected _centersTexture: Nullable<BaseTexture>;
     protected _colorsTexture: Nullable<BaseTexture>;
+    protected _mrtAtlas: Nullable<MultiRenderTarget>;
+    protected _useMrtAtlas: boolean;
+    protected _shMrtAtlas: Nullable<MultiRenderTarget[]>;
+    protected _useShMrtAtlas: boolean;
+    protected _shMrtAtlasTextureCount: number;
     protected _rotationsATexture: Nullable<BaseTexture>;
     protected _rotationsBTexture: Nullable<BaseTexture>;
     protected _rotationScaleTexture: Nullable<BaseTexture>;
+    protected _rotMrtAtlas: Nullable<MultiRenderTarget>;
+    protected _useRotMrtAtlas: boolean;
     private _rotationDataA;
     private _rotationDataB;
     private _rotationScaleData;
@@ -341,7 +349,7 @@ export declare class GaussianSplattingMeshBase extends Mesh {
     private static _PlyConversionBatchSize;
     /** @internal */
     _shDegree: number;
-    private _maxShDegree;
+    protected _maxShDegree: number;
     private static readonly _BatchSize;
     private _cameraViewInfos;
     protected static readonly _DefaultViewUpdateThreshold = 0.0001;
@@ -350,6 +358,19 @@ export declare class GaussianSplattingMeshBase extends Mesh {
     /** Fired after part-removal validation passes but before the mesh is rebuilt.
      *  Payload is the original (pre-removal) part index. */
     readonly onPartRemovedObservable: Observable<number>;
+    /**
+     * Fired just before an existing MRT-backed atlas is recreated to grow it (e.g. adding a part while a streaming
+     * part exists). Payload is the OLD atlas. Streaming parts subscribe to back up their GPU-only region before it
+     * is disposed. Only fires when growing an existing MRT atlas (not on first creation).
+     * @internal
+     */
+    readonly _onBeforeAtlasRebuildObservable: Observable<MultiRenderTarget>;
+    /**
+     * Fired after the new (grown) MRT-backed atlas has been created and its CPU data uploaded. Payload is the NEW
+     * atlas. Streaming parts subscribe to rebind to it and restore their backed-up region.
+     * @internal
+     */
+    readonly _onAfterAtlasRebuildObservable: Observable<MultiRenderTarget>;
     /**
      * Returns a byte-accurate view for retained splat data, preserving any non-zero byte offset.
      * @param data The retained splat source bytes.
@@ -433,8 +454,15 @@ export declare class GaussianSplattingMeshBase extends Mesh {
      * @param colors color texture
      * @param splatPositions stride-4 CPU centers for depth sorting (length vertexCount*4)
      * @param vertexCount number of splats addressable in the work buffer
+     * @param shTextures optional baked higher-order SH textures (packed-u32) produced by the work buffer's SH decode.
+     *   When provided, the draw path lights the decoded splats with view-dependent SH (the non-SOG `shTexture0..N`
+     *   path). `shDegree` sets both the max and active SH degree.
+     * @param shDegree SH degree of the baked SH textures (0 = none). Ignored when `shTextures` is empty/omitted.
+     * @param rotationTextures optional decoded rotation/scale textures ([rotA, rotB, rotScale]) produced by the work
+     *   buffer's rotation decode. When provided, they drive the voxel-IBL rotation/scale samplers so the streamed
+     *   splats participate in voxel-based IBL shadowing.
      */
-    protected _setExternalWorkBuffer(centers: BaseTexture, covariancesA: BaseTexture, covariancesB: BaseTexture, colors: BaseTexture, splatPositions: Float32Array, vertexCount: number): void;
+    protected _setExternalWorkBuffer(centers: BaseTexture, covariancesA: BaseTexture, covariancesB: BaseTexture, colors: BaseTexture, splatPositions: Float32Array, vertexCount: number, shTextures?: Nullable<BaseTexture[]>, shDegree?: number, rotationTextures?: Nullable<BaseTexture[]>): void;
     /**
      * returns the splats data array buffer that contains in order : postions (3 floats), size (3 floats), color (4 bytes), orientation quaternion (4 bytes)
      * Only available if the mesh was created with keepInRam: true
@@ -669,8 +697,10 @@ export declare class GaussianSplattingMeshBase extends Mesh {
      * @param maximum - accumulated bounding maximum (updated in-place)
      * @param flipY - whether to negate the Y position
      * @param srcIndex - source splat index (defaults to dstIndex when omitted)
+     * @param dstArrayIndex - index into the covA/covB/colorArray transients (defaults to dstIndex). Lets a streaming
+     * write pass count-sized transients indexed from 0 while dstIndex still addresses the atlas-sized _splatPositions.
      */
-    protected _makeSplat(dstIndex: number, fBuffer: Float32Array, uBuffer: Uint8Array, covA: Uint16Array, covB: Uint16Array, colorArray: Uint8Array, minimum: Vector3, maximum: Vector3, flipY: boolean, srcIndex?: number): void;
+    protected _makeSplat(dstIndex: number, fBuffer: Float32Array, uBuffer: Uint8Array, covA: Uint16Array, covB: Uint16Array, colorArray: Uint8Array, minimum: Vector3, maximum: Vector3, flipY: boolean, srcIndex?: number, dstArrayIndex?: number): void;
     protected _onUpdateTextures(_textureSize: Vector2): void;
     /**
      * Called when part index data is received during a data load. Override to store and manage
@@ -696,6 +726,34 @@ export declare class GaussianSplattingMeshBase extends Mesh {
      */
     get isCompound(): boolean;
     protected _setDelayedTextureUpdate(covA: Uint16Array, covB: Uint16Array, colorArray: Uint8Array, sh?: Uint8Array[]): void;
+    /**
+     * Creates (or recreates) the MRT-backed data atlas at the given size and points the four core data
+     * textures at its attachments. The attachments use the same decoded GS layout as {@link GaussianSplattingWorkBuffer}
+     * — [centers F32, covA HALF_FLOAT, covB HALF_FLOAT, colors U8], all RGBA — so a streaming engine can render
+     * (decode/relayout) directly into the same textures the GS material samples, while static parts CPU-upload
+     * into them via {@link _updateSubTextures}. Covariance B is RGBA here (its extra channels unused), so the
+     * atlas forces {@link _useRGBACovariants}.
+     * @param textureSize atlas dimensions (width, height)
+     */
+    protected _createMrtAtlas(textureSize: Vector2): void;
+    /**
+     * Creates the shared higher-order SH atlas: `_shMrtAtlasTextureCount` single-attachment integer render targets
+     * (RGBA_INTEGER / UNSIGNED_INTEGER, packed-u32), sized to the whole atlas, so a streaming engine can GPU-decode
+     * baked SH into the reserved region and static SH parts CPU-upload into the same attachments. `_shTextures` (the
+     * draw path's `shTexture0..N` samplers) are the attachments. One MRT per attachment keeps within WebGPU's
+     * per-sample color-attachment byte budget. No-op without a real GPU backend (mirrors {@link _createMrtAtlas}).
+     * @param textureSize atlas dimensions (width, height)
+     */
+    protected _createShMrtAtlas(textureSize: Vector2): void;
+    /**
+     * Creates the shared rotation/scale atlas: one 3-attachment half-float render target ([rotA, rotB, rotScale])
+     * sized to the whole atlas, so a streaming engine can GPU-decode rotation/scale into the reserved region and
+     * static parts CPU-upload into the same attachments. `_rotationsATexture`/`_rotationsBTexture`/
+     * `_rotationScaleTexture` (the voxel-IBL samplers) become the three attachments. No-op without a real GPU
+     * backend (mirrors {@link _createMrtAtlas}).
+     * @param textureSize atlas dimensions (width, height)
+     */
+    protected _createRotMrtAtlas(textureSize: Vector2): void;
     protected _updateTextures(covA: Uint16Array, covB: Uint16Array, colorArray: Uint8Array, sh?: Uint8Array[]): void;
     /**
      * Checks whether the GPU textures can be incrementally updated for a new addPart operation,
@@ -703,9 +761,10 @@ export declare class GaussianSplattingMeshBase extends Mesh {
      * Requires that the GPU textures already exist and the texture height won't change.
      * @param previousVertexCount - The number of splats previously committed to GPU
      * @param vertexCount - The new total number of splats
+     * @param requiredShTextureCount - SH texture count this update requires (the merged `sh.length`), 0 when no SH
      * @returns true when only the new splat region needs to be uploaded
      */
-    protected _canReuseCachedData(previousVertexCount: number, vertexCount: number): boolean;
+    protected _canReuseCachedData(previousVertexCount: number, vertexCount: number, requiredShTextureCount?: number): boolean;
     /**
      * Posts updated positions to the sort worker and marks the sort as dirty.
      * Called after processing new splats so the worker can re-sort with the complete position set.
@@ -722,6 +781,24 @@ export declare class GaussianSplattingMeshBase extends Mesh {
      * @param splatCount number of splats in the updated range
      */
     protected _postWorkerPositionsRange(splatOffset: number, splatCount: number): void;
+    /**
+     * Decodes raw `.splat` bytes (32 bytes/splat) into a contiguous sub-range of the already-allocated atlas,
+     * uploading only the affected texels (never touching neighboring parts' texels) and patching just that
+     * range of positions in the sort worker. Used to populate a region reserved by
+     * {@link GaussianSplattingMesh.reserveStreamingPart} — the CPU path a streaming engine uses when GPU
+     * decode/readback is unavailable, and the seam that verifies reservation + interleaving before the
+     * streaming engine exists.
+     *
+     * The atlas textures and `_splatPositions` must already be sized to cover `[globalOffset, globalOffset+count)`
+     * (guaranteed after `reserveStreamingPart`). Bounds of the written centers are accumulated into `min`/`max`
+     * when provided (so the caller can grow the owning part's bounding info).
+     * @param globalOffset first atlas splat index to write
+     * @param count number of splats to write
+     * @param splatsData raw `.splat` bytes for `count` splats (stride 32)
+     * @param min optional running min accumulator for the written centers
+     * @param max optional running max accumulator for the written centers
+     */
+    protected _writeStreamingSplats(globalOffset: number, count: number, splatsData: ArrayBuffer | ArrayBufferView, min?: Vector3, max?: Vector3): void;
     private _updateData;
     /**
      * Update asynchronously the buffer