@cesium/engine 21.0.1 → 22.1.0

package/Source/Scene/BoundingVolumeSemantics.js

@@ -12,89 +12,85 @@ const BoundingVolumeSemantics = {};
 
 /**
  * Parse the bounding volume-related semantics such as
- * <code>TILE_BOUNDING_BOX</code> and <code>CONTENT_BOUNDING_REGION</code> from
- * implicit tile metadata. Results are returned as a JSON object for use when
- * transcoding tiles (see {@link Implicit3DTileContent}).
+ * <code>TILE_BOUNDING_BOX</code> and <code>CONTENT_BOUNDING_BOX</code> from
+ * implicit tile or content metadata. Results are returned as a JSON object for
+ * use when transcoding tiles (see {@link Implicit3DTileContent}).
  * <p>
  * Bounding volumes are checked in the order box, region, then sphere. Only
  * the first valid bounding volume is returned.
  * </p>
+ * <p>
+ * This handles both tile and content bounding volumes, as the only difference
+ * is the prefix. e.g. <code>TILE_BOUNDING_BOX</code> and
+ * <code>CONTENT_BOUNDING_BOX</code> have the same memory layout.
+ * </p>
  *
  * @see {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata/Semantics|3D Metadata Semantic Reference} for the various bounding volumes and minimum/maximum heights.
  *
- * @param {TileMetadata} tileMetadata The metadata object for looking up values by semantic. In practice, this will typically be a {@link ImplicitMetadataView}
- * @return {object} An object containing a <code>tile</code> property and a <code>content</code> property. These contain the bounding volume, and any minimum or maximum height.
+ * @param {string} prefix Either "TILE" or "CONTENT"
+ * @param {TileMetadata|ContentMetadata} metadata The metadata object for looking up values by semantic. In practice, this will typically be a {@link ImplicitMetadataView}
+ * @return {object} An object containing the bounding volume, and any minimum or maximum height.
  *
  * @private
  * @experimental This feature is using part of the 3D Tiles spec that is not final and is subject to change without Cesium's standard deprecation policy.
  */
 BoundingVolumeSemantics.parseAllBoundingVolumeSemantics = function (
-  tileMetadata,
+  prefix,
+  metadata,
 ) {
   //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("tileMetadata", tileMetadata);
+  Check.typeOf.string("prefix", prefix);
+  if (prefix !== "TILE" && prefix !== "CONTENT") {
+    throw new DeveloperError("prefix must be either 'TILE' or 'CONTENT'");
+  }
+  Check.typeOf.object("metadata", metadata);
   //>>includeEnd('debug');
 
   return {
-    tile: {
-      boundingVolume: BoundingVolumeSemantics.parseBoundingVolumeSemantic(
-        "TILE",
-        tileMetadata,
-      ),
-      minimumHeight: BoundingVolumeSemantics._parseMinimumHeight(
-        "TILE",
-        tileMetadata,
-      ),
-      maximumHeight: BoundingVolumeSemantics._parseMaximumHeight(
-        "TILE",
-        tileMetadata,
-      ),
-    },
-    content: {
-      boundingVolume: BoundingVolumeSemantics.parseBoundingVolumeSemantic(
-        "CONTENT",
-        tileMetadata,
-      ),
-      minimumHeight: BoundingVolumeSemantics._parseMinimumHeight(
-        "CONTENT",
-        tileMetadata,
-      ),
-      maximumHeight: BoundingVolumeSemantics._parseMaximumHeight(
-        "CONTENT",
-        tileMetadata,
-      ),
-    },
+    boundingVolume: BoundingVolumeSemantics.parseBoundingVolumeSemantic(
+      prefix,
+      metadata,
+    ),
+    minimumHeight: BoundingVolumeSemantics._parseMinimumHeight(
+      prefix,
+      metadata,
+    ),
+    maximumHeight: BoundingVolumeSemantics._parseMaximumHeight(
+      prefix,
+      metadata,
+    ),
   };
 };
 
 /**
- * Parse the bounding volume from a tile metadata. If the metadata specify
- * multiple bounding volumes, only the first one is returned. Bounding volumes
- * are checked in the order box, region, then sphere.
- *
+ * Parse the bounding volume from tile or content metadata. If the metadata
+ * specify multiple bounding volumes, only the first one is returned. Bounding
+ * volumes are checked in the order box, region, then sphere.
+ * <p>
  * This handles both tile and content bounding volumes, as the only difference
  * is the prefix. e.g. <code>TILE_BOUNDING_BOX</code> and
  * <code>CONTENT_BOUNDING_BOX</code> have the same memory layout.
+ * </p>
  *
  * @param {string} prefix Either "TILE" or "CONTENT"
- * @param {TileMetadata} tileMetadata The tileMetadata for looking up values
- * @return {object} An object representing the JSON description of the tile metadata
+ * @param {TileMetadata|ContentMetadata} metadata The metadata for looking up values
+ * @return {object} An object representing the JSON description of the tile or content bounding volume
  * @private
  */
 BoundingVolumeSemantics.parseBoundingVolumeSemantic = function (
   prefix,
-  tileMetadata,
+  metadata,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.string("prefix", prefix);
   if (prefix !== "TILE" && prefix !== "CONTENT") {
     throw new DeveloperError("prefix must be either 'TILE' or 'CONTENT'");
   }
-  Check.typeOf.object("tileMetadata", tileMetadata);
+  Check.typeOf.object("metadata", metadata);
   //>>includeEnd('debug');
 
   const boundingBoxSemantic = `${prefix}_BOUNDING_BOX`;
-  const boundingBox = tileMetadata.getPropertyBySemantic(boundingBoxSemantic);
+  const boundingBox = metadata.getPropertyBySemantic(boundingBoxSemantic);
 
   if (defined(boundingBox)) {
     return {
@@ -103,9 +99,7 @@ BoundingVolumeSemantics.parseBoundingVolumeSemantic = function (
   }
 
   const boundingRegionSemantic = `${prefix}_BOUNDING_REGION`;
-  const boundingRegion = tileMetadata.getPropertyBySemantic(
-    boundingRegionSemantic,
-  );
+  const boundingRegion = metadata.getPropertyBySemantic(boundingRegionSemantic);
 
   if (defined(boundingRegion)) {
     return {
@@ -114,9 +108,7 @@ BoundingVolumeSemantics.parseBoundingVolumeSemantic = function (
   }
 
   const boundingSphereSemantic = `${prefix}_BOUNDING_SPHERE`;
-  const boundingSphere = tileMetadata.getPropertyBySemantic(
-    boundingSphereSemantic,
-  );
+  const boundingSphere = metadata.getPropertyBySemantic(boundingSphereSemantic);
 
   if (defined(boundingSphere)) {
     // ARRAY with 4 elements is automatically converted to a Cartesian4
@@ -129,49 +121,49 @@ BoundingVolumeSemantics.parseBoundingVolumeSemantic = function (
 };
 
 /**
- * Parse the minimum height from tile metadata. This is used for making tighter
- * quadtree bounds for implicit tiling. This works for both
+ * Parse the minimum height from tile or content metadata. This is used for making
+ * tighter quadtree bounds for implicit tiling. This works for both
  * <code>TILE_MINIMUM_HEIGHT</code> and <code>CONTENT_MINIMUM_HEIGHT</code>
  *
  * @param {string} prefix Either "TILE" or "CONTENT"
- * @param {TileMetadata} tileMetadata The tileMetadata for looking up values
+ * @param {TileMetadata|ContentMetadata} metadata The metadata for looking up values
  * @return {number} The minimum height
  * @private
  */
-BoundingVolumeSemantics._parseMinimumHeight = function (prefix, tileMetadata) {
+BoundingVolumeSemantics._parseMinimumHeight = function (prefix, metadata) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.string("prefix", prefix);
   if (prefix !== "TILE" && prefix !== "CONTENT") {
     throw new DeveloperError("prefix must be either 'TILE' or 'CONTENT'");
   }
-  Check.typeOf.object("tileMetadata", tileMetadata);
+  Check.typeOf.object("metadata", metadata);
   //>>includeEnd('debug');
 
   const minimumHeightSemantic = `${prefix}_MINIMUM_HEIGHT`;
-  return tileMetadata.getPropertyBySemantic(minimumHeightSemantic);
+  return metadata.getPropertyBySemantic(minimumHeightSemantic);
 };
 
 /**
- * Parse the maximum height from tile metadata. This is used for making tighter
- * quadtree bounds for implicit tiling. This works for both
+ * Parse the maximum height from tile or content metadata. This is used for
+ * making tighter quadtree bounds for implicit tiling. This works for both
  * <code>TILE_MAXIMUM_HEIGHT</code> and <code>CONTENT_MAXIMUM_HEIGHT</code>
  *
  * @param {string} prefix Either "TILE" or "CONTENT"
- * @param {TileMetadata} tileMetadata The tileMetadata for looking up values
+ * @param {TileMetadata|ContentMetadata} metadata The metadata for looking up values
  * @return {number} The maximum height
  * @private
  */
-BoundingVolumeSemantics._parseMaximumHeight = function (prefix, tileMetadata) {
+BoundingVolumeSemantics._parseMaximumHeight = function (prefix, metadata) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.string("prefix", prefix);
   if (prefix !== "TILE" && prefix !== "CONTENT") {
     throw new DeveloperError("prefix must be either 'TILE' or 'CONTENT'");
   }
-  Check.typeOf.object("tileMetadata", tileMetadata);
+  Check.typeOf.object("metadata", metadata);
   //>>includeEnd('debug');
 
   const maximumHeightSemantic = `${prefix}_MAXIMUM_HEIGHT`;
-  return tileMetadata.getPropertyBySemantic(maximumHeightSemantic);
+  return metadata.getPropertyBySemantic(maximumHeightSemantic);
 };
 
 export default BoundingVolumeSemantics;

package/Source/Scene/Cesium3DTile.js

@@ -795,7 +795,7 @@ const scratchCartesian = new Cartesian3();
  * @private
  * @param {Cesium3DTile} tile
  * @param {FrameState} frameState
- * @returns {Boolean}
+ * @returns {boolean}
  */
 function isPriorityDeferred(tile, frameState) {
   const { tileset, boundingSphere } = tile;
@@ -905,7 +905,7 @@ const scratchJulianDate = new JulianDate();
  *
  * @private
  * @param {FrameState} frameState
- * @param {Boolean} useParentGeometricError
+ * @param {boolean} useParentGeometricError
  * @param {number} progressiveResolutionHeightFraction
  */
 Cesium3DTile.prototype.getScreenSpaceError = function (
@@ -964,7 +964,7 @@ Cesium3DTile.prototype.getScreenSpaceError = function (
  * @private
  * @param {Cesium3DTileset} tileset
  * @param {Cesium3DTile} tile
- * @returns {Boolean}
+ * @returns {boolean}
  */
 function isPriorityProgressiveResolution(tileset, tile) {
   if (

package/Source/Scene/Cesium3DTilesVoxelProvider.js

@@ -25,7 +25,7 @@ import CesiumMath from "../Core/Math.js";
 import Quaternion from "../Core/Quaternion.js";
 
 /**
- * @typedef {Object} Cesium3DTilesVoxelProvider.ConstructorOptions
+ * @typedef {object} Cesium3DTilesVoxelProvider.ConstructorOptions
  *
  * Initialization options for the Cesium3DTilesVoxelProvider constructor
  *

package/Source/Scene/Cesium3DTileset.js

@@ -65,7 +65,7 @@ import DynamicEnvironmentMapManager from "./DynamicEnvironmentMapManager.js";
 import ImageryLayerCollection from "./ImageryLayerCollection.js";
 
 /**
- * @typedef {Object} Cesium3DTileset.ConstructorOptions
+ * @typedef {object} Cesium3DTileset.ConstructorOptions
  *
  * Initialization options for the Cesium3DTileset constructor
  *

package/Source/Scene/EdgeFramebuffer.js

@@ -0,0 +1,245 @@
+import defined from "../Core/defined.js";
+import destroyObject from "../Core/destroyObject.js";
+import PixelFormat from "../Core/PixelFormat.js";
+import Color from "../Core/Color.js";
+import PixelDatatype from "../Renderer/PixelDatatype.js";
+import FramebufferManager from "../Renderer/FramebufferManager.js";
+import ClearCommand from "../Renderer/ClearCommand.js";
+
+/**
+ * Creates and manages framebuffers for edge visibility rendering.
+ *
+ * @param {Object} options Object with the following properties:
+ *
+ * @alias EdgeFramebuffer
+ * @constructor
+ *
+ * @private
+ */
+function EdgeFramebuffer(options) {
+  options = options || {};
+
+  // Create framebuffer manager with multiple render targets (MRT)
+  // Color attachment 0: edge color output (visualization / debug)
+  // Color attachment 1: R: edge type, G: featureId (metadata / ids)
+  // Color attachment 2: packed depth (czm_packDepth) for edge fragments
+  this._framebufferManager = new FramebufferManager({
+    colorAttachmentsLength: 3, // MRT: Color + ID + Depth (packed RGBA)
+    createColorAttachments: true,
+    depthStencil: true,
+    supportsDepthTexture: true,
+    color: true,
+  });
+
+  this._framebuffer = undefined;
+  this._colorTexture = undefined;
+  this._idTexture = undefined;
+  this._depthTexture = undefined; // packed depth color attachment (location = 2)
+  this._depthStencilTexture = undefined;
+
+  this._clearCommand = new ClearCommand({
+    color: new Color(0.0, 0.0, 0.0, 0.0),
+    depth: 1.0,
+    stencil: 0,
+    owner: this,
+  });
+}
+
+Object.defineProperties(EdgeFramebuffer.prototype, {
+  /**
+   * Gets the framebuffer for edge rendering.
+   * @memberof EdgeFramebuffer.prototype
+   * @type {Framebuffer}
+   * @readonly
+   */
+  framebuffer: {
+    get: function () {
+      return this._framebuffer;
+    },
+  },
+
+  /**
+   * Gets the color texture.
+   * @memberof EdgeFramebuffer.prototype
+   * @type {Texture}
+   * @readonly
+   */
+  colorTexture: {
+    get: function () {
+      return this._colorTexture;
+    },
+  },
+
+  /**
+   * Gets the ID texture.
+   * @memberof EdgeFramebuffer.prototype
+   * @type {Texture}
+   * @readonly
+   */
+  idTexture: {
+    get: function () {
+      return this._idTexture;
+    },
+  },
+
+  /**
+   * Gets the packed depth texture written during the edge pass.
+   * @memberof EdgeFramebuffer.prototype
+   * @type {Texture}
+   * @readonly
+   */
+  depthTexture: {
+    get: function () {
+      return this._depthTexture;
+    },
+  },
+
+  /**
+   * Gets the depth-stencil texture.
+   * @memberof EdgeFramebuffer.prototype
+   * @type {Texture}
+   * @readonly
+   */
+  depthStencilTexture: {
+    get: function () {
+      return this._depthStencilTexture;
+    },
+  },
+});
+
+/**
+ * Updates the framebuffer.
+ *
+ * @param {Context} context The context.
+ * @param {Viewport} viewport The viewport.
+ * @param {boolean} hdr Whether HDR is enabled.
+ * @param {Texture} [existingColorTexture] Optional existing color texture to reuse.
+ * @param {Texture} [existingDepthTexture] Optional existing depth texture to reuse.
+ *
+ * @returns {boolean} True if the framebuffer was updated; otherwise, false.
+ */
+EdgeFramebuffer.prototype.update = function (
+  context,
+  viewport,
+  hdr,
+  existingColorTexture,
+  existingDepthTexture,
+) {
+  const width = viewport.width;
+  const height = viewport.height;
+
+  const pixelDatatype = hdr
+    ? context.halfFloatingPointTexture
+      ? PixelDatatype.HALF_FLOAT
+      : PixelDatatype.FLOAT
+    : PixelDatatype.UNSIGNED_BYTE;
+
+  const changed = this._framebufferManager.update(
+    context,
+    width,
+    height,
+    1, // No MSAA
+    pixelDatatype,
+    PixelFormat.RGBA,
+  );
+
+  // Always assign framebuffer if FramebufferManager has one
+  if (this._framebufferManager.framebuffer) {
+    this._framebuffer = this._framebufferManager.framebuffer;
+
+    // Get the textures from the framebuffer manager or use existing ones
+    this._colorTexture = defined(existingColorTexture)
+      ? existingColorTexture
+      : this._framebufferManager.getColorTexture(0); // Color attachment 0
+    this._idTexture = this._framebufferManager.getColorTexture(1); // Color attachment 1: ID texture
+    this._depthTexture = this._framebufferManager.getColorTexture(2); // Color attachment 2: packed depth
+    this._depthStencilTexture = defined(existingDepthTexture)
+      ? existingDepthTexture
+      : this._framebufferManager.getDepthStencilTexture();
+  }
+
+  return changed;
+};
+
+/**
+ * Clears the framebuffer using ClearCommand.
+ * @deprecated Use getClearCommand() instead for proper MRT clearing.
+ *
+ * @param {Context} context The context.
+ * @param {PassState} passState The pass state.
+ * @param {Color} clearColor The clear color.
+ */
+EdgeFramebuffer.prototype.clear = function (context, passState, clearColor) {
+  const clearCommand = this.getClearCommand(clearColor);
+  clearCommand.execute(context, passState);
+};
+
+/**
+ * Gets the clear command for this framebuffer.
+ *
+ * @param {Color} [clearColor] The clear color to use. If undefined, uses the default.
+ * @returns {ClearCommand} The clear command.
+ */
+EdgeFramebuffer.prototype.getClearCommand = function (clearColor) {
+  this._clearCommand.framebuffer = this._framebuffer;
+
+  if (defined(clearColor)) {
+    Color.clone(clearColor, this._clearCommand.color);
+  }
+
+  return this._clearCommand;
+};
+
+/**
+ * Gets the edge framebuffer, creating it if necessary.
+ *
+ * @param {Context} context The context.
+ * @param {Viewport} viewport The viewport.
+ * @param {Texture} [existingColorTexture] Optional existing color texture to reuse.
+ * @param {Texture} [existingDepthTexture] Optional existing depth texture to reuse.
+ *
+ * @returns {Framebuffer} The edge framebuffer.
+ */
+EdgeFramebuffer.prototype.getFramebuffer = function (
+  context,
+  viewport,
+  existingColorTexture,
+  existingDepthTexture,
+) {
+  this.update(
+    context,
+    viewport,
+    false,
+    existingColorTexture,
+    existingDepthTexture,
+  );
+  return this._framebuffer;
+};
+
+/**
+ * Returns true if this object was destroyed; otherwise, false.
+ *
+ * @returns {boolean} True if this object was destroyed; otherwise, false.
+ */
+EdgeFramebuffer.prototype.isDestroyed = function () {
+  return false;
+};
+
+/**
+ * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
+ * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+ * <br /><br />
+ * Once an object is destroyed, it should not be used; calling any function other than
+ * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+ * assign the return value (<code>undefined</code>) to the object as done in the example.
+ *
+ * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+ */
+EdgeFramebuffer.prototype.destroy = function () {
+  this._framebufferManager =
+    this._framebufferManager && this._framebufferManager.destroy();
+  this._clearCommand = undefined;
+  return destroyObject(this);
+};
+
+export default EdgeFramebuffer;

package/Source/Scene/FrameState.js

@@ -454,6 +454,18 @@ function FrameState(context, creditDisplay, jobScheduler) {
    * @type {PickedMetadataInfo|undefined}
    */
   this.pickedMetadataInfo = undefined;
+
+  /**
+   * Internal toggle indicating that at least one primitive for this frame requested
+   * edge visibility rendering (EXT_mesh_primitive_edge_visibility). This allows
+   * lazy allocation/activation of the edge MRT without storing a Scene reference
+   * on the frame state (avoids passing entire Scene through internal APIs).
+   * Set by model pipeline stages when they encounter edge visibility data.
+   * Consumed by Scene to flip its _enableEdgeVisibility flag.
+   * @type {boolean}
+   * @private
+   */
+  this.edgeVisibilityRequested = false;
 }
 
 /**

package/Source/Scene/GaussianSplat3DTileContent.js

@@ -125,7 +125,6 @@ GaussianSplat3DTileContent.tilesetRequiresGaussianSplattingExt = function (
   tileset,
 ) {
   let hasGaussianSplatExtension = false;
-  let hasLegacyGaussianSplatExtension = false;
   if (tileset.isGltfExtensionRequired instanceof Function) {
     hasGaussianSplatExtension =
       tileset.isGltfExtensionRequired("KHR_gaussian_splatting") &&
@@ -133,22 +132,20 @@ GaussianSplat3DTileContent.tilesetRequiresGaussianSplattingExt = function (
         "KHR_gaussian_splatting_compression_spz_2",
       );
 
-    hasLegacyGaussianSplatExtension = tileset.isGltfExtensionRequired(
-      "KHR_spz_gaussian_splats_compression",
-    );
-  }
-
-  if (hasLegacyGaussianSplatExtension) {
-    deprecationWarning(
-      "KHR_spz_gaussian_splats_compression",
-      "Support for the original KHR_spz_gaussian_splats_compression extension has been deprecated in favor " +
-        "of the up to date KHR_gaussian_splatting and KHR_gaussian_splatting_compression_spz_2 extensions and will be " +
-        "removed in CesiumJS 1.135.\n\nPlease retile your tileset with the KHR_gaussian_splatting and " +
-        "KHR_gaussian_splatting_compression_spz_2 extensions.",
-    );
+    if (
+      tileset.isGltfExtensionRequired("KHR_spz_gaussian_splats_compression")
+    ) {
+      deprecationWarning(
+        "KHR_spz_gaussian_splats_compression",
+        "Support for the original KHR_spz_gaussian_splats_compression extension has been removed in favor " +
+          "of the up to date KHR_gaussian_splatting and KHR_gaussian_splatting_compression_spz_2 extensions" +
+          "\n\nPlease retile your tileset with the KHR_gaussian_splatting and " +
+          "KHR_gaussian_splatting_compression_spz_2 extensions.",
+      );
+    }
   }
 
-  return hasGaussianSplatExtension || hasLegacyGaussianSplatExtension;
+  return hasGaussianSplatExtension;
 };
 
 Object.defineProperties(GaussianSplat3DTileContent.prototype, {
@@ -236,7 +233,6 @@ Object.defineProperties(GaussianSplat3DTileContent.prototype, {
    * @readonly
    */
   batchTableByteLength: {
-    // eslint-disable-next-line getter-return
     get: function () {
       return 0;
     },

package/Source/Scene/GaussianSplatPrimitive.js

@@ -32,6 +32,7 @@ import Quaternion from "../Core/Quaternion.js";
 import SplitDirection from "./SplitDirection.js";
 import destroyObject from "../Core/destroyObject.js";
 import ContextLimits from "../Renderer/ContextLimits.js";
+import Transforms from "../Core/Transforms.js";
 
 const scratchMatrix4A = new Matrix4();
 const scratchMatrix4B = new Matrix4();
@@ -89,7 +90,7 @@ function createGaussianSplatTexture(context, splatTextureData) {
  * </p>
  * @alias GaussianSplatPrimitive
  * @constructor
- * @param {Object} options An object with the following properties:
+ * @param {object} options An object with the following properties:
  * @param {Cesium3DTileset} options.tileset The tileset that this primitive belongs to.
  * @param {boolean} [options.debugShowBoundingVolume=false] Whether to show the bounding volume of the primitive for debugging purposes.
  * @private
@@ -427,6 +428,13 @@ GaussianSplatPrimitive.transformTile = function (tile) {
   const gltfPrimitive = tile.content.gltfPrimitive;
   const gaussianSplatPrimitive = tile.tileset.gaussianSplatPrimitive;
 
+  if (gaussianSplatPrimitive._rootTransform === undefined) {
+    gaussianSplatPrimitive._rootTransform = Transforms.eastNorthUpToFixedFrame(
+      tile.tileset.boundingSphere.center,
+    );
+  }
+  const rootTransform = gaussianSplatPrimitive._rootTransform;
+
   const computedModelMatrix = Matrix4.multiplyTransformation(
     computedTransform,
     gaussianSplatPrimitive._axisCorrectionMatrix,
@@ -441,7 +449,7 @@ GaussianSplatPrimitive.transformTile = function (tile) {
 
   const toGlobal = Matrix4.multiply(
     tile.tileset.modelMatrix,
-    Matrix4.fromArray(tile.tileset.root.transform),
+    rootTransform,
     scratchMatrix4B,
   );
   const toLocal = Matrix4.inverse(toGlobal, scratchMatrix4C);
@@ -684,7 +692,7 @@ GaussianSplatPrimitive.buildGSplatDrawCommand = function (
     const tileset = primitive._tileset;
     const modelMatrix = Matrix4.multiply(
       tileset.modelMatrix,
-      Matrix4.fromArray(tileset.root.transform),
+      primitive._rootTransform,
       scratchMatrix4A,
     );
     const inverseModelRotation = Matrix4.getRotation(
@@ -765,7 +773,7 @@ GaussianSplatPrimitive.buildGSplatDrawCommand = function (
 
   const modelMatrix = Matrix4.multiply(
     tileset.modelMatrix,
-    Matrix4.fromArray(tileset.root.transform),
+    primitive._rootTransform,
     scratchMatrix4B,
   );
 
@@ -804,10 +812,6 @@ GaussianSplatPrimitive.buildGSplatDrawCommand = function (
 GaussianSplatPrimitive.prototype.update = function (frameState) {
   const tileset = this._tileset;
 
-  if (!defined(this._rootTransform)) {
-    this._rootTransform = tileset.root.computedTransform;
-  }
-
   if (!tileset.show || tileset._selectedTiles.length === 0) {
     return;
   }

package/Source/Scene/GaussianSplatSorter.js

@@ -49,8 +49,8 @@ GaussianSplatSorter._getSorterTaskProcessor = function () {
  * Sorts Gaussian splats using a radix sort algorithm. Sorted by distance from the camera.
  * A new list of indexes is returned, which can be used to render the splats in the correct order.
  *
- * @param {Object} parameters - The parameters for sorting Gaussian splat indexes.
- * @param {Object} parameters.primitive - The primitive containing positions and modelView matrices.
+ * @param {object} parameters - The parameters for sorting Gaussian splat indexes.
+ * @param {object} parameters.primitive - The primitive containing positions and modelView matrices.
  * @returns {Promise|undefined} A promise that resolves to the sorted indexes or undefined if the task cannot be scheduled.
  * @exception {RuntimeError} Sorter could not be initialized.
  * @private

package/Source/Scene/Globe.js

@@ -646,7 +646,7 @@ function makeShadersDirty(globe) {
   const fragmentSources = [AtmosphereCommon, GroundAtmosphere];
   if (
     defined(globe._material) &&
-    (!requireNormals || globe._terrainProvider.requestVertexNormals)
+    (!requireNormals || globe._terrainProvider.hasVertexNormals)
   ) {
     fragmentSources.push(globe._material.shaderSource);
     defines.push("APPLY_MATERIAL");
@@ -943,7 +943,9 @@ Globe.prototype.getHeight = function (cartographic) {
 
   const intersection = tile.data.pick(
     ray,
-    undefined,
+    // Globe height is the same at a given cartographic regardless of the scene mode,
+    // but the ray is constructed via a surface normal (which assumes 3D), so pick in 3D mode.
+    SceneMode.SCENE3D,
     projection,
     false,
     scratchGetHeightIntersection,