@cesium/engine 1.0.0 → 2.0.0

package/Source/Scene/Cesium3DTileBatchTable.js

@@ -517,13 +517,13 @@ Cesium3DTileBatchTable.prototype.getVertexShaderCallback = function (
       newMain +=
         `${
           "uniform sampler2D tile_batchTexture; \n" +
-          "varying vec4 tile_featureColor; \n" +
-          "varying vec2 tile_featureSt; \n" +
+          "out vec4 tile_featureColor; \n" +
+          "out vec2 tile_featureSt; \n" +
           "void main() \n" +
           "{ \n" +
           "    vec2 st = computeSt("
         }${batchIdAttributeName}); \n` +
-        `    vec4 featureProperties = texture2D(tile_batchTexture, st); \n` +
+        `    vec4 featureProperties = texture(tile_batchTexture, st); \n` +
         `    tile_color(featureProperties); \n` +
         `    float show = ceil(featureProperties.a); \n` + // 0 - false, non-zero - true
         `    gl_Position *= show; \n`; // Per-feature show/hide
@@ -553,7 +553,7 @@ Cesium3DTileBatchTable.prototype.getVertexShaderCallback = function (
       // When VTF is not supported, color blend mode MIX will look incorrect due to the feature's color not being available in the vertex shader
       newMain =
         `${
-          "varying vec2 tile_featureSt; \n" +
+          "out vec2 tile_featureSt; \n" +
           "void main() \n" +
           "{ \n" +
           "    tile_color(vec4(1.0)); \n" +
@@ -578,22 +578,22 @@ function getDefaultShader(source, applyHighlight) {
   }
 
   // The color blend mode is intended for the RGB channels so alpha is always just multiplied.
-  // gl_FragColor is multiplied by the tile color only when tile_colorBlend is 0.0 (highlight)
+  // out_FragColor is multiplied by the tile color only when tile_colorBlend is 0.0 (highlight)
   return (
     `${source}uniform float tile_colorBlend; \n` +
     `void tile_color(vec4 tile_featureColor) \n` +
     `{ \n` +
     `    tile_main(); \n` +
     `    tile_featureColor = czm_gammaCorrect(tile_featureColor); \n` +
-    `    gl_FragColor.a *= tile_featureColor.a; \n` +
+    `    out_FragColor.a *= tile_featureColor.a; \n` +
     `    float highlight = ceil(tile_colorBlend); \n` +
-    `    gl_FragColor.rgb *= mix(tile_featureColor.rgb, vec3(1.0), highlight); \n` +
+    `    out_FragColor.rgb *= mix(tile_featureColor.rgb, vec3(1.0), highlight); \n` +
     `} \n`
   );
 }
 
 function replaceDiffuseTextureCalls(source, diffuseAttributeOrUniformName) {
-  const functionCall = `texture2D(${diffuseAttributeOrUniformName}`;
+  const functionCall = `texture(${diffuseAttributeOrUniformName}`;
 
   let fromIndex = 0;
   let startIndex = source.indexOf(functionCall, fromIndex);
@@ -668,12 +668,12 @@ function modifyDiffuse(source, diffuseAttributeOrUniformName, applyHighlight) {
     "} \n";
 
   // The color blend mode is intended for the RGB channels so alpha is always just multiplied.
-  // gl_FragColor is multiplied by the tile color only when tile_colorBlend is 0.0 (highlight)
+  // out_FragColor is multiplied by the tile color only when tile_colorBlend is 0.0 (highlight)
   const highlight =
     "    tile_featureColor = czm_gammaCorrect(tile_featureColor); \n" +
-    "    gl_FragColor.a *= tile_featureColor.a; \n" +
+    "    out_FragColor.a *= tile_featureColor.a; \n" +
     "    float highlight = ceil(tile_colorBlend); \n" +
-    "    gl_FragColor.rgb *= mix(tile_featureColor.rgb, vec3(1.0), highlight); \n";
+    "    out_FragColor.rgb *= mix(tile_featureColor.rgb, vec3(1.0), highlight); \n";
 
   let setColor;
   if (type === "vec3" || type === "vec4") {
@@ -691,8 +691,8 @@ function modifyDiffuse(source, diffuseAttributeOrUniformName, applyHighlight) {
       `    tile_main(); \n`;
   } else if (type === "sampler2D") {
     // Handles any number of nested parentheses
-    // E.g. texture2D(u_diffuse, uv)
-    // E.g. texture2D(u_diffuse, computeUV(index))
+    // E.g. texture(u_diffuse, uv)
+    // E.g. texture(u_diffuse, computeUV(index))
     source = replaceDiffuseTextureCalls(source, diffuseAttributeOrUniformName);
     setColor =
       "    tile_diffuse = tile_featureColor; \n" + "    tile_main(); \n";
@@ -727,14 +727,14 @@ Cesium3DTileBatchTable.prototype.getFragmentShaderCallback = function (
       // When VTF is supported, per-feature show/hide already happened in the fragment shader
       source +=
         "uniform sampler2D tile_pickTexture; \n" +
-        "varying vec2 tile_featureSt; \n" +
-        "varying vec4 tile_featureColor; \n" +
+        "in vec2 tile_featureSt; \n" +
+        "in vec4 tile_featureColor; \n" +
         "void main() \n" +
         "{ \n" +
         "    tile_color(tile_featureColor); \n";
 
       if (hasPremultipliedAlpha) {
-        source += "    gl_FragColor.rgb *= gl_FragColor.a; \n";
+        source += "    out_FragColor.rgb *= out_FragColor.a; \n";
       }
 
       source += "}";
@@ -745,10 +745,10 @@ Cesium3DTileBatchTable.prototype.getFragmentShaderCallback = function (
       source +=
         "uniform sampler2D tile_pickTexture; \n" +
         "uniform sampler2D tile_batchTexture; \n" +
-        "varying vec2 tile_featureSt; \n" +
+        "in vec2 tile_featureSt; \n" +
         "void main() \n" +
         "{ \n" +
-        "    vec4 featureProperties = texture2D(tile_batchTexture, tile_featureSt); \n" +
+        "    vec4 featureProperties = texture(tile_batchTexture, tile_featureSt); \n" +
         "    if (featureProperties.a == 0.0) { \n" + // show: alpha == 0 - false, non-zeo - true
         "        discard; \n" +
         "    } \n";
@@ -775,7 +775,7 @@ Cesium3DTileBatchTable.prototype.getFragmentShaderCallback = function (
       source += "    tile_color(featureProperties); \n";
 
       if (hasPremultipliedAlpha) {
-        source += "    gl_FragColor.rgb *= gl_FragColor.a; \n";
+        source += "    out_FragColor.rgb *= out_FragColor.a; \n";
       }
 
       source += "} \n";
@@ -794,28 +794,28 @@ Cesium3DTileBatchTable.prototype.getClassificationFragmentShaderCallback = funct
       // When VTF is supported, per-feature show/hide already happened in the fragment shader
       source +=
         "uniform sampler2D tile_pickTexture;\n" +
-        "varying vec2 tile_featureSt; \n" +
-        "varying vec4 tile_featureColor; \n" +
+        "in vec2 tile_featureSt; \n" +
+        "in vec4 tile_featureColor; \n" +
         "void main() \n" +
         "{ \n" +
         "    tile_main(); \n" +
-        "    gl_FragColor = tile_featureColor; \n" +
-        "    gl_FragColor.rgb *= gl_FragColor.a; \n" +
+        "    out_FragColor = tile_featureColor; \n" +
+        "    out_FragColor.rgb *= out_FragColor.a; \n" +
         "}";
     } else {
       source +=
         "uniform sampler2D tile_batchTexture; \n" +
         "uniform sampler2D tile_pickTexture;\n" +
-        "varying vec2 tile_featureSt; \n" +
+        "in vec2 tile_featureSt; \n" +
         "void main() \n" +
         "{ \n" +
         "    tile_main(); \n" +
-        "    vec4 featureProperties = texture2D(tile_batchTexture, tile_featureSt); \n" +
+        "    vec4 featureProperties = texture(tile_batchTexture, tile_featureSt); \n" +
         "    if (featureProperties.a == 0.0) { \n" + // show: alpha == 0 - false, non-zero - true
         "        discard; \n" +
         "    } \n" +
-        "    gl_FragColor = featureProperties; \n" +
-        "    gl_FragColor.rgb *= gl_FragColor.a; \n" +
+        "    out_FragColor = featureProperties; \n" +
+        "    out_FragColor.rgb *= out_FragColor.a; \n" +
         "} \n";
     }
     return source;
@@ -875,7 +875,7 @@ Cesium3DTileBatchTable.prototype.getUniformMapCallback = function () {
 };
 
 Cesium3DTileBatchTable.prototype.getPickId = function () {
-  return "texture2D(tile_pickTexture, tile_featureSt)";
+  return "texture(tile_pickTexture, tile_featureSt)";
 };
 
 ///////////////////////////////////////////////////////////////////////////

package/Source/Scene/Cesium3DTileContentType.js

@@ -132,6 +132,24 @@ const Cesium3DTileContentType = {
    * @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.
    */
   GEOJSON: "geoJson",
+  /**
+   * Binary voxel content for <code>3DTILES_content_voxels</code> extension.
+   *
+   * @type {String}
+   * @constant
+   * @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.
+   */
+  VOXEL_BINARY: "voxl",
+  /**
+   * Binary voxel content for <code>3DTILES_content_voxels</code> extension.
+   *
+   * @type {String}
+   * @constant
+   * @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.
+   */
+  VOXEL_JSON: "voxelJson",
 };
 
 /**
@@ -150,6 +168,7 @@ Cesium3DTileContentType.isBinaryFormat = function (contentType) {
     case Cesium3DTileContentType.VECTOR:
     case Cesium3DTileContentType.GEOMETRY:
     case Cesium3DTileContentType.IMPLICIT_SUBTREE:
+    case Cesium3DTileContentType.VOXEL_BINARY:
     case Cesium3DTileContentType.GLTF_BINARY:
       return true;
     default:

package/Source/Scene/Cesium3DTilesVoxelProvider.js

@@ -0,0 +1,494 @@
+import Cartesian3 from "../Core/Cartesian3.js";
+import Check from "../Core/Check.js";
+import defaultValue from "../Core/defaultValue.js";
+import defined from "../Core/defined.js";
+import DeveloperError from "../Core/DeveloperError.js";
+import Ellipsoid from "../Core/Ellipsoid.js";
+import Matrix4 from "../Core/Matrix4.js";
+import OrientedBoundingBox from "../Core/OrientedBoundingBox.js";
+import Resource from "../Core/Resource.js";
+import RuntimeError from "../Core/RuntimeError.js";
+import Cesium3DTilesetMetadata from "./Cesium3DTilesetMetadata.js";
+import hasExtension from "./hasExtension.js";
+import ImplicitSubtree from "./ImplicitSubtree.js";
+import ImplicitSubtreeCache from "./ImplicitSubtreeCache.js";
+import ImplicitTileCoordinates from "./ImplicitTileCoordinates.js";
+import ImplicitTileset from "./ImplicitTileset.js";
+import MetadataSemantic from "./MetadataSemantic.js";
+import MetadataType from "./MetadataType.js";
+import preprocess3DTileContent from "./preprocess3DTileContent.js";
+import ResourceCache from "./ResourceCache.js";
+import VoxelBoxShape from "./VoxelBoxShape.js";
+import VoxelContent from "./VoxelContent.js";
+import VoxelCylinderShape from "./VoxelCylinderShape.js";
+import VoxelShapeType from "./VoxelShapeType.js";
+
+/**
+ * A {@link VoxelProvider} that fetches voxel data from a 3D Tiles tileset.
+ * <p>
+ * Implements the {@link VoxelProvider} interface.
+ * </p>
+ *
+ * @alias Cesium3DTilesVoxelProvider
+ * @constructor
+ * @augments VoxelProvider
+ *
+ * @param {Object} options Object with the following properties:
+ * @param {Resource|String|Promise<Resource>|Promise<String>} options.url The URL to a tileset JSON file.
+ *
+ * @see VoxelProvider
+ * @see VoxelPrimitive
+ * @see VoxelShapeType
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ */
+function Cesium3DTilesVoxelProvider(options) {
+  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  //>>includeStart('debug', pragmas.debug)
+  Check.defined("options.url", options.url);
+  //>>includeEnd('debug');
+
+  /** @inheritdoc */
+  this.ready = false;
+
+  /** @inheritdoc */
+  this.shapeTransform = undefined;
+
+  /** @inheritdoc */
+  this.globalTransform = undefined;
+
+  /** @inheritdoc */
+  this.shape = undefined;
+
+  /** @inheritdoc */
+  this.minBounds = undefined;
+
+  /** @inheritdoc */
+  this.maxBounds = undefined;
+
+  /** @inheritdoc */
+  this.dimensions = undefined;
+
+  /** @inheritdoc */
+  this.paddingBefore = undefined;
+
+  /** @inheritdoc */
+  this.paddingAfter = undefined;
+
+  /** @inheritdoc */
+  this.names = undefined;
+
+  /** @inheritdoc */
+  this.types = undefined;
+
+  /** @inheritdoc */
+  this.componentTypes = undefined;
+
+  /** @inheritdoc */
+  this.minimumValues = undefined;
+
+  /** @inheritdoc */
+  this.maximumValues = undefined;
+
+  /** @inheritdoc */
+  this.maximumTileCount = undefined;
+
+  this._implicitTileset = undefined;
+  this._subtreeCache = new ImplicitSubtreeCache();
+
+  const that = this;
+  let tilesetJson;
+
+  this._readyPromise = Promise.resolve(options.url).then(function (url) {
+    const resource = Resource.createIfNeeded(url);
+    return resource
+      .fetchJson()
+      .then(function (tileset) {
+        tilesetJson = tileset;
+        validate(tilesetJson);
+        return getMetadataSchemaLoader(tilesetJson, resource).promise;
+      })
+      .then(function (schemaLoader) {
+        const root = tilesetJson.root;
+        const voxel = root.content.extensions["3DTILES_content_voxels"];
+        const className = voxel.class;
+
+        const metadataJson = hasExtension(tilesetJson, "3DTILES_metadata")
+          ? tilesetJson.extensions["3DTILES_metadata"]
+          : tilesetJson;
+
+        const metadataSchema = schemaLoader.schema;
+        const metadata = new Cesium3DTilesetMetadata({
+          metadataJson: metadataJson,
+          schema: metadataSchema,
+        });
+
+        addAttributeInfo(that, metadata, className);
+
+        const implicitTileset = new ImplicitTileset(
+          resource,
+          root,
+          metadataSchema
+        );
+
+        const {
+          shape,
+          minBounds,
+          maxBounds,
+          shapeTransform,
+          globalTransform,
+        } = getShape(root);
+
+        that.shape = shape;
+        that.minBounds = minBounds;
+        that.maxBounds = maxBounds;
+        that.dimensions = Cartesian3.unpack(voxel.dimensions);
+        that.shapeTransform = shapeTransform;
+        that.globalTransform = globalTransform;
+        that.maximumTileCount = getTileCount(metadata);
+
+        let paddingBefore;
+        let paddingAfter;
+
+        if (defined(voxel.padding)) {
+          paddingBefore = Cartesian3.unpack(voxel.padding.before);
+          paddingAfter = Cartesian3.unpack(voxel.padding.after);
+        }
+
+        that.paddingBefore = paddingBefore;
+        that.paddingAfter = paddingAfter;
+
+        that._implicitTileset = implicitTileset;
+
+        ResourceCache.unload(schemaLoader);
+
+        that.ready = true;
+        return that;
+      });
+  });
+}
+
+Object.defineProperties(Cesium3DTilesVoxelProvider.prototype, {
+  /** @inheritdoc */
+  readyPromise: {
+    get: function () {
+      return this._readyPromise;
+    },
+  },
+});
+
+function getTileCount(metadata) {
+  if (!defined(metadata.tileset)) {
+    return undefined;
+  }
+
+  return metadata.tileset.getPropertyBySemantic(
+    MetadataSemantic.TILESET_TILE_COUNT
+  );
+}
+
+function validate(tileset) {
+  const root = tileset.root;
+
+  if (!defined(root.content)) {
+    throw new RuntimeError("Root must have content");
+  }
+
+  if (!hasExtension(root.content, "3DTILES_content_voxels")) {
+    throw new RuntimeError(
+      "Root tile content must have 3DTILES_content_voxels extension"
+    );
+  }
+
+  if (
+    !hasExtension(root, "3DTILES_implicit_tiling") &&
+    !defined(root.implicitTiling)
+  ) {
+    throw new RuntimeError("Root tile must have implicit tiling");
+  }
+
+  if (
+    !defined(tileset.schema) &&
+    !defined(tileset.schemaUri) &&
+    !hasExtension(tileset, "3DTILES_metadata")
+  ) {
+    throw new RuntimeError("Tileset must have a metadata schema");
+  }
+}
+
+function getShape(tile) {
+  const boundingVolume = tile.boundingVolume;
+
+  let tileTransform;
+  if (defined(tile.transform)) {
+    tileTransform = Matrix4.unpack(tile.transform);
+  } else {
+    tileTransform = Matrix4.clone(Matrix4.IDENTITY);
+  }
+
+  if (defined(boundingVolume.box)) {
+    return getBoxShape(boundingVolume.box, tileTransform);
+  } else if (defined(boundingVolume.region)) {
+    return getEllipsoidShape(boundingVolume.region);
+  } else if (hasExtension(boundingVolume, "3DTILES_bounding_volume_cylinder")) {
+    return getCylinderShape(
+      boundingVolume.extensions["3DTILES_bounding_volume_cylinder"].cylinder,
+      tileTransform
+    );
+  }
+
+  throw new RuntimeError(
+    "Only box, region and 3DTILES_bounding_volume_cylinder are supported in Cesium3DTilesVoxelProvider"
+  );
+}
+
+function getEllipsoidShape(region) {
+  const west = region[0];
+  const south = region[1];
+  const east = region[2];
+  const north = region[3];
+  const minHeight = region[4];
+  const maxHeight = region[5];
+
+  const shapeTransform = Matrix4.fromScale(Ellipsoid.WGS84.radii);
+
+  const minBoundsX = west;
+  const maxBoundsX = east;
+  const minBoundsY = south;
+  const maxBoundsY = north;
+  const minBoundsZ = minHeight;
+  const maxBoundsZ = maxHeight;
+
+  const minBounds = new Cartesian3(minBoundsX, minBoundsY, minBoundsZ);
+  const maxBounds = new Cartesian3(maxBoundsX, maxBoundsY, maxBoundsZ);
+
+  return {
+    shape: VoxelShapeType.ELLIPSOID,
+    minBounds: minBounds,
+    maxBounds: maxBounds,
+    shapeTransform: shapeTransform,
+    globalTransform: Matrix4.clone(Matrix4.IDENTITY),
+  };
+}
+
+function getBoxShape(box, tileTransform) {
+  const obb = OrientedBoundingBox.unpack(box);
+  const shapeTransform = Matrix4.fromRotationTranslation(
+    obb.halfAxes,
+    obb.center
+  );
+
+  return {
+    shape: VoxelShapeType.BOX,
+    minBounds: Cartesian3.clone(VoxelBoxShape.DefaultMinBounds),
+    maxBounds: Cartesian3.clone(VoxelBoxShape.DefaultMaxBounds),
+    shapeTransform: shapeTransform,
+    globalTransform: tileTransform,
+  };
+}
+
+function getCylinderShape(cylinder, tileTransform) {
+  const obb = OrientedBoundingBox.unpack(cylinder);
+  const shapeTransform = Matrix4.fromRotationTranslation(
+    obb.halfAxes,
+    obb.center
+  );
+
+  return {
+    shape: VoxelShapeType.CYLINDER,
+    minBounds: Cartesian3.clone(VoxelCylinderShape.DefaultMinBounds),
+    maxBounds: Cartesian3.clone(VoxelCylinderShape.DefaultMaxBounds),
+    shapeTransform: shapeTransform,
+    globalTransform: tileTransform,
+  };
+}
+
+function getMetadataSchemaLoader(tilesetJson, resource) {
+  const { schemaUri, schema } = tilesetJson;
+  if (!defined(schemaUri)) {
+    return ResourceCache.loadSchema({ schema });
+  }
+  return ResourceCache.loadSchema({
+    resource: resource.getDerivedResource({
+      url: schemaUri,
+    }),
+  });
+}
+
+function addAttributeInfo(provider, metadata, className) {
+  const { schema, statistics } = metadata;
+  const classStatistics = statistics?.classes[className];
+  const properties = schema.classes[className].properties;
+
+  const propertyInfo = Object.entries(properties).map(([id, property]) => {
+    const { type, componentType } = property;
+    const min = classStatistics?.properties[id].min;
+    const max = classStatistics?.properties[id].max;
+    const componentCount = MetadataType.getComponentCount(type);
+    const minValue = copyArray(min, componentCount);
+    const maxValue = copyArray(max, componentCount);
+
+    return { id, type, componentType, minValue, maxValue };
+  });
+
+  provider.names = propertyInfo.map((info) => info.id);
+  provider.types = propertyInfo.map((info) => info.type);
+  provider.componentTypes = propertyInfo.map((info) => info.componentType);
+
+  const minimumValues = propertyInfo.map((info) => info.minValue);
+  const maximumValues = propertyInfo.map((info) => info.maxValue);
+  const hasMinimumValues = minimumValues.some(defined);
+
+  provider.minimumValues = hasMinimumValues ? minimumValues : undefined;
+  provider.maximumValues = hasMinimumValues ? maximumValues : undefined;
+}
+
+function copyArray(values, length) {
+  // Copy input values into a new array of a specified length.
+  // If the input is not an array, its value will be copied into the first element
+  // of the returned array. If the input is an array shorter than the returned
+  // array, the extra elements in the returned array will be undefined. If the
+  // input is undefined, the return will be undefined.
+  if (!defined(values)) {
+    return;
+  }
+  const valuesArray = Array.isArray(values) ? values : [values];
+  return Array.from({ length }, (v, i) => valuesArray[i]);
+}
+
+function getVoxelPromise(implicitTileset, tileCoordinates) {
+  const voxelRelative = implicitTileset.contentUriTemplates[0].getDerivedResource(
+    {
+      templateValues: tileCoordinates.getTemplateValues(),
+    }
+  );
+  const voxelResource = implicitTileset.baseResource.getDerivedResource({
+    url: voxelRelative.url,
+  });
+
+  return voxelResource.fetchArrayBuffer().then(function (arrayBuffer) {
+    const preprocessed = preprocess3DTileContent(arrayBuffer);
+
+    const voxelContent = new VoxelContent(
+      voxelResource,
+      preprocessed.jsonPayload,
+      preprocessed.binaryPayload,
+      implicitTileset.metadataSchema
+    );
+
+    return voxelContent.readyPromise;
+  });
+}
+
+function getSubtreePromise(provider, subtreeCoord) {
+  const implicitTileset = provider._implicitTileset;
+  const subtreeCache = provider._subtreeCache;
+
+  // First load the subtree to check if the tile is available.
+  // If the subtree has been requested previously it might still be in the cache
+  const subtree = subtreeCache.find(subtreeCoord);
+  if (defined(subtree)) {
+    return subtree.readyPromise;
+  }
+
+  const subtreeRelative = implicitTileset.subtreeUriTemplate.getDerivedResource(
+    {
+      templateValues: subtreeCoord.getTemplateValues(),
+    }
+  );
+  const subtreeResource = implicitTileset.baseResource.getDerivedResource({
+    url: subtreeRelative.url,
+  });
+
+  return subtreeResource.fetchArrayBuffer().then(function (arrayBuffer) {
+    // Check one more time if the subtree is in the cache.
+    // This could happen if there are two in-flight tile requests from the same
+    // subtree and one finishes before the other.
+    let subtree = subtreeCache.find(subtreeCoord);
+    if (defined(subtree)) {
+      return subtree.readyPromise;
+    }
+
+    const preprocessed = preprocess3DTileContent(arrayBuffer);
+    subtree = new ImplicitSubtree(
+      subtreeResource,
+      preprocessed.jsonPayload,
+      preprocessed.binaryPayload,
+      implicitTileset,
+      subtreeCoord
+    );
+    subtreeCache.addSubtree(subtree);
+    return subtree.readyPromise;
+  });
+}
+
+/** @inheritdoc */
+Cesium3DTilesVoxelProvider.prototype.requestData = function (options) {
+  //>>includeStart('debug', pragmas.debug);
+  if (!this.ready) {
+    throw new DeveloperError(
+      "The provider is not ready. Use Cesium3DTilesVoxelProvider.readyPromise or wait for Cesium3DTilesVoxelProvider.ready to be true."
+    );
+  }
+  //>>includeEnd('debug');
+
+  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  const tileLevel = defaultValue(options.tileLevel, 0);
+  const tileX = defaultValue(options.tileX, 0);
+  const tileY = defaultValue(options.tileY, 0);
+  const tileZ = defaultValue(options.tileZ, 0);
+  const keyframe = defaultValue(options.keyframe, 0);
+
+  // 3D Tiles currently doesn't support time-dynamic data.
+  if (keyframe !== 0) {
+    return undefined;
+  }
+
+  // 1. Load the subtree that the tile belongs to (possibly from the subtree cache)
+  // 2. Load the voxel content if available
+
+  const implicitTileset = this._implicitTileset;
+  const names = this.names;
+
+  // Can't use a scratch variable here because the object is used inside the promise chain.
+  const tileCoordinates = new ImplicitTileCoordinates({
+    subdivisionScheme: implicitTileset.subdivisionScheme,
+    subtreeLevels: implicitTileset.subtreeLevels,
+    level: tileLevel,
+    x: tileX,
+    y: tileY,
+    z: tileZ,
+  });
+
+  // Find the coordinates of the parent subtree containing tileCoordinates
+  // If tileCoordinates is a subtree child, use that subtree
+  // If tileCoordinates is a subtree root, use its parent subtree
+  const isSubtreeRoot =
+    tileCoordinates.isSubtreeRoot() && tileCoordinates.level > 0;
+
+  const subtreeCoord = isSubtreeRoot
+    ? tileCoordinates.getParentSubtreeCoordinates()
+    : tileCoordinates.getSubtreeCoordinates();
+
+  const that = this;
+
+  return getSubtreePromise(that, subtreeCoord)
+    .then(function (subtree) {
+      const available = isSubtreeRoot
+        ? subtree.childSubtreeIsAvailableAtCoordinates(tileCoordinates)
+        : subtree.tileIsAvailableAtCoordinates(tileCoordinates);
+
+      if (!available) {
+        return Promise.reject("Tile is not available");
+      }
+
+      return getVoxelPromise(implicitTileset, tileCoordinates);
+    })
+    .then(function (voxelContent) {
+      return names.map(function (name) {
+        return voxelContent.metadataTable.getPropertyTypedArray(name);
+      });
+    });
+};
+
+export default Cesium3DTilesVoxelProvider;