@cesium/engine 13.1.0 → 15.0.0

package/Source/Scene/Megatexture.js

@@ -21,11 +21,11 @@ import TextureWrap from "../Renderer/TextureWrap.js";
  * @alias Megatexture
  * @constructor
  *
- * @param {Context} context
- * @param {Cartesian3} dimensions
- * @param {number} channelCount
- * @param {MetadataComponentType} componentType
- * @param {number} [textureMemoryByteLength]
+ * @param {Context} context The context in which to create GPU resources.
+ * @param {Cartesian3} dimensions The number of voxels in each dimension of the tile.
+ * @param {number} channelCount The number of channels in the metadata.
+ * @param {MetadataComponentType} componentType The component type of the metadata.
+ * @param {number} [availableTextureMemoryBytes=134217728] An upper limit on the texture memory size in bytes.
  *
  * @private
  */
@@ -34,59 +34,35 @@ function Megatexture(
   dimensions,
   channelCount,
   componentType,
-  textureMemoryByteLength,
+  availableTextureMemoryBytes,
 ) {
+  const maximumTextureMemoryByteLength = 512 * 1024 * 1024;
+  availableTextureMemoryBytes = Math.min(
+    defaultValue(availableTextureMemoryBytes, 128 * 1024 * 1024),
+    maximumTextureMemoryByteLength,
+  );
+
   // TODO there are a lot of texture packing rules, see https://github.com/CesiumGS/cesium/issues/9572
   // Unsigned short textures not allowed in webgl 1, so treat as float
   if (componentType === MetadataComponentType.UNSIGNED_SHORT) {
     componentType = MetadataComponentType.FLOAT32;
   }
 
-  const supportsFloatingPointTexture = context.floatingPointTexture;
   if (
     componentType === MetadataComponentType.FLOAT32 &&
-    !supportsFloatingPointTexture
+    !context.floatingPointTexture
   ) {
     throw new RuntimeError("Floating point texture not supported");
   }
 
-  // TODO support more
-  let pixelType;
-  if (
-    componentType === MetadataComponentType.FLOAT32 ||
-    componentType === MetadataComponentType.FLOAT64
-  ) {
-    pixelType = PixelDatatype.FLOAT;
-  } else if (componentType === MetadataComponentType.UINT8) {
-    pixelType = PixelDatatype.UNSIGNED_BYTE;
-  }
-
-  let pixelFormat;
-  if (channelCount === 1) {
-    pixelFormat = context.webgl2 ? PixelFormat.RED : PixelFormat.LUMINANCE;
-  } else if (channelCount === 2) {
-    pixelFormat = context.webgl2 ? PixelFormat.RG : PixelFormat.LUMINANCE_ALPHA;
-  } else if (channelCount === 3) {
-    pixelFormat = PixelFormat.RGB;
-  } else if (channelCount === 4) {
-    pixelFormat = PixelFormat.RGBA;
-  }
-
-  const maximumTextureMemoryByteLength = 512 * 1024 * 1024;
-  const defaultTextureMemoryByteLength = 128 * 1024 * 1024;
-  textureMemoryByteLength = Math.min(
-    defaultValue(textureMemoryByteLength, defaultTextureMemoryByteLength),
-    maximumTextureMemoryByteLength,
-  );
-  const maximumTextureDimensionContext = ContextLimits.maximumTextureSize;
+  const pixelDataType = getPixelDataType(componentType);
+  const pixelFormat = getPixelFormat(channelCount, context.webgl2);
   const componentTypeByteLength =
     MetadataComponentType.getSizeInBytes(componentType);
-  const texelCount = Math.floor(
-    textureMemoryByteLength / (channelCount * componentTypeByteLength),
-  );
-  const textureDimension = Math.min(
-    maximumTextureDimensionContext,
-    CesiumMath.previousPowerOfTwo(Math.floor(Math.sqrt(texelCount))),
+  const textureDimension = getTextureDimension(
+    availableTextureMemoryBytes,
+    channelCount,
+    componentTypeByteLength,
   );
 
   const sliceCountPerRegionX = Math.ceil(Math.sqrt(dimensions.x));
@@ -116,6 +92,13 @@ function Megatexture(
    */
   this.componentType = componentType;
 
+  /**
+   * @type {number}
+   * @readonly
+   */
+  this.textureMemoryByteLength =
+    componentTypeByteLength * channelCount * textureDimension ** 2;
+
   /**
    * @type {Cartesian3}
    * @readonly
@@ -190,7 +173,7 @@ function Megatexture(
   this.texture = new Texture({
     context: context,
     pixelFormat: pixelFormat,
-    pixelDatatype: pixelType,
+    pixelDatatype: pixelDataType,
     flipY: false,
     width: textureDimension,
     height: textureDimension,
@@ -249,6 +232,73 @@ function Megatexture(
   this.occupiedCount = 0;
 }
 
+/**
+ * Get the pixel data type to use in a megatexture.
+ * TODO support more
+ *
+ * @param {MetadataComponentType} componentType The component type of the metadata.
+ * @returns {PixelDatatype} The pixel datatype to use for a megatexture.
+ *
+ * @private
+ */
+function getPixelDataType(componentType) {
+  if (
+    componentType === MetadataComponentType.FLOAT32 ||
+    componentType === MetadataComponentType.FLOAT64
+  ) {
+    return PixelDatatype.FLOAT;
+  } else if (componentType === MetadataComponentType.UINT8) {
+    return PixelDatatype.UNSIGNED_BYTE;
+  }
+}
+
+/**
+ * Get the pixel format to use for a megatexture.
+ *
+ * @param {number} channelCount The number of channels in the metadata. Must be 1 to 4.
+ * @param {boolean} webgl2 true if the context is using webgl2
+ * @returns {PixelFormat} The pixel format to use for a megatexture.
+ *
+ * @private
+ */
+function getPixelFormat(channelCount, webgl2) {
+  if (channelCount === 1) {
+    return webgl2 ? PixelFormat.RED : PixelFormat.LUMINANCE;
+  } else if (channelCount === 2) {
+    return webgl2 ? PixelFormat.RG : PixelFormat.LUMINANCE_ALPHA;
+  } else if (channelCount === 3) {
+    return PixelFormat.RGB;
+  } else if (channelCount === 4) {
+    return PixelFormat.RGBA;
+  }
+}
+
+/**
+ * Compute the largest size of a square texture that will fit in the available memory.
+ *
+ * @param {number} availableTextureMemoryBytes An upper limit on the texture memory size.
+ * @param {number} channelCount The number of metadata channels per texel.
+ * @param {number} componentByteLength The byte length of each component of the metadata.
+ * @returns {number} The dimension of the square texture to use for the megatexture.
+ *
+ * @private
+ */
+function getTextureDimension(
+  availableTextureMemoryBytes,
+  channelCount,
+  componentByteLength,
+) {
+  // Compute how many texels will fit in the available memory
+  const texelCount = Math.floor(
+    availableTextureMemoryBytes / (channelCount * componentByteLength),
+  );
+  // Return the largest power of two texture size that will fit in memory
+  return Math.min(
+    ContextLimits.maximumTextureSize,
+    CesiumMath.previousPowerOfTwo(Math.floor(Math.sqrt(texelCount))),
+  );
+}
+
 /**
  * @alias MegatextureNode
  * @constructor
@@ -275,8 +325,9 @@ function MegatextureNode(index) {
 }
 
 /**
- * @param {Array} data
- * @returns {number}
+ * Add an array of tile metadata to the megatexture.
+ * @param {Array} data The data to be added.
+ * @returns {number} The index of the tile's location in the megatexture.
  */
 Megatexture.prototype.add = function (data) {
   if (this.isFull()) {
@@ -339,10 +390,10 @@ Megatexture.prototype.isFull = function () {
 };
 
 /**
- * @param {number} tileCount
- * @param {Cartesian3} dimensions
- * @param {number} channelCount number of channels in the metadata. Must be 1 to 4.
- * @param {MetadataComponentType} componentType
+ * @param {number} tileCount The total number of tiles in the tileset.
+ * @param {Cartesian3} dimensions The number of voxels in each dimension of the tile.
+ * @param {number} channelCount The number of channels in the metadata.
+ * @param {MetadataComponentType} componentType The type of one channel of the metadata.
  * @returns {number}
  */
 Megatexture.getApproximateTextureMemoryByteLength = function (
@@ -390,55 +441,52 @@ Megatexture.getApproximateTextureMemoryByteLength = function (
 };
 
 /**
- * @param {number} index
- * @param {Float32Array|Uint16Array|Uint8Array} data
+ * Write an array of tile metadata to the megatexture.
+ * @param {number} index The index of the tile's location in the megatexture.
+ * @param {Float32Array|Uint16Array|Uint8Array} data The data to be written.
  */
 Megatexture.prototype.writeDataToTexture = function (index, data) {
   // Unsigned short textures not allowed in webgl 1, so treat as float
   const tileData =
     data.constructor === Uint16Array ? new Float32Array(data) : data;
 
-  const voxelDimensionsPerTile = this.voxelCountPerTile;
-  const sliceDimensionsPerRegion = this.sliceCountPerRegion;
-  const voxelDimensionsPerRegion = this.voxelCountPerRegion;
-  const channelCount = this.channelCount;
-
-  const tileVoxelData = this.tileVoxelDataTemp;
-  for (let z = 0; z < voxelDimensionsPerTile.z; z++) {
-    const sliceVoxelOffsetX =
-      (z % sliceDimensionsPerRegion.x) * voxelDimensionsPerTile.x;
+  const {
+    tileVoxelDataTemp,
+    voxelCountPerTile,
+    sliceCountPerRegion,
+    voxelCountPerRegion,
+    channelCount,
+    regionCountPerMegatexture,
+  } = this;
+
+  for (let z = 0; z < voxelCountPerTile.z; z++) {
+    const sliceVoxelOffsetX = (z % sliceCountPerRegion.x) * voxelCountPerTile.x;
     const sliceVoxelOffsetY =
-      Math.floor(z / sliceDimensionsPerRegion.x) * voxelDimensionsPerTile.y;
-    for (let y = 0; y < voxelDimensionsPerTile.y; y++) {
-      for (let x = 0; x < voxelDimensionsPerTile.x; x++) {
-        const readIndex =
-          z * voxelDimensionsPerTile.y * voxelDimensionsPerTile.x +
-          y * voxelDimensionsPerTile.x +
-          x;
-        const writeIndex =
-          (sliceVoxelOffsetY + y) * voxelDimensionsPerRegion.x +
-          (sliceVoxelOffsetX + x);
+      Math.floor(z / sliceCountPerRegion.x) * voxelCountPerTile.y;
+    for (let y = 0; y < voxelCountPerTile.y; y++) {
+      const readOffset = getReadOffset(voxelCountPerTile, y, z);
+      const writeOffset =
+        (sliceVoxelOffsetY + y) * voxelCountPerRegion.x + sliceVoxelOffsetX;
+      for (let x = 0; x < voxelCountPerTile.x; x++) {
+        const readIndex = readOffset + x;
+        const writeIndex = writeOffset + x;
         for (let c = 0; c < channelCount; c++) {
-          tileVoxelData[writeIndex * channelCount + c] =
+          tileVoxelDataTemp[writeIndex * channelCount + c] =
             tileData[readIndex * channelCount + c];
         }
       }
     }
   }
 
-  const regionDimensionsPerMegatexture = this.regionCountPerMegatexture;
-  const voxelWidth = voxelDimensionsPerRegion.x;
-  const voxelHeight = voxelDimensionsPerRegion.y;
   const voxelOffsetX =
-    (index % regionDimensionsPerMegatexture.x) * voxelDimensionsPerRegion.x;
+    (index % regionCountPerMegatexture.x) * voxelCountPerRegion.x;
   const voxelOffsetY =
-    Math.floor(index / regionDimensionsPerMegatexture.x) *
-    voxelDimensionsPerRegion.y;
+    Math.floor(index / regionCountPerMegatexture.x) * voxelCountPerRegion.y;
 
   const source = {
-    arrayBufferView: tileVoxelData,
-    width: voxelWidth,
-    height: voxelHeight,
+    arrayBufferView: tileVoxelDataTemp,
+    width: voxelCountPerRegion.x,
+    height: voxelCountPerRegion.y,
   };
 
   const copyOptions = {
@@ -450,6 +498,22 @@ Megatexture.prototype.writeDataToTexture = function (index, data) {
   this.texture.copyFrom(copyOptions);
 };
 
+/**
+ * Get the offset into the data array for a given row of contiguous voxel data.
+ *
+ * @param {Cartesian3} dimensions The number of voxels in each dimension of the tile.
+ * @param {number} y The y index of the voxel row
+ * @param {number} z The z index of the voxel row
+ * @returns {number} The offset into the data array
+ * @private
+ */
+function getReadOffset(dimensions, y, z) {
+  const voxelsPerInputSlice = dimensions.y * dimensions.x;
+  const sliceIndex = z;
+  const rowIndex = y;
+  return sliceIndex * voxelsPerInputSlice + rowIndex * dimensions.x;
+}
+
 /**
  * Returns true if this object was destroyed; otherwise, false.
  * <br /><br />

package/Source/Scene/Model/CustomShader.js

@@ -443,7 +443,6 @@ CustomShader.prototype.update = function (frameState) {
  * @returns {boolean} True if this object was destroyed; otherwise, false.
  *
  * @see CustomShader#destroy
- * @private
  */
 CustomShader.prototype.isDestroyed = function () {
   return false;
@@ -463,7 +462,6 @@ CustomShader.prototype.isDestroyed = function () {
  * customShader = customShader && customShader.destroy();
  *
  * @see CustomShader#isDestroyed
- * @private
  */
 CustomShader.prototype.destroy = function () {
   this._textureManager = this._textureManager && this._textureManager.destroy();

package/Source/Scene/Model/Model.js

@@ -120,9 +120,9 @@ import pickModel from "./pickModel.js";
  * @alias Model
  * @internalConstructor
  *
+ * @privateParam {object} options Object with the following properties:
  * @privateParam {ResourceLoader} options.loader The loader used to load resources for this model.
  * @privateParam {ModelType} options.type Type of this model, to distinguish individual glTF files from 3D Tiles internally.
- * @privateParam {object} options Object with the following properties:
  * @privateParam {Resource} options.resource The Resource to the 3D model.
  * @privateParam {boolean} [options.show=true] Whether or not to render the model.
  * @privateParam {Matrix4} [options.modelMatrix=Matrix4.IDENTITY]  The 4x4 transformation matrix that transforms the model from model to world coordinates.

package/Source/Scene/Model/ModelUtility.js

@@ -346,15 +346,18 @@ ModelUtility.supportedExtensions = {
   CESIUM_primitive_outline: true,
   CESIUM_RTC: true,
   EXT_feature_metadata: true,
+  EXT_implicit_cylinder_region: true,
+  EXT_implicit_ellipsoid_region: true,
   EXT_instance_features: true,
   EXT_mesh_features: true,
   EXT_mesh_gpu_instancing: true,
   EXT_meshopt_compression: true,
+  EXT_primitive_voxels: true,
   EXT_structural_metadata: true,
   EXT_texture_webp: true,
   KHR_blend: true,
   KHR_draco_mesh_compression: true,
-  KHR_techniques_webgl: true,
+  KHR_implicit_shapes: true,
   KHR_materials_common: true,
   KHR_materials_pbrSpecularGlossiness: true,
   KHR_materials_specular: true,
@@ -362,6 +365,7 @@ ModelUtility.supportedExtensions = {
   KHR_materials_clearcoat: true,
   KHR_materials_unlit: true,
   KHR_mesh_quantization: true,
+  KHR_techniques_webgl: true,
   KHR_texture_basisu: true,
   KHR_texture_transform: true,
   WEB3D_quantized_attributes: true,

package/Source/Scene/Multiple3DTileContent.js

@@ -6,7 +6,6 @@ import Request from "../Core/Request.js";
 import RequestScheduler from "../Core/RequestScheduler.js";
 import RequestState from "../Core/RequestState.js";
 import RequestType from "../Core/RequestType.js";
-import RuntimeError from "../Core/RuntimeError.js";
 import Cesium3DContentGroup from "./Cesium3DContentGroup.js";
 import Cesium3DTileContentType from "./Cesium3DTileContentType.js";
 import Cesium3DTileContentFactory from "./Cesium3DTileContentFactory.js";
@@ -52,6 +51,11 @@ function Multiple3DTileContent(tileset, tile, tilesetResource, contentsJson) {
   // used to help short-circuit computations after a tile was canceled.
   this._cancelCount = 0;
 
+  // The number of contents that turned out to be external tilesets
+  // in createInnerContent. When all contents are external tilesets,
+  // then tile.hasRenderableContent will become `false`
+  this._externalTilesetCount = 0;
+
   const contentCount = this._innerContentHeaders.length;
   this._arrayFetchPromises = new Array(contentCount);
   this._requests = new Array(contentCount);
@@ -505,6 +509,16 @@ async function createInnerContents(multipleContents) {
   const contents = await Promise.all(promises);
   multipleContents._contentsCreated = true;
   multipleContents._contents = contents.filter(defined);
+
+  // If each content is an external tileset, then the tile
+  // itself does not have any renderable content
+  if (
+    multipleContents._externalTilesetCount === multipleContents._contents.length
+  ) {
+    const tile = multipleContents._tile;
+    tile.hasRenderableContent = false;
+  }
+
   return contents;
 }
 
@@ -518,10 +532,13 @@ async function createInnerContent(multipleContents, arrayBuffer, index) {
   try {
     const preprocessed = preprocess3DTileContent(arrayBuffer);
 
+    const tileset = multipleContents._tileset;
+    const resource = multipleContents._innerContentResources[index];
+    const tile = multipleContents._tile;
+
     if (preprocessed.contentType === Cesium3DTileContentType.EXTERNAL_TILESET) {
-      throw new RuntimeError(
-        "External tilesets are disallowed inside multiple contents",
-      );
+      multipleContents._externalTilesetCount++;
+      tile.hasTilesetContent = true;
     }
 
     multipleContents._disableSkipLevelOfDetail =
@@ -529,10 +546,6 @@ async function createInnerContent(multipleContents, arrayBuffer, index) {
       preprocessed.contentType === Cesium3DTileContentType.GEOMETRY ||
       preprocessed.contentType === Cesium3DTileContentType.VECTOR;
 
-    const tileset = multipleContents._tileset;
-    const resource = multipleContents._innerContentResources[index];
-    const tile = multipleContents._tile;
-
     let content;
     const contentFactory = Cesium3DTileContentFactory[preprocessed.contentType];
     if (defined(preprocessed.binaryPayload)) {

package/Source/Scene/PointPrimitive.js

@@ -665,7 +665,7 @@ PointPrimitive.getScreenSpaceBoundingBox = function (
  * Determines if this point equals another point.  Points are equal if all their properties
  * are equal.  Points in different collections can be equal.
  *
- * @param {PointPrimitive} other The point to compare for equality.
+ * @param {PointPrimitive} [other] The point to compare for equality.
  * @returns {boolean} <code>true</code> if the points are equal; otherwise, <code>false</code>.
  */
 PointPrimitive.prototype.equals = function (other) {

package/Source/Scene/ResourceCache.js

@@ -345,6 +345,7 @@ ResourceCache.getBufferViewLoader = function (options) {
  *
  * @param {object} options Object with the following properties:
  * @param {object} options.gltf The glTF JSON.
+ * @param {object} options.primitive The primitive containing the Draco extension.
  * @param {object} options.draco The Draco extension object.
  * @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
  * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
@@ -354,10 +355,11 @@ ResourceCache.getBufferViewLoader = function (options) {
  */
 ResourceCache.getDracoLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const { gltf, draco, gltfResource, baseResource } = options;
+  const { gltf, primitive, draco, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);
+  Check.typeOf.object("options.primitive", primitive);
   Check.typeOf.object("options.draco", draco);
   Check.typeOf.object("options.gltfResource", gltfResource);
   Check.typeOf.object("options.baseResource", baseResource);
@@ -378,6 +380,7 @@ ResourceCache.getDracoLoader = function (options) {
   dracoLoader = new GltfDracoLoader({
     resourceCache: ResourceCache,
     gltf: gltf,
+    primitive: primitive,
     draco: draco,
     gltfResource: gltfResource,
     baseResource: baseResource,
@@ -396,6 +399,7 @@ ResourceCache.getDracoLoader = function (options) {
  * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
  * @param {FrameState} options.frameState The frame state.
  * @param {number} [options.bufferViewId] The bufferView ID corresponding to the vertex buffer.
+ * @param {object} [options.primitive] The primitive containing the Draco extension.
  * @param {object} [options.draco] The Draco extension object.
  * @param {string} [options.attributeSemantic] The attribute semantic, e.g. POSITION or NORMAL.
  * @param {number} [options.accessorId] The accessor ID.
@@ -418,6 +422,7 @@ ResourceCache.getVertexBufferLoader = function (options) {
     baseResource,
     frameState,
     bufferViewId,
+    primitive,
     draco,
     attributeSemantic,
     accessorId,
@@ -439,6 +444,7 @@ ResourceCache.getVertexBufferLoader = function (options) {
   }
 
   const hasBufferViewId = defined(bufferViewId);
+  const hasPrimitive = defined(primitive);
   const hasDraco = hasDracoCompression(draco, attributeSemantic);
   const hasAttributeSemantic = defined(attributeSemantic);
   const hasAccessorId = defined(accessorId);
@@ -461,6 +467,12 @@ ResourceCache.getVertexBufferLoader = function (options) {
     );
   }
 
+  if (hasDraco && !hasPrimitive) {
+    throw new DeveloperError(
+      "When options.draco is defined options.primitive must also be defined.",
+    );
+  }
+
   if (hasDraco) {
     Check.typeOf.object("options.draco", draco);
     Check.typeOf.string("options.attributeSemantic", attributeSemantic);
@@ -492,6 +504,7 @@ ResourceCache.getVertexBufferLoader = function (options) {
     gltfResource: gltfResource,
     baseResource: baseResource,
     bufferViewId: bufferViewId,
+    primitive: primitive,
     draco: draco,
     attributeSemantic: attributeSemantic,
     accessorId: accessorId,
@@ -522,6 +535,7 @@ function hasDracoCompression(draco, semantic) {
  * @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
  * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
  * @param {FrameState} options.frameState The frame state.
+ * @param {object} [options.primitive] The primitive containing the Draco extension.
  * @param {object} [options.draco] The Draco extension object.
  * @param {boolean} [options.asynchronous=true] Determines if WebGL resource creation will be spread out over several frames or block until all WebGL resources are created.
  * @param {boolean} [options.loadBuffer=false] Load index buffer as a GPU index buffer.
@@ -537,6 +551,7 @@ ResourceCache.getIndexBufferLoader = function (options) {
     gltfResource,
     baseResource,
     frameState,
+    primitive,
     draco,
     asynchronous = true,
     loadBuffer = false,
@@ -578,6 +593,7 @@ ResourceCache.getIndexBufferLoader = function (options) {
     accessorId: accessorId,
     gltfResource: gltfResource,
     baseResource: baseResource,
+    primitive: primitive,
     draco: draco,
     cacheKey: cacheKey,
     asynchronous: asynchronous,

package/Source/Scene/Scene.js

@@ -3805,6 +3805,38 @@ function getGlobeHeight(scene) {
   return scene.getHeight(cartographic);
 }
 
+function getMaxPrimitiveHeight(primitive, cartographic, scene) {
+  let maxHeight = Number.NEGATIVE_INFINITY;
+
+  if (primitive instanceof PrimitiveCollection) {
+    // If it's a PrimitiveCollection, iterate through its children
+    const length = primitive.length;
+    for (let i = 0; i < length; ++i) {
+      const subPrimitive = primitive.get(i);
+      const subHeight = getMaxPrimitiveHeight(
+        subPrimitive,
+        cartographic,
+        scene,
+      );
+      if (defined(subHeight) && subHeight > maxHeight) {
+        maxHeight = subHeight;
+      }
+    }
+  } else if (
+    primitive.isCesium3DTileset &&
+    primitive.show &&
+    primitive.enableCollision
+  ) {
+    // If it's an individual primitive, check its height
+    const result = primitive.getHeight(cartographic, scene);
+    if (defined(result) && result > maxHeight) {
+      return result;
+    }
+  }
+
+  return maxHeight;
+}
+
 /**
  * Gets the height of the loaded surface at the cartographic position.
  * @param {Cartographic} cartographic The cartographic position.
@@ -3831,21 +3863,13 @@ Scene.prototype.getHeight = function (cartographic, heightReference) {
   let maxHeight = Number.NEGATIVE_INFINITY;
 
   if (!ignore3dTiles) {
-    const length = this.primitives.length;
-    for (let i = 0; i < length; ++i) {
-      const primitive = this.primitives.get(i);
-      if (
-        !primitive.isCesium3DTileset ||
-        !primitive.show ||
-        !primitive.enableCollision
-      ) {
-        continue;
-      }
-
-      const result = primitive.getHeight(cartographic, this);
-      if (defined(result) && result > maxHeight) {
-        maxHeight = result;
-      }
+    const maxPrimitiveHeight = getMaxPrimitiveHeight(
+      this.primitives,
+      cartographic,
+      this,
+    );
+    if (defined(maxPrimitiveHeight) && maxPrimitiveHeight > maxHeight) {
+      maxHeight = maxPrimitiveHeight;
     }
   }
 

package/Source/Scene/ScreenSpaceCameraController.js

@@ -623,14 +623,6 @@ function handleZoom(
   orientation.pitch = camera.pitch;
   orientation.roll = camera.roll;
 
-  if (camera.frustum instanceof OrthographicFrustum) {
-    if (Math.abs(distance) > 0.0) {
-      camera.zoomIn(distance);
-      camera._adjustOrthographicFrustum(true);
-    }
-    return;
-  }
-
   const sameStartPosition = defaultValue(
     movement.inertiaEnabled,
     Cartesian2.equals(startPosition, object._zoomMouseStart),

package/Source/Scene/SpatialNode.js

@@ -320,12 +320,7 @@ SpatialNode.prototype.destroyKeyframeNode = function (
     this.renderableKeyframeNodes.splice(renderableKeyframeNodeIndex, 1);
   }
 
-  keyframeNode.spatialNode = undefined;
-  keyframeNode.state = KeyframeNode.LoadState.UNLOADED;
-  keyframeNode.metadata = {};
-  keyframeNode.megatextureIndex = -1;
-  keyframeNode.priority = -Number.MAX_VALUE;
-  keyframeNode.highPriorityFrameNumber = -1;
+  keyframeNode.unload();
 };
 
 /**
@@ -337,20 +332,18 @@ SpatialNode.prototype.addKeyframeNodeToMegatextures = function (
   megatextures,
 ) {
   if (
-    keyframeNode.state !== KeyframeNode.LoadState.RECEIVED ||
     keyframeNode.megatextureIndex !== -1 ||
-    keyframeNode.metadata.length !== megatextures.length
+    keyframeNode.content.metadata.length !== megatextures.length
   ) {
     throw new DeveloperError("Keyframe node cannot be added to megatexture");
   }
 
+  const { metadata } = keyframeNode.content;
   for (let i = 0; i < megatextures.length; i++) {
     const megatexture = megatextures[i];
-    keyframeNode.megatextureIndex = megatexture.add(keyframeNode.metadata[i]);
+    keyframeNode.megatextureIndex = megatexture.add(metadata[i]);
   }
 
-  keyframeNode.state = KeyframeNode.LoadState.LOADED;
-
   const renderableKeyframeNodes = this.renderableKeyframeNodes;
   let renderableKeyframeNodeIndex = findKeyframeIndex(
     keyframeNode.keyframe,