@cesium/engine 7.0.0 → 9.0.0

package/Source/Scene/Globe.js

@@ -28,7 +28,6 @@ import ImageryLayerCollection from "./ImageryLayerCollection.js";
 import QuadtreePrimitive from "./QuadtreePrimitive.js";
 import SceneMode from "./SceneMode.js";
 import ShadowMode from "./ShadowMode.js";
-import deprecationWarning from "../Core/deprecationWarning.js";
 
 /**
  * The globe rendered in the scene, including its terrain ({@link Globe#terrainProvider})
@@ -341,10 +340,6 @@ function Globe(ellipsoid) {
    */
   this.atmosphereBrightnessShift = 0.0;
 
-  this._terrainExaggerationChanged = false;
-  this._terrainExaggeration = 1.0;
-  this._terrainExaggerationRelativeHeight = 0.0;
-
   /**
    * Whether to show terrain skirts. Terrain skirts are geometry extending downwards from a tile's edges used to hide seams between neighboring tiles.
    * Skirts are always hidden when the camera is underground or translucency is enabled.
@@ -523,68 +518,6 @@ Object.defineProperties(Globe.prototype, {
       return this._terrainProviderChanged;
     },
   },
-  /**
-   * A scalar used to exaggerate the terrain. Defaults to <code>1.0</code> (no exaggeration).
-   * A value of <code>2.0</code> scales the terrain by 2x.
-   * A value of <code>0.0</code> makes the terrain completely flat.
-   * Note that terrain exaggeration will not modify any other primitive as they are positioned relative to the ellipsoid.
-   *
-   * @memberof Globe.prototype
-   * @type {number}
-   * @default 1.0
-   *
-   * @deprecated
-   */
-  terrainExaggeration: {
-    get: function () {
-      deprecationWarning(
-        "Globe.terrainExaggeration",
-        "Globe.terrainExaggeration was deprecated in CesiumJS 1.113.  It will be removed in CesiumJS 1.116. Use Scene.verticalExaggeration instead."
-      );
-      return this._terrainExaggeration;
-    },
-    set: function (value) {
-      deprecationWarning(
-        "Globe.terrainExaggeration",
-        "Globe.terrainExaggeration was deprecated in CesiumJS 1.113.  It will be removed in CesiumJS 1.116. Use Scene.verticalExaggeration instead."
-      );
-      if (value !== this._terrainExaggeration) {
-        this._terrainExaggeration = value;
-        this._terrainExaggerationChanged = true;
-      }
-    },
-  },
-  /**
-   * The height from which terrain is exaggerated. Defaults to <code>0.0</code> (scaled relative to ellipsoid surface).
-   * Terrain that is above this height will scale upwards and terrain that is below this height will scale downwards.
-   * Note that terrain exaggeration will not modify any other primitive as they are positioned relative to the ellipsoid.
-   * If {@link Globe#terrainExaggeration} is <code>1.0</code> this value will have no effect.
-   *
-   * @memberof Globe.prototype
-   * @type {number}
-   * @default 0.0
-   *
-   * @deprecated
-   */
-  terrainExaggerationRelativeHeight: {
-    get: function () {
-      deprecationWarning(
-        "Globe.terrainExaggerationRelativeHeight",
-        "Globe.terrainExaggerationRelativeHeight was deprecated in CesiumJS 1.113.  It will be removed in CesiumJS 1.116. Use Scene.verticalExaggerationRelativeHeight instead."
-      );
-      return this._terrainExaggerationRelativeHeight;
-    },
-    set: function (value) {
-      deprecationWarning(
-        "Globe.terrainExaggerationRelativeHeight",
-        "Globe.terrainExaggerationRelativeHeight was deprecated in CesiumJS 1.113.  It will be removed in CesiumJS 1.116. Use Scene.verticalExaggerationRelativeHeight instead."
-      );
-      if (value !== this._terrainExaggerationRelativeHeight) {
-        this._terrainExaggerationRelativeHeight = value;
-        this._terrainExaggerationChanged = true;
-      }
-    },
-  },
   /**
    * Gets an event that's raised when the length of the tile load queue has changed since the last render frame.  When the load queue is empty,
    * all terrain and imagery for the current view have been loaded.  The event passes the new length of the tile load queue.

package/Source/Scene/GlobeTranslucencyState.js

@@ -930,7 +930,7 @@ GlobeTranslucencyState.prototype.pushDerivedCommands = function (
   isBlendCommand,
   frameState
 ) {
-  const picking = frameState.passes.pick;
+  const picking = frameState.passes.pick || frameState.passes.pickVoxel;
   if (picking && isBlendCommand) {
     // No need to push blend commands in the pick pass
     return;

package/Source/Scene/GltfPipeline/updateVersion.js

@@ -1079,6 +1079,26 @@ function convertTechniquesToPbr(gltf, options) {
   removeExtension(gltf, "KHR_blend");
 }
 
+function assignAsBaseColor(material, baseColor) {
+  if (defined(baseColor)) {
+    if (isVec4(baseColor)) {
+      material.pbrMetallicRoughness.baseColorFactor = srgbToLinear(baseColor);
+    } else if (isTexture(baseColor)) {
+      material.pbrMetallicRoughness.baseColorTexture = baseColor;
+    }
+  }
+}
+
+function assignAsEmissive(material, emissive) {
+  if (defined(emissive)) {
+    if (isVec4(emissive)) {
+      material.emissiveFactor = emissive.slice(0, 3);
+    } else if (isTexture(emissive)) {
+      material.emissiveTexture = emissive;
+    }
+  }
+}
+
 function convertMaterialsCommonToPbr(gltf) {
   // Future work: convert KHR_materials_common lights to KHR_lights_punctual
   ForEach.material(gltf, function (material) {
@@ -1086,80 +1106,61 @@ function convertMaterialsCommonToPbr(gltf) {
       material.extensions,
       defaultValue.EMPTY_OBJECT
     ).KHR_materials_common;
+    if (!defined(materialsCommon)) {
+      // Nothing to do
+      return;
+    }
 
-    if (defined(materialsCommon)) {
-      const technique = materialsCommon.technique;
-      if (technique === "CONSTANT") {
-        // Add the KHR_materials_unlit extension
-        addExtensionsUsed(gltf, "KHR_materials_unlit");
-        material.extensions = defined(material.extensions)
-          ? material.extensions
-          : {};
-        material.extensions["KHR_materials_unlit"] = {};
-      }
-
-      const values = defined(materialsCommon.values)
-        ? materialsCommon.values
+    const values = defaultValue(materialsCommon.values, {});
+    const ambient = values.ambient;
+    const diffuse = values.diffuse;
+    const emission = values.emission;
+    const transparency = values.transparency;
+
+    // These actually exist on the extension object, not the values object despite what's shown in the spec
+    const doubleSided = materialsCommon.doubleSided;
+    const transparent = materialsCommon.transparent;
+
+    // Ignore specular and shininess for now because the conversion to PBR
+    // isn't straightforward and depends on the technique
+    initializePbrMaterial(material);
+
+    const technique = materialsCommon.technique;
+    if (technique === "CONSTANT") {
+      // Add the KHR_materials_unlit extension
+      addExtensionsUsed(gltf, "KHR_materials_unlit");
+      material.extensions = defined(material.extensions)
+        ? material.extensions
         : {};
+      material.extensions["KHR_materials_unlit"] = {};
 
-      const ambient = values.ambient;
-      const diffuse = values.diffuse;
-      const emission = values.emission;
-      const transparency = values.transparency;
-
-      // These actually exist on the extension object, not the values object despite what's shown in the spec
-      const doubleSided = materialsCommon.doubleSided;
-      const transparent = materialsCommon.transparent;
-
-      // Ignore specular and shininess for now because the conversion to PBR
-      // isn't straightforward and depends on the technique
-      initializePbrMaterial(material);
-
-      if (defined(ambient)) {
-        if (isVec4(ambient)) {
-          material.emissiveFactor = ambient.slice(0, 3);
-        } else if (isTexture(ambient)) {
-          material.emissiveTexture = ambient;
-        }
-      }
-
-      if (defined(diffuse)) {
-        if (isVec4(diffuse)) {
-          material.pbrMetallicRoughness.baseColorFactor = srgbToLinear(diffuse);
-        } else if (isTexture(diffuse)) {
-          material.pbrMetallicRoughness.baseColorTexture = diffuse;
-        }
-      }
-
-      if (defined(doubleSided)) {
-        material.doubleSided = doubleSided;
-      }
-
-      if (defined(emission)) {
-        if (isVec4(emission)) {
-          material.emissiveFactor = emission.slice(0, 3);
-        } else if (isTexture(emission)) {
-          material.emissiveTexture = emission;
-        }
-      }
-
-      if (defined(transparency)) {
-        if (defined(material.pbrMetallicRoughness.baseColorFactor)) {
-          material.pbrMetallicRoughness.baseColorFactor[3] *= transparency;
-        } else {
-          material.pbrMetallicRoughness.baseColorFactor = [
-            1,
-            1,
-            1,
-            transparency,
-          ];
-        }
-      }
+      // The CONSTANT technique does not support 'diffuse', so
+      // assign either the 'emission' or the 'ambient' as the
+      // base color
+      assignAsBaseColor(material, emission);
+      assignAsBaseColor(material, ambient);
+    } else {
+      // Assign the 'diffuse' as the base color, and
+      // the 'ambient' or 'emissive' as the emissive
+      // part if they are present.
+      assignAsBaseColor(material, diffuse);
+      assignAsEmissive(material, ambient);
+      assignAsEmissive(material, emission);
+    }
 
-      if (defined(transparent)) {
-        material.alphaMode = transparent ? "BLEND" : "OPAQUE";
+    if (defined(doubleSided)) {
+      material.doubleSided = doubleSided;
+    }
+    if (defined(transparency)) {
+      if (defined(material.pbrMetallicRoughness.baseColorFactor)) {
+        material.pbrMetallicRoughness.baseColorFactor[3] *= transparency;
+      } else {
+        material.pbrMetallicRoughness.baseColorFactor = [1, 1, 1, transparency];
       }
     }
+    if (defined(transparent)) {
+      material.alphaMode = transparent ? "BLEND" : "OPAQUE";
+    }
   });
 
   removeExtension(gltf, "KHR_materials_common");

package/Source/Scene/I3SDataProvider.js

@@ -57,6 +57,8 @@ import Resource from "../Core/Resource.js";
 import RuntimeError from "../Core/RuntimeError.js";
 import WebMercatorProjection from "../Core/WebMercatorProjection.js";
 import I3SLayer from "./I3SLayer.js";
+import I3SStatistics from "./I3SStatistics.js";
+import I3SSublayer from "./I3SSublayer.js";
 import Lerc from "lerc";
 import Rectangle from "../Core/Rectangle.js";
 
@@ -68,8 +70,30 @@ import Rectangle from "../Core/Rectangle.js";
  * @property {string} [name] The name of the I3S dataset.
  * @property {boolean} [show=true] Determines if the dataset will be shown.
  * @property {ArcGISTiledElevationTerrainProvider|Promise<ArcGISTiledElevationTerrainProvider>} [geoidTiledTerrainProvider] Tiled elevation provider describing an Earth Gravitational Model. If defined, geometry will be shifted based on the offsets given by this provider. Required to position I3S data sets with gravity-related height at the correct location.
- * @property {boolean} [traceFetches=false] Debug option. When true, log a message whenever an I3S tile is fetched.
  * @property {Cesium3DTileset.ConstructorOptions} [cesium3dTilesetOptions] Object containing options to pass to an internally created {@link Cesium3DTileset}. See {@link Cesium3DTileset} for list of valid properties. All options can be used with the exception of <code>url</code> and <code>show</code> which are overridden by values from I3SDataProvider.
+ * @property {boolean} [showFeatures=false] Determines if the features will be shown.
+ * @property {boolean} [adjustMaterialAlphaMode=false] The option to adjust the alpha mode of the material based on the transparency of the vertex color. When <code>true</code>, the alpha mode of the material (if not defined) will be set to BLEND for geometry with any transparency in the color vertex attribute.
+ * @property {boolean} [applySymbology=false] Determines if the I3S symbology will be parsed and applied for the layers.
+ * @property {boolean} [calculateNormals=false] Determines if the flat normals will be generated for I3S geometry without normals.
+ *
+ * @example
+ * // Increase LOD by reducing SSE
+ * const cesium3dTilesetOptions = {
+ *   maximumScreenSpaceError: 1,
+ * };
+ * const i3sOptions = {
+ *   cesium3dTilesetOptions: cesium3dTilesetOptions,
+ * };
+ *
+ * @example
+ * // Set a custom outline color to replace the color defined in I3S symbology
+ * const cesium3dTilesetOptions = {
+ *   outlineColor: Cesium.Color.BLUE,
+ * };
+ * const i3sOptions = {
+ *   cesium3dTilesetOptions: cesium3dTilesetOptions,
+ *   applySymbology: true,
+ * };
  */
 
 /**
@@ -122,7 +146,13 @@ function I3SDataProvider(options) {
   this._name = options.name;
   this._show = defaultValue(options.show, true);
   this._geoidTiledTerrainProvider = options.geoidTiledTerrainProvider;
-  this._traceFetches = defaultValue(options.traceFetches, false);
+  this._showFeatures = defaultValue(options.showFeatures, false);
+  this._adjustMaterialAlphaMode = defaultValue(
+    options.adjustMaterialAlphaMode,
+    false
+  );
+  this._applySymbology = defaultValue(options.applySymbology, false);
+  this._calculateNormals = defaultValue(options.calculateNormals, false);
 
   this._cesium3dTilesetOptions = defaultValue(
     options.cesium3dTilesetOptions,
@@ -130,12 +160,15 @@ function I3SDataProvider(options) {
   );
 
   this._layers = [];
+  this._sublayers = [];
   this._data = undefined;
   this._extent = undefined;
   this._geoidDataPromise = undefined;
   this._geoidDataList = undefined;
   this._decoderTaskProcessor = undefined;
   this._taskProcessorReadyPromise = undefined;
+  this._attributeStatistics = [];
+  this._layersExtent = [];
 }
 
 Object.defineProperties(I3SDataProvider.prototype, {
@@ -165,33 +198,15 @@ Object.defineProperties(I3SDataProvider.prototype, {
       Check.defined("value", value);
       //>>includeEnd('debug');
 
-      this._show = value;
-      for (let i = 0; i < this._layers.length; i++) {
-        if (defined(this._layers[i]._tileset)) {
-          this._layers[i]._tileset.show = this._show;
+      if (this._show !== value) {
+        this._show = value;
+        for (let i = 0; i < this._layers.length; i++) {
+          this._layers[i]._updateVisibility();
         }
       }
     },
   },
 
-  /**
-   * Gets or sets debugging and tracing of I3S fetches.
-   * @memberof I3SDataProvider.prototype
-   * @type {boolean}
-   */
-  traceFetches: {
-    get: function () {
-      return this._traceFetches;
-    },
-    set: function (value) {
-      //>>includeStart('debug', pragmas.debug);
-      Check.defined("value", value);
-      //>>includeEnd('debug');
-
-      this._traceFetches = value;
-    },
-  },
-
   /**
    * The terrain provider referencing the GEOID service to be used for orthometric to ellipsoidal conversion.
    * @memberof I3SDataProvider.prototype
@@ -216,6 +231,18 @@ Object.defineProperties(I3SDataProvider.prototype, {
     },
   },
 
+  /**
+   * Gets the collection of building sublayers.
+   * @memberof I3SDataProvider.prototype
+   * @type {I3SSublayer[]}
+   * @readonly
+   */
+  sublayers: {
+    get: function () {
+      return this._sublayers;
+    },
+  },
+
   /**
    * Gets the I3S data for this object.
    * @memberof I3SDataProvider.prototype
@@ -251,6 +278,54 @@ Object.defineProperties(I3SDataProvider.prototype, {
       return this._resource;
     },
   },
+
+  /**
+   * Determines if the features will be shown.
+   * @memberof I3SDataProvider.prototype
+   * @type {boolean}
+   * @readonly
+   */
+  showFeatures: {
+    get: function () {
+      return this._showFeatures;
+    },
+  },
+
+  /**
+   * Determines if the alpha mode of the material will be adjusted depending on the color vertex attribute.
+   * @memberof I3SDataProvider.prototype
+   * @type {boolean}
+   * @readonly
+   */
+  adjustMaterialAlphaMode: {
+    get: function () {
+      return this._adjustMaterialAlphaMode;
+    },
+  },
+
+  /**
+   * Determines if the I3S symbology will be parsed and applied for the layers.
+   * @memberof I3SDataProvider.prototype
+   * @type {boolean}
+   * @readonly
+   */
+  applySymbology: {
+    get: function () {
+      return this._applySymbology;
+    },
+  },
+
+  /**
+   * Determines if the flat normals will be generated for I3S geometry without normals.
+   * @memberof I3SDataProvider.prototype
+   * @type {boolean}
+   * @readonly
+   */
+  calculateNormals: {
+    get: function () {
+      return this._calculateNormals;
+    },
+  },
 });
 
 /**
@@ -335,6 +410,101 @@ I3SDataProvider.prototype.updateForPass = function (frameState, passState) {
   }
 };
 
+function buildLayerUrl(provider, layerId) {
+  const dataProviderUrl = provider.resource.getUrlComponent();
+
+  let layerUrl = "";
+  if (dataProviderUrl.match(/layers\/\d/)) {
+    layerUrl = `${dataProviderUrl}`.replace(/\/+$/, "");
+  } else {
+    // Add '/' to url if needed + `$layers/${layerId}/` if tilesetUrl not already in ../layers/[id] format
+    layerUrl = `${dataProviderUrl}`
+      .replace(/\/?$/, "/")
+      .concat(`layers/${layerId}`);
+  }
+  return layerUrl;
+}
+
+async function addLayers(provider, data, options) {
+  if (data.layerType === "Building") {
+    if (!defined(options.showFeatures)) {
+      // The Building Scene Layer requires features to be shown to support filtering
+      provider._showFeatures = true;
+    }
+    if (!defined(options.adjustMaterialAlphaMode)) {
+      // The Building Scene Layer enables transparency by default
+      provider._adjustMaterialAlphaMode = true;
+    }
+    if (!defined(options.applySymbology)) {
+      // The Building Scene Layer applies symbology by default
+      provider._applySymbology = true;
+    }
+    if (!defined(options.calculateNormals)) {
+      // The Building Scene Layer calculates flat normals by default
+      provider._calculateNormals = true;
+    }
+
+    const buildingLayerUrl = buildLayerUrl(provider, data.id);
+    if (defined(data.sublayers)) {
+      const promises = [];
+      for (let i = 0; i < data.sublayers.length; i++) {
+        const promise = I3SSublayer._fromData(
+          provider,
+          buildingLayerUrl,
+          data.sublayers[i],
+          provider
+        );
+        promises.push(promise);
+      }
+      const sublayers = await Promise.all(promises);
+      for (let i = 0; i < sublayers.length; i++) {
+        const sublayer = sublayers[i];
+        provider._sublayers.push(sublayer);
+        provider._layers.push(...sublayer._i3sLayers);
+      }
+    }
+
+    if (defined(data.statisticsHRef)) {
+      const uri = buildingLayerUrl.concat(`/${data.statisticsHRef}`);
+      const statistics = new I3SStatistics(provider, uri);
+      await statistics.load();
+      provider._attributeStatistics.push(statistics);
+    }
+
+    if (defined(data.fullExtent)) {
+      const extent = Rectangle.fromDegrees(
+        data.fullExtent.xmin,
+        data.fullExtent.ymin,
+        data.fullExtent.xmax,
+        data.fullExtent.ymax
+      );
+      provider._layersExtent.push(extent);
+    }
+  } else if (
+    data.layerType === "3DObject" ||
+    data.layerType === "IntegratedMesh"
+  ) {
+    if (
+      !defined(options.calculateNormals) &&
+      !defined(data.textureSetDefinitions)
+    ) {
+      // I3S Layers without textures should calculate flat normals by default
+      provider._calculateNormals = true;
+    }
+
+    const newLayer = new I3SLayer(provider, data, provider);
+    provider._layers.push(newLayer);
+    if (defined(newLayer._extent)) {
+      provider._layersExtent.push(newLayer._extent);
+    }
+  } else {
+    // Filter other scene layer types out
+    console.log(
+      `${data.layerType} layer ${data.name} is skipped as not supported.`
+    );
+  }
+}
+
 /**
  * Creates an I3SDataProvider. Currently supported I3S versions are 1.6 and
  * 1.7/1.8 (OGC I3S 1.2).
@@ -375,6 +545,8 @@ I3SDataProvider.fromUrl = async function (url, options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
 
   const resource = Resource.createIfNeeded(url);
+  // Set a query parameter for json to avoid failure on html pages
+  resource.setQueryParameters({ f: "pjson" }, true);
   const data = await I3SDataProvider.loadJson(resource);
 
   const provider = new I3SDataProvider(options);
@@ -383,17 +555,14 @@ I3SDataProvider.fromUrl = async function (url, options) {
 
   // Success
   if (defined(data.layers)) {
+    const promises = [];
     for (let layerIndex = 0; layerIndex < data.layers.length; layerIndex++) {
-      const newLayer = new I3SLayer(
-        provider,
-        data.layers[layerIndex],
-        layerIndex
-      );
-      provider._layers.push(newLayer);
+      const promise = addLayers(provider, data.layers[layerIndex], options);
+      promises.push(promise);
     }
+    await Promise.all(promises);
   } else {
-    const newLayer = new I3SLayer(provider, data, data.id);
-    provider._layers.push(newLayer);
+    await addLayers(provider, data, options);
   }
 
   provider._computeExtent();
@@ -421,14 +590,9 @@ I3SDataProvider._fetchJson = function (resource) {
  * @private
  *
  * @param {Resource} resource The JSON resource to request
- * @param {boolean} [trace=false] Log the resource
  * @returns {Promise<object>} The fetched data
  */
