@cesium/engine 14.0.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/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,

package/Source/Scene/Vector3DTilePoints.js

@@ -101,9 +101,8 @@ Object.defineProperties(Vector3DTilePoints.prototype, {
    */
   texturesByteLength: {
     get: function () {
-      const billboardSize =
-        this._billboardCollection.textureAtlas.texture.sizeInBytes;
-      const labelSize = this._labelCollection._textureAtlas.texture.sizeInBytes;
+      const billboardSize = this._billboardCollection.sizeInBytes;
+      const labelSize = this._labelCollection.sizeInBytes;
       return billboardSize + labelSize;
     },
   },
@@ -496,8 +495,6 @@ Vector3DTilePoints.prototype.update = function (frameState) {
       this._error = undefined;
       throw error;
     }
-
-    return;
   }
 
   this._polylineCollection.update(frameState);

package/Source/Scene/VoxelBoxShape.js

@@ -24,6 +24,7 @@ function VoxelBoxShape() {
   /**
    * An oriented bounding box containing the bounded shape.
    * The update function must be called before accessing this value.
+   * @private
    * @type {OrientedBoundingBox}
    * @readonly
    */
@@ -32,6 +33,7 @@ function VoxelBoxShape() {
   /**
    * A bounding sphere containing the bounded shape.
    * The update function must be called before accessing this value.
+   * @private
    * @type {BoundingSphere}
    * @readonly
    */
@@ -40,6 +42,7 @@ function VoxelBoxShape() {
   /**
    * A transformation matrix containing the bounded shape.
    * The update function must be called before accessing this value.
+   * @private
    * @type {Matrix4}
    * @readonly
    */
@@ -48,6 +51,7 @@ function VoxelBoxShape() {
   /**
    * A transformation matrix containing the shape, ignoring the bounds.
    * The update function must be called before accessing this value.
+   * @private
    * @type {Matrix4}
    * @readonly
    */
@@ -72,6 +76,7 @@ function VoxelBoxShape() {
   );
 
   /**
+   * @private
    * @type {Object<string, any>}
    * @readonly
    */
@@ -83,6 +88,7 @@ function VoxelBoxShape() {
   };
 
   /**
+   * @private
    * @type {Object<string, any>}
    * @readonly
    */
@@ -93,6 +99,7 @@ function VoxelBoxShape() {
 
   /**
    * The maximum number of intersections against the shape for any ray direction.
+   * @private
    * @type {number}
    * @readonly
    */
@@ -115,7 +122,7 @@ const transformLocalToUv = Matrix4.fromRotationTranslation(
 
 /**
  * Update the shape's state.
- *
+ * @private
  * @param {Matrix4} modelMatrix The model matrix.
  * @param {Cartesian3} minBounds The minimum bounds.
  * @param {Cartesian3} maxBounds The maximum bounds.
@@ -302,7 +309,7 @@ const scratchTileMaxBounds = new Cartesian3();
 /**
  * Computes an oriented bounding box for a specified tile.
  * The update function must be called before calling this function.
- *
+ * @private
  * @param {number} tileLevel The tile's level.
  * @param {number} tileX The tile's x coordinate.
  * @param {number} tileY The tile's y coordinate.
@@ -356,7 +363,7 @@ const sampleSizeScratch = new Cartesian3();
 /**
  * Computes an oriented bounding box for a specified sample within a specified tile.
  * The update function must be called before calling this function.
- *
+ * @private
  * @param {SpatialNode} spatialNode The spatial node containing the sample
  * @param {Cartesian3} tileDimensions The size of the tile in number of samples, before padding
  * @param {Cartesian3} tileUv The sample coordinate within the tile
@@ -429,7 +436,7 @@ VoxelBoxShape.prototype.computeOrientedBoundingBoxForSample = function (
 
 /**
  * Defines the minimum bounds of the shape. Corresponds to minimum X, Y, Z.
- *
+ * @private
  * @type {Cartesian3}
  * @constant
  * @readonly
@@ -440,7 +447,7 @@ VoxelBoxShape.DefaultMinBounds = Object.freeze(
 
 /**
  * Defines the maximum bounds of the shape. Corresponds to maximum X, Y, Z.
- *
+ * @private
  * @type {Cartesian3}
  * @constant
  * @readonly

package/Source/Scene/VoxelCell.js

@@ -71,8 +71,8 @@ VoxelCell.fromKeyframeNode = function (
   //>>includeEnd('debug');
 
   const voxelCell = new VoxelCell(primitive, tileIndex, sampleIndex);
-  const { spatialNode, metadata } = keyframeNode;
-  voxelCell._metadata = getMetadataForSample(primitive, metadata, sampleIndex);
+  const { spatialNode, content } = keyframeNode;
+  voxelCell._metadata = getMetadataForSample(primitive, content, sampleIndex);
   voxelCell._orientedBoundingBox = getOrientedBoundingBox(
     primitive,
     spatialNode,
@@ -85,15 +85,16 @@ VoxelCell.fromKeyframeNode = function (
 /**
  * @private
  * @param {VoxelPrimitive} primitive
- * @param {object} metadata
+ * @param {VoxelContent} content
  * @param {number} sampleIndex
  * @returns {object}
  */
-function getMetadataForSample(primitive, metadata, sampleIndex) {
-  if (!defined(metadata)) {
+function getMetadataForSample(primitive, content, sampleIndex) {
+  if (!defined(content) || !defined(content.metadata)) {
     return undefined;
   }
   const { names, types } = primitive.provider;
+  const { metadata } = content;
   const metadataMap = {};
   for (let i = 0; i < names.length; i++) {
     const name = names[i];