@babylonjs/core 9.4.1 → 9.5.0

package/Meshes/GaussianSplatting/gaussianSplattingMeshBase.d.ts

@@ -5,6 +5,7 @@ import { SubMesh } from "../subMesh.js";
 import { type AbstractMesh } from "../abstractMesh.js";
 import { Mesh } from "../mesh.js";
 import { Matrix, Vector2, Vector3 } from "../../Maths/math.vector.js";
+import { type InternalTexture } from "../../Materials/Textures/internalTexture.js";
 import "../thinInstanceMesh.js";
 import { type Material } from "../../Materials/material.js";
 import { type Effect } from "../../Materials/effect.js";
@@ -14,6 +15,12 @@ interface IUpdateOptions {
     /** @internal When set, skips reprocessing splats [0, previousVertexCount) and copies from cached arrays instead. */
     previousVertexCount?: number;
 }
+interface ITextureDataUpdateCapableEngine {
+    updateTextureData(texture: InternalTexture, imageData: ArrayBufferView, xOffset: number, yOffset: number, width: number, height: number, faceIndex?: number, lod?: number, generateMipMaps?: boolean): void;
+    updateRawTexture(texture: Nullable<InternalTexture>, data: Nullable<ArrayBufferView>, format: number, invertY: boolean, compression?: Nullable<string>, type?: number, useSRGBBuffer?: boolean): void;
+    _gl?: unknown;
+    isWebGPU?: boolean;
+}
 /**
  * Representation of the types
  */
