@onerjs/core 8.32.7 → 8.32.9

package/Meshes/GaussianSplatting/gaussianSplattingMesh.d.ts

@@ -8,6 +8,9 @@ import { Vector3 } from "../../Maths/math.vector.js";
 import "../thinInstanceMesh.js";
 import type { Material } from "../../Materials/material.js";
 import type { Camera } from "../../Cameras/camera.js";
+interface IUpdateOptions {
+    flipY?: boolean;
+}
 /**
  * Representation of the types
  */
@@ -194,7 +197,6 @@ export declare class GaussianSplattingMesh extends Mesh {
     private _splatIndex;
     private _shTextures;
     private _splatsData;
-    private _sh;
     private readonly _keepInRam;
     private _delayedTextureUpdate;
     private _useRGBACovariants;
@@ -206,13 +208,13 @@ export declare class GaussianSplattingMesh extends Mesh {
     private static _SplatBatchSize;
     private static _PlyConversionBatchSize;
     private _shDegree;
-    private _viewDirectionFactor;
     private static readonly _BatchSize;
     private _cameraViewInfos;
     /**
      * View direction factor used to compute the SH view direction in the shader.
+     * @deprecated Not used anymore for SH rendering
      */
-    get viewDirectionFactor(): Vector3;
+    get viewDirectionFactor(): import("../../types.js").DeepImmutableObject<Vector3>;
     /**
      * SH degree. 0 = no sh (default). 1 = 3 parameters. 2 = 8 parameters. 3 = 15 parameters.
      */
@@ -261,6 +263,7 @@ export declare class GaussianSplattingMesh extends Mesh {
      * Get the compensation state
      */
     get compensation(): boolean;
+    private _loadingPromise;
     /**
      * set rendering material
      */
@@ -278,6 +281,11 @@ export declare class GaussianSplattingMesh extends Mesh {
      * @param keepInRam keep datas in ram for editing purpose
      */
     constructor(name: string, url?: Nullable<string>, scene?: Nullable<Scene>, keepInRam?: boolean);
+    /**
+     * Get the loading promise when loading the mesh from a URL in the constructor
+     * @returns constructor loading promise or null if no URL was provided
+     */
+    getLoadingPromise(): Promise<void> | null;
     /**
      * Returns the class name
      * @returns "GaussianSplattingMesh"
@@ -364,12 +372,13 @@ export declare class GaussianSplattingMesh extends Mesh {
      */
     loadDataAsync(data: ArrayBuffer): Promise<void>;
     /**
-     * Loads a .splat Gaussian or .ply Splatting file asynchronously
+     * Loads a Gaussian or Splatting file asynchronously
      * @param url path to the splat file to load
+     * @param scene optional scene it belongs to
      * @returns a promise that resolves when the operation is complete
      * @deprecated Please use SceneLoader.ImportMeshAsync instead
      */
-    loadFileAsync(url: string): Promise<void>;
+    loadFileAsync(url: string, scene?: Scene): Promise<void>;
     /**
      * Releases resources associated with this mesh.
      * @param doNotRecurse Set to true to not recurse into each children (recurse into each children by default)
@@ -399,8 +408,9 @@ export declare class GaussianSplattingMesh extends Mesh {
      * Update data from GS (position, orientation, color, scaling)
      * @param data array that contain all the datas
      * @param sh optional array of uint8 array for SH data
+     * @param options optional informations on how to treat data
      */
-    updateData(data: ArrayBuffer, sh?: Uint8Array[]): void;
+    updateData(data: ArrayBuffer, sh?: Uint8Array[], options?: IUpdateOptions): void;
     /**
      * Refreshes the bounding info, taking into account all the thin instances defined
      * @returns the current Gaussian Splatting

package/Meshes/GaussianSplatting/gaussianSplattingMesh.js

@@ -6,12 +6,12 @@ import { Logger } from "../../Misc/logger.js";
 import { GaussianSplattingMaterial } from "../../Materials/GaussianSplatting/gaussianSplattingMaterial.js";
 import { RawTexture } from "../../Materials/Textures/rawTexture.js";
 
-import { Tools } from "../../Misc/tools.js";
 import "../thinInstanceMesh.js";
 import { ToHalfFloat } from "../../Misc/textureTools.js";
 import { Scalar } from "../../Maths/math.scalar.js";
 import { runCoroutineSync, runCoroutineAsync, createYieldingScheduler } from "../../Misc/coroutine.js";
 import { EngineStore } from "../../Engines/engineStore.js";
+import { ImportMeshAsync } from "../../Loading/sceneLoader.js";
 // @internal
 const UnpackUnorm = (value, bits) => {
     const t = (1 << bits) - 1;
@@ -163,9 +163,10 @@ var PLYValue;
 export class GaussianSplattingMesh extends Mesh {
     /**
      * View direction factor used to compute the SH view direction in the shader.
+     * @deprecated Not used anymore for SH rendering
      */
     get viewDirectionFactor() {
-        return this._viewDirectionFactor;
+        return Vector3.OneReadOnly;
     }
     /**
      * SH degree. 0 = no sh (default). 1 = 3 parameters. 2 = 8 parameters. 3 = 15 parameters.
@@ -235,7 +236,7 @@ export class GaussianSplattingMesh extends Mesh {
      */
     set material(value) {
         this._material = value;
-        this._material.backFaceCulling = true;
+        this._material.backFaceCulling = false;
         this._material.cullBackFaces = false;
         value.resetDrawCache();
     }
@@ -288,7 +289,6 @@ export class GaussianSplattingMesh extends Mesh {
         this._splatIndex = null;
         this._shTextures = null;
         this._splatsData = null;
-        this._sh = null;
         this._keepInRam = false;
         this._delayedTextureUpdate = null;
         this._useRGBACovariants = false;
@@ -296,8 +296,8 @@ export class GaussianSplattingMesh extends Mesh {
         this._tmpCovariances = [0, 0, 0, 0, 0, 0];
         this._sortIsDirty = false;
         this._shDegree = 0;
-        this._viewDirectionFactor = new Vector3(1, 1, -1);
         this._cameraViewInfos = new Map();
+        this._loadingPromise = null;
         this.subMeshes = [];
         new SubMesh(0, 0, 4 * GaussianSplattingMesh._BatchSize, 0, 6 * GaussianSplattingMesh._BatchSize, this);
         this.setEnabled(false);
@@ -305,8 +305,7 @@ export class GaussianSplattingMesh extends Mesh {
         this._useRGBACovariants = !this.getEngine().isWebGPU && this.getEngine().version === 1.0;
         this._keepInRam = keepInRam;
         if (url) {
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            this.loadFileAsync(url);
+            this._loadingPromise = this.loadFileAsync(url);
         }
         const gaussianSplattingMaterial = new GaussianSplattingMaterial(this.name + "_material", this._scene);
         gaussianSplattingMaterial.setSourceMesh(this);
@@ -322,6 +321,13 @@ export class GaussianSplattingMesh extends Mesh {
             }
         });
     }
+    /**
+     * Get the loading promise when loading the mesh from a URL in the constructor
+     * @returns constructor loading promise or null if no URL was provided
+     */
+    getLoadingPromise() {
+        return this._loadingPromise;
+    }
     /**
      * Returns the class name
      * @returns "GaussianSplattingMesh"
@@ -355,11 +361,11 @@ export class GaussianSplattingMesh extends Mesh {
     _getCameraDirection(camera) {
         const cameraMatrix = camera.getViewMatrix();
         this.getWorldMatrix().multiplyToRef(cameraMatrix, this._modelViewMatrix);
-        cameraMatrix.invertToRef(TmpVectors.Matrix[0]);
-        this.getWorldMatrix().multiplyToRef(TmpVectors.Matrix[0], TmpVectors.Matrix[1]);
-        Vector3.TransformNormalToRef(Vector3.Forward(this._scene.useRightHandedSystem), TmpVectors.Matrix[1], TmpVectors.Vector3[2]);
-        TmpVectors.Vector3[2].normalize();
-        return TmpVectors.Vector3[2];
+        // return vector used to compute distance to camera
+        const localDirection = TmpVectors.Vector3[1];
+        localDirection.set(this._modelViewMatrix.m[2], this._modelViewMatrix.m[6], this._modelViewMatrix.m[10]);
+        localDirection.normalize();
+        return localDirection;
     }
     /** @internal */
     _postToWorker(forced = false) {
@@ -692,10 +698,10 @@ export class GaussianSplattingMesh extends Mesh {
                         shDegree = 3;
                     }
                     else if (value >= 64 /* PLYValue.SH_24 */) {
-                        shDegree = 2;
+                        shDegree = Math.max(shDegree, 2);
                     }
                     else if (value >= 48 /* PLYValue.SH_8 */) {
-                        shDegree = 1;
+                        shDegree = Math.max(shDegree, 1);
                     }
                 }
                 const type = GaussianSplattingMesh._TypeNameToEnum(typeName);
@@ -1104,15 +1110,14 @@ export class GaussianSplattingMesh extends Mesh {
         return await this.updateDataAsync(data);
     }
     /**
-     * Loads a .splat Gaussian or .ply Splatting file asynchronously
+     * Loads a Gaussian or Splatting file asynchronously
      * @param url path to the splat file to load
+     * @param scene optional scene it belongs to
      * @returns a promise that resolves when the operation is complete
      * @deprecated Please use SceneLoader.ImportMeshAsync instead
      */
-    async loadFileAsync(url) {
-        const plyBuffer = await Tools.LoadFileAsync(url, true);
-        const splatsData = await GaussianSplattingMesh.ConvertPLYWithSHToSplatAsync(plyBuffer);
-        await this.updateDataAsync(splatsData.buffer, splatsData.sh);
+    async loadFileAsync(url, scene) {
+        await ImportMeshAsync(url, (scene || EngineStore.LastCreatedScene), { pluginOptions: { splat: { gaussianSplattingMesh: this } } });
     }
     /**
      * Releases resources associated with this mesh.
@@ -1187,13 +1192,13 @@ export class GaussianSplattingMesh extends Mesh {
         covB[index * covBSItemSize + 1] = ToHalfFloat(0);
         colorArray[index * 4 + 3] = 0;
     }
-    _makeSplat(index, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum) {
+    _makeSplat(index, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum, options) {
         const matrixRotation = TmpVectors.Matrix[0];
         const matrixScale = TmpVectors.Matrix[1];
         const quaternion = TmpVectors.Quaternion[0];
         const covBSItemSize = this._useRGBACovariants ? 4 : 2;
         const x = fBuffer[8 * index + 0];
-        const y = -fBuffer[8 * index + 1];
+        const y = fBuffer[8 * index + 1] * (options.flipY ? -1 : 1);
         const z = fBuffer[8 * index + 2];
         this._splatPositions[4 * index + 0] = x;
         this._splatPositions[4 * index + 1] = y;
@@ -1271,7 +1276,7 @@ export class GaussianSplattingMesh extends Mesh {
             this._instanciateWorker();
         }
     }
-    *_updateData(data, isAsync, sh) {
+    *_updateData(data, isAsync, sh, options = { flipY: false }) {
         // if a covariance texture is present, then it's not a creation but an update
         if (!this._covariancesATexture) {
             this._readyToDisplay = false;
@@ -1281,9 +1286,7 @@ export class GaussianSplattingMesh extends Mesh {
         const fBuffer = new Float32Array(uBuffer.buffer);
         if (this._keepInRam) {
             this._splatsData = data;
-            if (sh) {
-                this._sh = sh;
-            }
+            // keep sh in ram too ?
         }
         const vertexCount = uBuffer.length / GaussianSplattingMesh._RowOutputLength;
         if (vertexCount != this._vertexCount) {
@@ -1311,7 +1314,7 @@ export class GaussianSplattingMesh extends Mesh {
                 const updateLine = partIndex * lineCountUpdate;
                 const splatIndexBase = updateLine * textureSize.x;
                 for (let i = 0; i < textureLengthPerUpdate; i++) {
-                    this._makeSplat(splatIndexBase + i, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum);
+                    this._makeSplat(splatIndexBase + i, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum, options);
                 }
                 this._updateSubTextures(this._splatPositions, covA, covB, colorArray, updateLine, Math.min(lineCountUpdate, textureSize.y - updateLine));
                 // Update the binfo
@@ -1329,7 +1332,7 @@ export class GaussianSplattingMesh extends Mesh {
         else {
             const paddedVertexCount = (vertexCount + 15) & ~0xf;
             for (let i = 0; i < vertexCount; i++) {
-                this._makeSplat(i, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum);
+                this._makeSplat(i, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum, options);
                 if (isAsync && i % GaussianSplattingMesh._SplatBatchSize === 0) {
                     yield;
                 }
@@ -1343,6 +1346,7 @@ export class GaussianSplattingMesh extends Mesh {
             // Update the binfo
             this.getBoundingInfo().reConstruct(minimum, maximum, this.getWorldMatrix());
             this.setEnabled(true);
+            this._sortIsDirty = true;
         }
         this._postToWorker(true);
     }
@@ -1360,9 +1364,10 @@ export class GaussianSplattingMesh extends Mesh {
      * Update data from GS (position, orientation, color, scaling)
      * @param data array that contain all the datas
      * @param sh optional array of uint8 array for SH data
+     * @param options optional informations on how to treat data
      */
-    updateData(data, sh) {
-        runCoroutineSync(this._updateData(data, false, sh));
+    updateData(data, sh, options = { flipY: true }) {
+        runCoroutineSync(this._updateData(data, false, sh, options));
     }
     /**
      * Refreshes the bounding info, taking into account all the thin instances defined
@@ -1403,7 +1408,7 @@ export class GaussianSplattingMesh extends Mesh {
         if (sh) {
             for (let i = 0; i < sh.length; i++) {
                 const componentCount = 4;
-                const shView = new Uint8Array(this._sh[i].buffer, texelStart * componentCount, texelCount * componentCount);
+                const shView = new Uint32Array(sh[i].buffer, texelStart * componentCount * 4, texelCount * componentCount);
                 updateTextureFromData(this._shTextures[i], shView, textureSize.x, lineStart, lineCount);
             }
         }
@@ -1421,7 +1426,7 @@ export class GaussianSplattingMesh extends Mesh {
         const vertexCountPadded = (this._vertexCount + 15) & ~0xf;
         this._depthMix = new BigInt64Array(vertexCountPadded);
         const positions = Float32Array.from(this._splatPositions);
-        this._worker.postMessage({ positions, vertexCountPadded }, [positions.buffer]);
+        this._worker.postMessage({ positions }, [positions.buffer]);
         this._worker.onmessage = (e) => {
             this._depthMix = e.data.depthMix;
             const cameraId = e.data.cameraId;
@@ -1490,7 +1495,6 @@ GaussianSplattingMesh._BatchSize = 16; // 16 splats per instance
  */
 GaussianSplattingMesh.ProgressiveUpdateAmount = 0;
 GaussianSplattingMesh._CreateWorker = function (self) {
-    let vertexCountPadded = 0;
     let positions;
     let depthMix;
     let indices;
@@ -1499,12 +1503,12 @@ GaussianSplattingMesh._CreateWorker = function (self) {
         // updated on init
         if (e.data.positions) {
             positions = e.data.positions;
-            vertexCountPadded = e.data.vertexCountPadded;
         }
         // udpate on view changed
         else {
             const cameraId = e.data.cameraId;
             const viewProj = e.data.view;
+            const vertexCountPadded = (positions.length + 15) & ~0xf;
             if (!positions || !viewProj) {
                 // Sanity check, it shouldn't happen!
                 throw new Error("positions or view is not defined!");