-I3SDataProvider.loadJson = async function (resource, trace) {
-  if (trace) {
-    console.log("I3S FETCH:", resource.url);
-  }
-
+I3SDataProvider.loadJson = async function (resource) {
   const data = await I3SDataProvider._fetchJson(resource);
   if (defined(data.error)) {
     console.error("Failed to fetch I3S ", resource.url);
@@ -450,11 +614,20 @@ I3SDataProvider.loadJson = async function (resource, trace) {
 /**
  * @private
  */
-I3SDataProvider.prototype._loadBinary = function (resource) {
-  if (this._traceFetches) {
-    console.log("I3S FETCH:", resource.url);
+I3SDataProvider.prototype._loadBinary = async function (resource) {
+  const buffer = await resource.fetchArrayBuffer();
+  if (buffer.byteLength > 0) {
+    // Check if we have a JSON response with 404
+    const array = new Uint8Array(buffer);
+    if (array[0] === "{".charCodeAt(0)) {
+      const textContent = new TextDecoder();
+      const str = textContent.decode(buffer);
+      if (str.includes("404")) {
+        throw new RuntimeError(`Failed to load binary: ${resource.url}`);
+      }
+    }
   }
-  return resource.fetchArrayBuffer();
+  return buffer;
 };
 
 /**
@@ -593,9 +766,6 @@ async function loadGeoidData(provider) {
   const geoidTerrainProvider = provider._geoidTiledTerrainProvider;
 
   if (!defined(geoidTerrainProvider)) {
-    console.log(
-      "No Geoid Terrain service provided - no geoid conversion will be performed."
-    );
     return;
   }
 
@@ -631,18 +801,65 @@ I3SDataProvider.prototype._computeExtent = function () {
   let rectangle;
 
   // Compute the extent from all layers
-  for (let layerIndex = 0; layerIndex < this._layers.length; layerIndex++) {
-    if (defined(this._layers[layerIndex]._extent)) {
-      const layerExtent = this._layers[layerIndex]._extent;
-      if (!defined(rectangle)) {
-        rectangle = Rectangle.clone(layerExtent);
-      } else {
-        Rectangle.union(rectangle, layerExtent, rectangle);
-      }
+  for (
+    let layerIndex = 0;
+    layerIndex < this._layersExtent.length;
+    layerIndex++
+  ) {
+    const layerExtent = this._layersExtent[layerIndex];
+    if (!defined(rectangle)) {
+      rectangle = Rectangle.clone(layerExtent);
+    } else {
+      Rectangle.union(rectangle, layerExtent, rectangle);
     }
   }
 
   this._extent = rectangle;
 };
 
+/**
+ * Returns the collection of names for all available attributes
+ * @returns {string[]} The collection of attribute names
+ */
+I3SDataProvider.prototype.getAttributeNames = function () {
+  const attributes = [];
+  for (let i = 0; i < this._attributeStatistics.length; ++i) {
+    attributes.push(...this._attributeStatistics[i].names);
+  }
+  return attributes;
+};
+
+/**
+ * Returns the collection of values for the attribute with the given name
+ * @param {string} name The attribute name
+ * @returns {string[]} The collection of attribute values
+ */
+I3SDataProvider.prototype.getAttributeValues = function (name) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.defined("name", name);
+  //>>includeEnd('debug');
+
+  for (let i = 0; i < this._attributeStatistics.length; ++i) {
+    const values = this._attributeStatistics[i]._getValues(name);
+    if (defined(values)) {
+      return values;
+    }
+  }
+  return [];
+};
+
+/**
+ * Filters the drawn elements of a scene to specific attribute names and values
+ * @param {I3SNode.AttributeFilter[]} [filters=[]] The collection of attribute filters
+ * @returns {Promise<void>} A promise that is resolved when the filter is applied
+ */
+I3SDataProvider.prototype.filterByAttributes = function (filters) {
+  const promises = [];
+  for (let i = 0; i < this._layers.length; i++) {
+    const promise = this._layers[i].filterByAttributes(filters);
+    promises.push(promise);
+  }
+  return Promise.all(promises);
+};
+
 export default I3SDataProvider;