Merge pull request #12838 from CesiumGS/gsplat-buffer-fix

GaussianSplatPrimitive Multiple Instances Fix

Author: ggetz

CHANGES.md

@@ -12,6 +12,7 @@
 - Improved performance and reduced memory usage of `Event` class. [#12896](https://github.com/CesiumGS/cesium/pull/12896)
 - Fixes vertical misalignment of glyphs in labels with small fonts [#8474](https://github.com/CesiumGS/cesium/issues/8474)
 - Prevent runtime errors for certain forms of invalid PNTS files [#12872](https://github.com/CesiumGS/cesium/issues/12872)
+- Fixes issue where multiple instances of a Gaussian splat tileset would transform tile positions incorrectly and render out of position. [#12795](https://github.com/CesiumGS/cesium/issues/12795)
 
 #### Additions :tada:
 

packages/engine/Source/Scene/GaussianSplat3DTileContent.js

@@ -31,15 +31,28 @@ function GaussianSplat3DTileContent(loader, tileset, tile, resource) {
   }
 
   /**
-   * Original position, scale and rotation values for splats. Used to maintain
-   * consistency when multiple transforms may occur. Downstream consumers otherwise may not know
-   * the underlying data was modified.
+   * Local copy of the position attribute buffer that has been transformed into root tile space. Originals are kept in the gltf loader.
+   * Used for rendering
    * @type {undefined|Float32Array}
    * @private
    */
-  this._originalPositions = undefined;
-  this._originalRotations = undefined;
-  this._originalScales = undefined;
+  this._positions = undefined;
+
+  /**
+   * Local copy of the rotation attribute buffer that has been transformed into root tile space. Originals are kept in the gltf loader.
+   * Used for rendering
+   * @type {undefined|Float32Array}
+   * @private
+   */
+  this._rotations = undefined;
+
+  /**
+   * Local copy of the scale attribute buffer that has been transformed into root tile space. Originals are kept in the gltf loader.
+   * Used for rendering
+   * @type {undefined|Float32Array}
+   * @private
+   */
+  this._scales = undefined;
 
   /**
    * glTF primitive data that contains the Gaussian splat data needed for rendering.
@@ -368,6 +381,38 @@ Object.defineProperties(GaussianSplat3DTileContent.prototype, {
     },
   },
 
+  /**
+   * Get the transformed positions of this tile's Gaussian splats.
+   * @type {undefined|Float32Array}
+   * @private
+   */
+  positions: {
+    get: function () {
+      return this._positions;
+    },
+  },
+  /**
+   * Get the transformed rotations of this tile's Gaussian splats.
+   * @type {undefined|Float32Array}
+   * @private
+   */
+  rotations: {
+    get: function () {
+      return this._rotations;
+    },
+  },
+
+  /**
+   * Get the transformed scales of this tile's Gaussian splats.
+   * @type {undefined|Float32Array}
+   * @private
+   */
+  scales: {
+    get: function () {
+      return this._scales;
+    },
+  },
+
   /**
    * The number of spherical harmonic coefficients used for the Gaussian splats.
    * @type {number}
@@ -629,21 +674,21 @@ GaussianSplat3DTileContent.prototype.update = function (primitive, frameState) {
     this.worldTransform = loader.components.scene.nodes[0].matrix;
     this._ready = true;
 
-    this._originalPositions = new Float32Array(
+    this._positions = new Float32Array(
       ModelUtility.getAttributeBySemantic(
         this.gltfPrimitive,
         VertexAttributeSemantic.POSITION,
       ).typedArray,
     );
 
-    this._originalRotations = new Float32Array(
+    this._rotations = new Float32Array(
       ModelUtility.getAttributeBySemantic(
         this.gltfPrimitive,
         VertexAttributeSemantic.ROTATION,
       ).typedArray,
     );
 
-    this._originalScales = new Float32Array(
+    this._scales = new Float32Array(
       ModelUtility.getAttributeBySemantic(
         this.gltfPrimitive,
         VertexAttributeSemantic.SCALE,

packages/engine/Source/Scene/GaussianSplatPrimitive.js

@@ -450,9 +450,9 @@ GaussianSplatPrimitive.transformTile = function (tile) {
     computedModelMatrix,
     scratchMatrix4A,
   );
-  const positions = tile.content._originalPositions;
-  const rotations = tile.content._originalRotations;
-  const scales = tile.content._originalScales;
+  const positions = tile.content.positions;
+  const rotations = tile.content.rotations;
+  const scales = tile.content.scales;
   const attributePositions = ModelUtility.getAttributeBySemantic(
     gltfPrimitive,
     VertexAttributeSemantic.POSITION,
@@ -471,19 +471,19 @@ GaussianSplatPrimitive.transformTile = function (tile) {
   const position = new Cartesian3();
   const rotation = new Quaternion();
   const scale = new Cartesian3();
-  for (let i = 0; i < positions.length / 3; ++i) {
-    position.x = positions[i * 3];
-    position.y = positions[i * 3 + 1];
-    position.z = positions[i * 3 + 2];
+  for (let i = 0; i < attributePositions.length / 3; ++i) {
+    position.x = attributePositions[i * 3];
+    position.y = attributePositions[i * 3 + 1];
+    position.z = attributePositions[i * 3 + 2];
 
-    rotation.x = rotations[i * 4];
-    rotation.y = rotations[i * 4 + 1];
-    rotation.z = rotations[i * 4 + 2];
-    rotation.w = rotations[i * 4 + 3];
+    rotation.x = attributeRotations[i * 4];
+    rotation.y = attributeRotations[i * 4 + 1];
+    rotation.z = attributeRotations[i * 4 + 2];
+    rotation.w = attributeRotations[i * 4 + 3];
 
-    scale.x = scales[i * 3];
-    scale.y = scales[i * 3 + 1];
-    scale.z = scales[i * 3 + 2];
+    scale.x = attributeScales[i * 3];
+    scale.y = attributeScales[i * 3 + 1];
+    scale.z = attributeScales[i * 3 + 2];
 
     Matrix4.fromTranslationQuaternionRotationScale(
       position,
@@ -498,18 +498,18 @@ GaussianSplatPrimitive.transformTile = function (tile) {
     Matrix4.getRotation(scratchMatrix4C, rotation);
     Matrix4.getScale(scratchMatrix4C, scale);
 
-    attributePositions[i * 3] = position.x;
-    attributePositions[i * 3 + 1] = position.y;
-    attributePositions[i * 3 + 2] = position.z;
+    positions[i * 3] = position.x;
+    positions[i * 3 + 1] = position.y;
+    positions[i * 3 + 2] = position.z;
 
-    attributeRotations[i * 4] = rotation.x;
-    attributeRotations[i * 4 + 1] = rotation.y;
-    attributeRotations[i * 4 + 2] = rotation.z;
-    attributeRotations[i * 4 + 3] = rotation.w;
+    rotations[i * 4] = rotation.x;
+    rotations[i * 4 + 1] = rotation.y;
+    rotations[i * 4 + 2] = rotation.z;
+    rotations[i * 4 + 3] = rotation.w;
 
-    attributeScales[i * 3] = scale.x;
-    attributeScales[i * 3 + 1] = scale.y;
-    attributeScales[i * 3 + 2] = scale.z;
+    scales[i * 3] = scale.x;
+    scales[i * 3 + 1] = scale.y;
+    scales[i * 3 + 2] = scale.z;
   }
 };
 
@@ -860,21 +860,27 @@ GaussianSplatPrimitive.prototype.update = function (frameState) {
       const aggregateAttributeValues = (
         componentDatatype,
         getAttributeCallback,
+        numberOfComponents,
       ) => {
         let aggregate;
         let offset = 0;
         for (const tile of tiles) {
-          const primitive = tile.content.gltfPrimitive;
-          const attribute = getAttributeCallback(primitive);
+          const content = tile.content;
+          const attribute = getAttributeCallback(content);
+          const componentsPerAttribute = defined(numberOfComponents)
+            ? numberOfComponents
+            : AttributeType.getNumberOfComponents(attribute.type);
+          const buffer = defined(attribute.typedArray)
+            ? attribute.typedArray
+            : attribute;
           if (!defined(aggregate)) {
             aggregate = ComponentDatatype.createTypedArray(
               componentDatatype,
-              totalElements *
-                AttributeType.getNumberOfComponents(attribute.type),
+              totalElements * componentsPerAttribute,
             );
           }
-          aggregate.set(attribute.typedArray, offset);
-          offset += attribute.typedArray.length;
+          aggregate.set(buffer, offset);
+          offset += buffer.length;
         }
         return aggregate;
       };
@@ -906,36 +912,27 @@ GaussianSplatPrimitive.prototype.update = function (frameState) {
 
       this._positions = aggregateAttributeValues(
         ComponentDatatype.FLOAT,
-        (gltfPrimitive) =>
-          ModelUtility.getAttributeBySemantic(
-            gltfPrimitive,
-            VertexAttributeSemantic.POSITION,
-          ),
+        (content) => content.positions,
+        3,
       );
 
       this._scales = aggregateAttributeValues(
         ComponentDatatype.FLOAT,
-        (gltfPrimitive) =>
-          ModelUtility.getAttributeBySemantic(
-            gltfPrimitive,
-            VertexAttributeSemantic.SCALE,
-          ),
+        (content) => content.scales,
+        3,
       );
 
       this._rotations = aggregateAttributeValues(
         ComponentDatatype.FLOAT,
-        (gltfPrimitive) =>
-          ModelUtility.getAttributeBySemantic(
-            gltfPrimitive,
-            VertexAttributeSemantic.ROTATION,
-          ),
+        (content) => content.rotations,
+        4,
       );
 
       this._colors = aggregateAttributeValues(
         ComponentDatatype.UNSIGNED_BYTE,
-        (gltfPrimitive) =>
+        (content) =>
           ModelUtility.getAttributeBySemantic(
-            gltfPrimitive,
+            content.gltfPrimitive,
             VertexAttributeSemantic.COLOR,
           ),
       );

packages/engine/Specs/Scene/GaussianSplat3DTileContentSpec.js

@@ -11,6 +11,7 @@ import {
 
 import Cesium3DTilesTester from "../../../../Specs/Cesium3DTilesTester.js";
 import createScene from "../../../../Specs/createScene.js";
+import pollToPromise from "../../../../Specs/pollToPromise.js";
 
 describe(
   "Scene/GaussianSplat3DTileContent",
@@ -96,6 +97,7 @@ describe(
         },
       );
     });
+
     it("Create and destroy GaussianSplat3DTileContent", async function () {
       const tileset = await Cesium3DTilesTester.loadTileset(
         scene,
@@ -116,6 +118,69 @@ describe(
       expect(tile.isDestroyed()).toBe(true);
       expect(tile.content).toBeUndefined();
     });
+
+    it("Load multiple instances of Gaussian splat tileset and validate transformed attributes", async function () {
+      const tileset = await Cesium3DTilesTester.loadTileset(
+        scene,
+        tilesetUrl,
+        options,
+      );
+      scene.camera.lookAt(
+        tileset.boundingSphere.center,
+        new HeadingPitchRange(0.0, -1.57, tileset.boundingSphere.radius),
+      );
+
+      const tileset2 = await Cesium3DTilesTester.loadTileset(
+        scene,
+        tilesetUrl,
+        options,
+      );
+
+      const tile = await Cesium3DTilesTester.waitForTileContentReady(
+        scene,
+        tileset.root,
+      );
+
+      scene.camera.lookAt(
+        tileset2.boundingSphere.center,
+        new HeadingPitchRange(0.0, -1.57, tileset2.boundingSphere.radius),
+      );
+
+      const tile2 = await Cesium3DTilesTester.waitForTileContentReady(
+        scene,
+        tileset2.root,
+      );
+      const content = tile.content;
+      const content2 = tile2.content;
+
+      expect(content).toBeDefined();
+      expect(content instanceof GaussianSplat3DTileContent).toBe(true);
+      expect(content2).toBeDefined();
+      expect(content2 instanceof GaussianSplat3DTileContent).toBe(true);
+
+      await pollToPromise(function () {
+        scene.renderForSpecs();
+        return (
+          tile.content._transformed === true &&
+          tile2.content._transformed === true
+        );
+      });
+
+      const positions1 = tile.content._positions;
+      const positions2 = tile2.content._positions;
+
+      expect(positions1.every((p, i) => p === positions2[i])).toBe(true);
+
+      const rotations1 = tile.content._rotations;
+      const rotations2 = tile2.content._rotations;
+
+      expect(rotations1.every((r, i) => r === rotations2[i])).toBe(true);
+
+      const scales1 = tile.content._scales;
+      const scales2 = tile2.content._scales;
+
+      expect(scales1.every((s, i) => s === scales2[i])).toBe(true);
+    });
   },
   "WebGL",
 );