@@ -262,6 +269,20 @@ export declare class GaussianSplattingMeshBase extends Mesh {
     private static readonly _BatchSize;
     private _cameraViewInfos;
     protected static readonly _DefaultViewUpdateThreshold = 0.0001;
+    /**
+     * Returns a byte-accurate view for retained splat data, preserving any non-zero byte offset.
+     * @param data The retained splat source bytes.
+     * @returns A Uint8Array covering the exact source byte range.
+     * @internal
+     */
+    protected static _GetSplatDataBytes(data: ArrayBuffer | ArrayBufferView): Uint8Array;
+    /**
+     * Returns a Float32 reinterpretation for retained splat data, copying only when alignment requires it.
+     * @param data The retained splat source bytes.
+     * @returns A Float32Array over the exact source byte range.
+     * @internal
+     */
+    protected static _GetSplatDataFloats(data: ArrayBuffer | ArrayBufferView): Float32Array;
     /**
      * Cosine value of the angle threshold to update view dependent splat sorting. Default is 0.0001.
      */
@@ -573,6 +594,9 @@ export declare class GaussianSplattingMeshBase extends Mesh {
     refreshBoundingInfo(): Mesh;
     protected _updateSplatIndexBuffer(vertexCount: number): void;
     protected _updateTextureFromData: (texture: BaseTexture, data: ArrayBufferView, width: number, lineStart: number, lineCount: number) => void;
+    protected _updateTextureFromDataRect: (texture: BaseTexture, data: ArrayBufferView, xOffset: number, yOffset: number, width: number, height: number) => void;
+    protected _getTextureDataUpdateEngine(): ITextureDataUpdateCapableEngine;
+    protected _updateShTextureData(texture: BaseTexture, shData: Uint8Array, textureWidth: number, lineStart: number, lineCount: number): void;
     protected _updateSubTextures(centers: Float32Array, covA: Uint16Array, covB: Uint16Array, colors: Uint8Array, lineStart: number, lineCount: number, sh?: Uint8Array[]): void;
     protected _instantiateWorker(): void;
     protected _getTextureSize(length: number): Vector2;

package/Meshes/GaussianSplatting/gaussianSplattingMeshBase.js

@@ -191,6 +191,34 @@ var PLYValue;
  * @internal Use GaussianSplattingMesh instead; this class is an internal implementation detail.
  */
 export class GaussianSplattingMeshBase extends Mesh {
+    /**
+     * Returns a byte-accurate view for retained splat data, preserving any non-zero byte offset.
+     * @param data The retained splat source bytes.
+     * @returns A Uint8Array covering the exact source byte range.
+     * @internal
+     */
+    static _GetSplatDataBytes(data) {
+        return ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : new Uint8Array(data);
+    }
+    /**
+     * Returns a Float32 reinterpretation for retained splat data, copying only when alignment requires it.
+     * @param data The retained splat source bytes.
+     * @returns A Float32Array over the exact source byte range.
+     * @internal
+     */
+    static _GetSplatDataFloats(data) {
+        const bytes = GaussianSplattingMeshBase._GetSplatDataBytes(data);
+        const floatSize = Float32Array.BYTES_PER_ELEMENT;
+        if (bytes.byteLength % floatSize !== 0) {
+            throw new Error(`Gaussian splat data byte length (${bytes.byteLength}) is not divisible by ${floatSize} and cannot be reinterpreted as Float32 data.`);
+        }
+        if (bytes.byteOffset % floatSize !== 0) {
+            const copy = new Uint8Array(bytes.byteLength);
+            copy.set(bytes);
+            return new Float32Array(copy.buffer, 0, bytes.byteLength / floatSize);
+        }
+        return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / floatSize);
+    }
     /**
      * If true, disables depth sorting of the splats (default: false)
      */
@@ -436,7 +464,12 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._disableDepthSort = false;
         this._loadingPromise = null;
         this._updateTextureFromData = (texture, data, width, lineStart, lineCount) => {
-            this.getEngine().updateTextureData(texture.getInternalTexture(), data, 0, lineStart, width, lineCount, 0, 0, false);
+            const engine = this._getTextureDataUpdateEngine();
+            engine.updateTextureData(texture.getInternalTexture(), data, 0, lineStart, width, lineCount, 0, 0, false);
+        };
+        this._updateTextureFromDataRect = (texture, data, xOffset, yOffset, width, height) => {
+            const engine = this._getTextureDataUpdateEngine();
+            engine.updateTextureData(texture.getInternalTexture(), data, xOffset, yOffset, width, height, 0, 0, false);
         };
         this.subMeshes = [];
         new SubMesh(0, 0, 4 * GaussianSplattingMeshBase._BatchSize, 0, 6 * GaussianSplattingMeshBase._BatchSize, this);
@@ -1702,8 +1735,8 @@ export class GaussianSplattingMeshBase extends Mesh {
         const createTextureFromDataU8 = (data, width, height, format) => {
             return new RawTexture(data, width, height, format, this._scene, false, false, 2, 0);
         };
-        const createTextureFromDataU32 = (data, width, height, format) => {
-            return new RawTexture(data, width, height, format, this._scene, false, false, 1, 7);
+        const createEmptyTextureU32 = (width, height, format) => {
+            return new RawTexture(null, width, height, format, this._scene, false, false, 1, 7);
         };
         const createTextureFromDataF16 = (data, width, height, format) => {
             return new RawTexture(data, width, height, format, this._scene, false, false, 2, 2);
@@ -1720,12 +1753,12 @@ export class GaussianSplattingMeshBase extends Mesh {
             // Handle SH textures in update path - create if they don't exist
             if (sh && !this._shTextures) {
                 this._shTextures = [];
-                for (const shData of sh) {
-                    const buffer = new Uint32Array(shData.buffer);
-                    const shTexture = createTextureFromDataU32(buffer, textureSize.x, textureSize.y, 11);
+                for (let textureIndex = 0; textureIndex < sh.length; textureIndex++) {
+                    const shTexture = createEmptyTextureU32(textureSize.x, textureSize.y, 11);
                     shTexture.wrapU = 0;
                     shTexture.wrapV = 0;
                     this._shTextures.push(shTexture);
+                    this._updateShTextureData(shTexture, sh[textureIndex], textureSize.x, 0, textureSize.y);
                 }
             }
             if (this._needsRotationScaleTextures && this._rotationDataA) {
@@ -1758,13 +1791,15 @@ export class GaussianSplattingMeshBase extends Mesh {
             this._colorsTexture = createTextureFromDataU8(colorArray, textureSize.x, textureSize.y, 5);
             if (sh) {
                 this._shTextures = [];
-                for (const shData of sh) {
-                    const buffer = new Uint32Array(shData.buffer);
-                    const shTexture = createTextureFromDataU32(buffer, textureSize.x, textureSize.y, 11);
+                for (let textureIndex = 0; textureIndex < sh.length; textureIndex++) {
+                    const shTexture = createEmptyTextureU32(textureSize.x, textureSize.y, 11);
                     shTexture.wrapU = 0;
                     shTexture.wrapV = 0;
                     this._shTextures.push(shTexture);
                 }
+                for (let textureIndex = 0; textureIndex < sh.length; textureIndex++) {
+                    this._updateShTextureData(this._shTextures[textureIndex], sh[textureIndex], textureSize.x, 0, textureSize.y);
+                }
             }
             if (this._needsRotationScaleTextures) {
                 const rotDataA = this._rotationDataA ?? new Uint16Array(covA.length);
@@ -2007,6 +2042,52 @@ export class GaussianSplattingMeshBase extends Mesh {
         }
         this.forcedInstanceCount = Math.max(paddedVertexCount >> 4, 1);
     }
+    _getTextureDataUpdateEngine() {
+        return this.getEngine();
+    }
+    _updateShTextureData(texture, shData, textureWidth, lineStart, lineCount) {
+        const engine = this._getTextureDataUpdateEngine();
+        // NativeEngine/NullEngine, updateTextureData unsupported
+        if (!engine._gl && !engine.isWebGPU) {
+            const internalTexture = texture.getInternalTexture();
+            const expectedByteLength = textureWidth * internalTexture.height * 16;
+            let uploadData;
+            if (shData.byteLength === expectedByteLength && shData.byteOffset % Uint32Array.BYTES_PER_ELEMENT === 0) {
+                uploadData = new Uint32Array(shData.buffer, shData.byteOffset, shData.byteLength / Uint32Array.BYTES_PER_ELEMENT);
+            }
+            else {
+                const padded = new Uint8Array(expectedByteLength);
+                padded.set(shData.subarray(0, Math.min(shData.byteLength, expectedByteLength)));
+                uploadData = new Uint32Array(padded.buffer);
+            }
+            engine.updateRawTexture(internalTexture, uploadData, internalTexture.format, internalTexture.invertY, null, internalTexture.type, internalTexture._useSRGBBuffer);
+            return;
+        }
+        const bytesPerTexel = 16;
+        const componentsPerTexel = 4;
+        const startTexel = lineStart * textureWidth;
+        const availableTexelCount = Math.floor(shData.byteLength / bytesPerTexel);
+        if (startTexel >= availableTexelCount) {
+            return;
+        }
+        let texelCount = Math.min(lineCount * textureWidth, availableTexelCount - startTexel);
+        if (texelCount <= 0) {
+            return;
+        }
+        const createView = (byteOffset, viewTexelCount) => {
+            return new Uint32Array(shData.buffer, shData.byteOffset + byteOffset, viewTexelCount * componentsPerTexel);
+        };
+        const fullRowCount = Math.floor(texelCount / textureWidth);
+        if (fullRowCount > 0) {
+            const fullRowTexelCount = fullRowCount * textureWidth;
+            this._updateTextureFromData(texture, createView(startTexel * bytesPerTexel, fullRowTexelCount), textureWidth, lineStart, fullRowCount);
+            texelCount -= fullRowTexelCount;
+        }
+        if (texelCount > 0) {
+            const partialRowOffset = (startTexel + fullRowCount * textureWidth) * bytesPerTexel;
+            this._updateTextureFromDataRect(texture, createView(partialRowOffset, texelCount), 0, lineStart + fullRowCount, texelCount, 1);
+        }
+    }
     _updateSubTextures(centers, covA, covB, colors, lineStart, lineCount, sh) {
         const textureSize = this._getTextureSize(this._vertexCount);
         const covBSItemSize = this._useRGBACovariants ? 4 : 2;
@@ -2030,9 +2111,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         }
         if (sh) {
             for (let i = 0; i < sh.length; i++) {
-                const componentCount = 4;
-                const shView = new Uint32Array(sh[i].buffer, texelStart * componentCount * 4, texelCount * componentCount);
-                this._updateTextureFromData(this._shTextures[i], shView, textureSize.x, lineStart, lineCount);
+                this._updateShTextureData(this._shTextures[i], sh[i], textureSize.x, lineStart, lineCount);
             }
         }
     }
@@ -2164,12 +2243,8 @@ export class GaussianSplattingMeshBase extends Mesh {
         if (!srcRaw || srcCount === 0) {
             return;
         }
-        // _splatsData is typed as ArrayBuffer but callers may have stored a TypedArray before this
-        // guard was added. Extract the underlying ArrayBuffer so Float32Array reinterprets bytes
-        // correctly instead of value-converting each element.
-        const srcBuffer = srcRaw instanceof ArrayBuffer ? srcRaw : srcRaw.buffer;
-        const uBuffer = new Uint8Array(srcBuffer);
-        const fBuffer = new Float32Array(srcBuffer);
+        const uBuffer = GaussianSplattingMeshBase._GetSplatDataBytes(srcRaw);
+        const fBuffer = GaussianSplattingMeshBase._GetSplatDataFloats(srcRaw);
         for (let i = 0; i < srcCount; i++) {
             this._makeSplat(dstOffset + i, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum, false, i);
         }