@cesium/engine 20.0.2-ion.0 → 21.0.1-ion.0

package/Source/Scene/ClippingPolygon.js

@@ -46,7 +46,90 @@ function ClippingPolygon(options) {
   //>>includeEnd('debug');
 
   this._ellipsoid = options.ellipsoid ?? Ellipsoid.default;
-  this._positions = [...options.positions];
+  this._positions = copyArrayCartesian3(options.positions);
+
+  /**
+   * A copy of the input positions.
+   *
+   * This is used to detect modifications of the positions in
+   * <code>coputeRectangle</code>: The rectangle only has
+   * to be re-computed when these positions have changed.
+   *
+   * @type {Cartesian3[]|undefined}
+   * @private
+   */
+  this._cachedPositions = undefined;
+
+  /**
+   * A cached version of the rectangle that is computed in
+   * <code>computeRectangle</code>.
+   *
+   * This is only re-computed when the positions have changed, as
+   * determined  by comparing the <code>_positions</code> to the
+   * <code>_cachedPositions</code>
+   *
+   * @type {Rectangle|undefined}
+   * @private
+   */
+  this._cachedRectangle = undefined;
+}
+
+/**
+ * Returns a deep copy of the given array.
+ *
+ * If the input is undefined, then <code>undefined</code> is returned.
+ *
+ * Otherwise, the result will be a copy of the given array, where
+ * each element is copied with <code>Cartesian3.clone</code>.
+ *
+ * @param {Cartesian3[]|undefined} input The input array
+ * @returns {Cartesian3[]|undefined} The copy
+ */
+function copyArrayCartesian3(input) {
+  if (!defined(input)) {
+    return undefined;
+  }
+  const n = input.length;
+  const output = Array(n);
+  for (let i = 0; i < n; i++) {
+    output[i] = Cartesian3.clone(input[i]);
+  }
+  return output;
+}
+
+/**
+ * Returns whether the given arrays are component-wise equal.
+ *
+ * When both arrays are undefined, then <code>true</code> is returned.
+ * When only one array is defined, or they are both defined but have
+ * different lengths, then <code>false</code> is returned.
+ *
+ * Otherwise, returns whether the corresponding elements of the arrays
+ * are equal, as of <code>Cartesian3.equals</code>.
+ *
+ * @param {Cartesian3[]|undefined} a The first array
+ * @param {Cartesian3[]|undefined} b The second array
+ * @returns {boolean} Whether the arrays are equal
+ */
+function equalsArrayCartesian3(a, b) {
+  if (!defined(a) && !defined(b)) {
+    return true;
+  }
+  if (defined(a) !== defined(b)) {
+    return false;
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  const n = a.length;
+  for (let i = 0; i < n; i++) {
+    const ca = a[i];
+    const cb = b[i];
+    if (!Cartesian3.equals(ca, cb)) {
+      return false;
+    }
+  }
+  return true;
 }
 
 Object.defineProperties(ClippingPolygon.prototype, {
@@ -138,12 +221,18 @@ ClippingPolygon.equals = function (left, right) {
  * @returns {Rectangle} The result rectangle
  */
 ClippingPolygon.prototype.computeRectangle = function (result) {
-  return PolygonGeometry.computeRectangleFromPositions(
+  if (equalsArrayCartesian3(this._positions, this._cachedPositions)) {
+    return Rectangle.clone(this._cachedRectangle, result);
+  }
+  const rectangle = PolygonGeometry.computeRectangleFromPositions(
     this.positions,
     this.ellipsoid,
     undefined,
     result,
   );
+  this._cachedPositions = copyArrayCartesian3(this._positions);
+  this._cachedRectangle = Rectangle.clone(rectangle);
+  return rectangle;
 };
 
 const scratchRectangle = new Rectangle();

package/Source/Scene/CreditDisplay.js

@@ -194,7 +194,7 @@ function appendCss(container) {
 .cesium-credit-lightbox.cesium-credit-lightbox-expanded {
   border: 1px solid #444;
   border-radius: 5px;
-  max-width: 370px;
+  max-width: 470px;
 }
 .cesium-credit-lightbox.cesium-credit-lightbox-mobile {
   height: 100%;

package/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,

package/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;
   }
 };
 
@@ -566,7 +566,7 @@ GaussianSplatPrimitive.generateSplatTexture = function (primitive, frameState) {
           },
         });
       }
-
+      primitive._vertexArray = undefined;
       primitive._lastTextureHeight = splatTextureData.height;
       primitive._lastTextureWidth = splatTextureData.width;
 
@@ -652,8 +652,9 @@ GaussianSplatPrimitive.buildGSplatDrawCommand = function (
 
   const uniformMap = renderResources.uniformMap;
 
+  const textureCache = primitive.gaussianSplatTexture;
   uniformMap.u_splatAttributeTexture = function () {
-    return primitive.gaussianSplatTexture;
+    return textureCache;
   };
 
   if (primitive._sphericalHarmonicsDegree > 0) {
@@ -768,12 +769,13 @@ GaussianSplatPrimitive.buildGSplatDrawCommand = function (
     scratchMatrix4B,
   );
 
+  const vertexArrayCache = primitive._vertexArray;
   const command = new DrawCommand({
     boundingVolume: tileset.boundingSphere,
     modelMatrix: modelMatrix,
     uniformMap: uniformMap,
     renderState: renderState,
-    vertexArray: primitive._vertexArray,
+    vertexArray: vertexArrayCache,
     shaderProgram: shaderProgram,
     cull: renderStateOptions.cull.enabled,
     pass: Pass.GAUSSIAN_SPLATS,
@@ -858,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;
       };
@@ -904,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,
           ),
       );