@cesium/engine 7.0.0 → 9.0.0

package/Source/Scene/I3SDecoder.js

@@ -45,6 +45,7 @@ async function initializeDecoder() {
  * @param {Object} defaultGeometrySchema Schema to use during decoding
  * @param {I3SGeometry} geometryData The draco encoded geometry data
  * @param {Array} [featureData] The draco encoded feature data
+ * @param {Object} [symbologyData] The rendering symbology to apply
  * @returns Promise<undefined|object> Returns a promise which resolves to the glTF result, or undefined if the task cannot be scheduled this frame.
  *
  * @exception {RuntimeError} I3S decoder could not be initialized.
@@ -53,7 +54,8 @@ I3SDecoder.decode = async function (
   url,
   defaultGeometrySchema,
   geometryData,
-  featureData
+  featureData,
+  symbologyData
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.string("url", url);
@@ -118,6 +120,11 @@ I3SDecoder.decode = async function (
       cartographicCenter: cartographicCenter,
       cartesianCenter: cartesianCenter,
       parentRotation: parentRotation,
+      enableFeatures: geometryData._dataProvider.showFeatures,
+      splitGeometryByColorTransparency:
+        geometryData._dataProvider.adjustMaterialAlphaMode,
+      symbologyData: symbologyData,
+      calculateNormals: geometryData._dataProvider.calculateNormals,
     };
 
     return taskProcessor.scheduleTask(payload);

package/Source/Scene/I3SFeature.js

@@ -50,14 +50,11 @@ Object.defineProperties(I3SFeature.prototype, {
 
 /**
  * Loads the content.
- * @returns {Promise} A promise that is resolved when the data of the I3S feature is loaded
+ * @returns {Promise<object>} A promise that is resolved when the data of the I3S feature is loaded
  * @private
  */
 I3SFeature.prototype.load = async function () {
-  this._data = await I3SDataProvider.loadJson(
-    this._resource,
-    this._dataProvider._traceFetches
-  );
+  this._data = await I3SDataProvider.loadJson(this._resource);
   return this._data;
 };
 

package/Source/Scene/I3SField.js

@@ -1,4 +1,5 @@
 import defined from "../Core/defined.js";
+import RuntimeError from "../Core/RuntimeError.js";
 
 /**
  * This class implements an I3S Field which is custom data attached
@@ -12,6 +13,7 @@ function I3SField(parent, storageInfo) {
   this._storageInfo = storageInfo;
   this._parent = parent;
   this._dataProvider = parent._dataProvider;
+  this._loadPromise = undefined;
   const uri = `attributes/${storageInfo.key}/0`;
 
   if (defined(this._parent._nodeIndex)) {
@@ -54,9 +56,16 @@ Object.defineProperties(I3SField.prototype, {
    */
   values: {
     get: function () {
-      return defined(this._values) && defined(this._values.attributeValues)
-        ? this._values.attributeValues
-        : [];
+      if (defined(this._values)) {
+        // attribute data can be stored either as values or as object identifiers
+        if (defined(this._values.attributeValues)) {
+          return this._values.attributeValues;
+        }
+        if (defined(this._values.objectIds)) {
+          return this._values.objectIds;
+        }
+      }
+      return [];
     },
   },
   /**
@@ -92,40 +101,37 @@ function getNumericTypeSize(type) {
   return 0;
 }
 
+function getValueTypeSize(type) {
+  if (type === "String") {
+    return 1;
+  }
+  return getNumericTypeSize(type);
+}
+
+async function load(field) {
+  const data = await field._dataProvider._loadBinary(field._resource);
+  const dataView = new DataView(data);
+  field._data = data;
+  field._validateHeader(dataView);
+  const headerSize = field._parseHeader(dataView);
+  const offset = field._getBodyOffset(headerSize);
+  field._validateBody(dataView, offset);
+  field._parseBody(dataView, offset);
+}
+
 /**
  * Loads the content.
  * @returns {Promise<void>} A promise that is resolved when the field data is loaded
  */
 I3SField.prototype.load = function () {
-  const that = this;
-  return this._dataProvider._loadBinary(this._resource).then(function (data) {
-    // Check if we have a 404
-    const dataView = new DataView(data);
-    let success = true;
-    if (dataView.getUint8(0) === "{".charCodeAt(0)) {
-      const textContent = new TextDecoder();
-      const str = textContent.decode(data);
-      if (str.includes("404")) {
-        success = false;
-        console.error(`Failed to load: ${that.resource.url}`);
-      }
-    }
-
-    if (success) {
-      that._data = data;
-      let offset = that._parseHeader(dataView);
-
-      const valueSize = getNumericTypeSize(
-        that._storageInfo.attributeValues.valueType
-      );
-      if (valueSize > 0) {
-        // Values will be padded to align the addresses with the data size
-        offset = Math.ceil(offset / valueSize) * valueSize;
-      }
+  if (defined(this._loadPromise)) {
+    return this._loadPromise;
+  }
 
-      that._parseBody(dataView, offset);
-    }
+  this._loadPromise = load(this).catch(function (error) {
+    console.error(error);
   });
+  return this._loadPromise;
 };
 
 /**
@@ -217,7 +223,9 @@ I3SField.prototype._parseBody = function (dataView, offset) {
     itemIndex < this._storageInfo.ordering.length;
     itemIndex++
   ) {
-    const item = this._storageInfo.ordering[itemIndex];
+    const orderingValue = this._storageInfo.ordering[itemIndex];
+    // all strings in the ordering array correspond to the property name, except ObjectIds
+    const item = orderingValue === "ObjectIds" ? "objectIds" : orderingValue;
     const desc = this._storageInfo[item];
     if (defined(desc)) {
       this._values[item] = [];
@@ -252,4 +260,101 @@ I3SField.prototype._parseBody = function (dataView, offset) {
   }
 };
 
+/**
+ * @private
+ */
+I3SField.prototype._getBodyOffset = function (headerSize) {
+  let valueSize = 0;
+  if (defined(this._storageInfo.attributeValues)) {
+    valueSize = getNumericTypeSize(this._storageInfo.attributeValues.valueType);
+  } else if (defined(this._storageInfo.objectIds)) {
+    valueSize = getNumericTypeSize(this._storageInfo.objectIds.valueType);
+  }
+  if (valueSize > 0) {
+    // Values will be padded to align the addresses with the data size
+    return Math.ceil(headerSize / valueSize) * valueSize;
+  }
+  return headerSize;
+};
+
+/**
+ * @private
+ */
+I3SField.prototype._validateHeader = function (dataView) {
+  let headerSize = 0;
+  for (
+    let itemIndex = 0;
+    itemIndex < this._storageInfo.header.length;
+    itemIndex++
+  ) {
+    const item = this._storageInfo.header[itemIndex];
+    headerSize += getValueTypeSize(item.valueType);
+  }
+  if (dataView.byteLength < headerSize) {
+    throw new RuntimeError(
+      `Invalid attribute buffer size (field: ${this.name}, header: ${headerSize}, actual: ${dataView.byteLength})`
+    );
+  }
+};
+
+/**
+ * @private
+ */
+I3SField.prototype._validateBody = function (dataView, offset) {
+  if (!defined(this._header.count)) {
+    throw new RuntimeError(
+      `Invalid attribute buffer (field: ${this.name}, count is missing)`
+    );
+  }
+  let attributeByteCountsOffset;
+  for (
+    let itemIndex = 0;
+    itemIndex < this._storageInfo.ordering.length &&
+    offset < dataView.byteLength;
+    itemIndex++
+  ) {
+    const orderingValue = this._storageInfo.ordering[itemIndex];
+    // all strings in the ordering array correspond to the property name, except ObjectIds
+    const item = orderingValue === "ObjectIds" ? "objectIds" : orderingValue;
+    const desc = this._storageInfo[item];
+    if (defined(desc)) {
+      if (desc.valueType !== "String") {
+        if (item === "attributeByteCounts") {
+          attributeByteCountsOffset = offset;
+        }
+        const valueSize = getNumericTypeSize(desc.valueType);
+        offset += valueSize * this._header.count;
+      } else {
+        if (!defined(attributeByteCountsOffset)) {
+          throw new RuntimeError(
+            `Invalid attribute buffer (field: ${this.name}, attributeByteCounts is missing)`
+          );
+        }
+        for (
+          let index = 0;
+          index < this._header.count && offset < dataView.byteLength;
+          ++index
+        ) {
+          const parsedValue = this._parseValue(
+            dataView,
+            this._storageInfo.attributeByteCounts.valueType,
+            attributeByteCountsOffset
+          );
+          offset += parsedValue.value;
+          attributeByteCountsOffset = parsedValue.offset;
+        }
+      }
+    } else {
+      throw new RuntimeError(
+        `Invalid attribute buffer (field: ${this.name}, ${item} is missing)`
+      );
+    }
+  }
+  if (dataView.byteLength < offset) {
+    throw new RuntimeError(
+      `Invalid attribute buffer size (field: ${this.name}, expected: ${offset}, actual: ${dataView.byteLength})`
+    );
+  }
+};
+
 export default I3SField;

package/Source/Scene/I3SGeometry.js

@@ -1,6 +1,8 @@
 import Cartesian3 from "../Core/Cartesian3.js";
+import clone from "../Core/clone.js";
 import defined from "../Core/defined.js";
 import Matrix3 from "../Core/Matrix3.js";
+import srgbToLinear from "../Core/srgbToLinear.js";
 
 /**
  * This class implements an I3S Geometry. Each I3SGeometry
@@ -267,6 +269,19 @@ I3SGeometry.prototype.getClosestPointIndexOnTriangle = function (px, py, pz) {
   };
 };
 
+function convertColorFactor(factor) {
+  const convertedFactor = [];
+  const length = factor.length;
+  for (let i = 0; i < length; i++) {
+    if (i < 3) {
+      convertedFactor.push(srgbToLinear(factor[i]));
+    } else {
+      convertedFactor.push(factor[i]);
+    }
+  }
+  return convertedFactor;
+}
+
 /**
  * @private
  */
@@ -276,7 +291,9 @@ I3SGeometry.prototype._generateGltf = function (
   meshes,
   buffers,
   bufferViews,
-  accessors
+  accessors,
+  extensions,
+  extensionsUsed
 ) {
   // Get the material definition
   let gltfMaterial = {
@@ -344,6 +361,21 @@ I3SGeometry.prototype._generateGltf = function (
           }).url;
         }
       }
+
+      // Convert color factors from sRGB to linear color space
+      if (
+        defined(gltfMaterial.pbrMetallicRoughness) &&
+        defined(gltfMaterial.pbrMetallicRoughness.baseColorFactor)
+      ) {
+        gltfMaterial.pbrMetallicRoughness.baseColorFactor = convertColorFactor(
+          gltfMaterial.pbrMetallicRoughness.baseColorFactor
+        );
+      }
+      if (defined(gltfMaterial.emissiveFactor)) {
+        gltfMaterial.emissiveFactor = convertColorFactor(
+          gltfMaterial.emissiveFactor
+        );
+      }
     }
   } else if (defined(this._parent._data.textureData)) {
     // No material definition, but if there's a texture reference, we can create a simple material using it (version 1.6 support)
@@ -353,6 +385,10 @@ I3SGeometry.prototype._generateGltf = function (
     }).url;
     gltfMaterial.pbrMetallicRoughness.baseColorTexture = { index: 0 };
   }
+  if (defined(gltfMaterial.alphaMode)) {
+    // I3S specifies alphaMode values in lowercase, but glTF expects values in uppercase
+    gltfMaterial.alphaMode = gltfMaterial.alphaMode.toUpperCase();
+  }
 
   let gltfTextures = [];
   let gltfImages = [];
@@ -382,6 +418,36 @@ I3SGeometry.prototype._generateGltf = function (
     ];
   }
 
+  const gltfMaterials = [];
+  const meshesLength = meshes.length;
+  for (let meshIndex = 0; meshIndex < meshesLength; meshIndex++) {
+    const primitives = meshes[meshIndex].primitives;
+    const primitivesLength = primitives.length;
+    for (
+      let primitiveIndex = 0;
+      primitiveIndex < primitivesLength;
+      primitiveIndex++
+    ) {
+      const primitive = primitives[primitiveIndex];
+      if (defined(primitive.material)) {
+        // Create as many copies of the material as specified in the mesh primitives
+        while (primitive.material >= gltfMaterials.length) {
+          const material = clone(gltfMaterial, true);
+          gltfMaterials.push(material);
+        }
+        const primitiveMaterial = gltfMaterials[primitive.material];
+        if (defined(primitive.extra) && primitive.extra.isTransparent) {
+          // If the alpha mode is not specified in the original material but the geometry is transparent, we need to force set BLEND alpha mode. Otherwise the geometry will be rendered opaque.
+          if (!defined(primitiveMaterial.alphaMode)) {
+            primitiveMaterial.alphaMode = "BLEND";
+          }
+        } else if (primitiveMaterial.alphaMode === "BLEND") {
+          // If the geometry is not transparent, but the alpha mode is set to BLEND in the original material, we need to force set OPAQUE alpha mode. Otherwise the geometry will be rendered transparent.
+          primitiveMaterial.alphaMode = "OPAQUE";
+        }
+      }
+    }
+  }
   const gltfData = {
     scene: 0,
     scenes: [
@@ -394,13 +460,15 @@ I3SGeometry.prototype._generateGltf = function (
     buffers: buffers,
     bufferViews: bufferViews,
     accessors: accessors,
-    materials: [gltfMaterial],
+    materials: gltfMaterials,
     textures: gltfTextures,
     images: gltfImages,
     samplers: gltfSamplers,
     asset: {
       version: "2.0",
     },
+    extensions: extensions,
+    extensionsUsed: extensionsUsed,
   };
 
   return gltfData;

package/Source/Scene/I3SLayer.js

@@ -1,9 +1,13 @@
+import Cartesian4 from "../Core/Cartesian4.js";
+import clone from "../Core/clone.js";
+import Color from "../Core/Color.js";
 import defined from "../Core/defined.js";
 import Rectangle from "../Core/Rectangle.js";
 import Resource from "../Core/Resource.js";
 import RuntimeError from "../Core/RuntimeError.js";
 import Cesium3DTileset from "./Cesium3DTileset.js";
 import I3SNode from "./I3SNode.js";
+import I3SSymbology from "./I3SSymbology.js";
 
 /**
  * This class implements an I3S layer. In CesiumJS each I3SLayer creates a Cesium3DTileset.
@@ -14,24 +18,25 @@ import I3SNode from "./I3SNode.js";
  * @internalConstructor
  * @privateParam {I3SDataProvider} dataProvider The i3s data provider
  * @privateParam {object} layerData The layer data that is loaded from the scene layer
- * @privateParam {number} index The index of the layer to be reflected
+ * @privateParam {I3SDataProvider|I3SSublayer} parent The parent of that layer
  */
-function I3SLayer(dataProvider, layerData, index) {
+function I3SLayer(dataProvider, layerData, parent) {
   this._dataProvider = dataProvider;
+  this._parent = parent;
 
-  if (!defined(layerData.href) && defined(index)) {
+  if (!defined(layerData.href) && defined(layerData.id)) {
     // assign a default layer
-    layerData.href = `layers/${index}`;
+    layerData.href = `layers/${layerData.id}`;
   }
 
-  const dataProviderUrl = this._dataProvider.resource.getUrlComponent();
+  const parentUrl = this._parent.resource.getUrlComponent();
 
   let tilesetUrl = "";
-  if (dataProviderUrl.match(/layers\/\d/)) {
-    tilesetUrl = `${dataProviderUrl}`.replace(/\/+$/, "");
+  if (parentUrl.match(/layers\/\d/)) {
+    tilesetUrl = `${parentUrl}`.replace(/\/+$/, "");
   } else {
     // Add '/' to url if needed + `${layerData.href}` if tilesetUrl not already in ../layers/[id] format
-    tilesetUrl = `${dataProviderUrl}`
+    tilesetUrl = `${parentUrl}`
       .replace(/\/?$/, "/")
       .concat(`${layerData.href}`);
   }
@@ -53,6 +58,8 @@ function I3SLayer(dataProvider, layerData, index) {
   this._extent = undefined;
   this._tileset = undefined;
   this._geometryDefinitions = undefined;
+  this._filters = [];
+  this._symbology = undefined;
 
   this._computeGeometryDefinitions(true);
   this._computeExtent();
@@ -166,7 +173,7 @@ Object.defineProperties(I3SLayer.prototype, {
 /**
  * Loads the content, including the root node definition and its children
  * @param {Cesium3DTileset.ConstructorOptions} [cesium3dTilesetOptions] options for Cesium3dTileset constructor
- * @returns {Promise} A promise that is resolved when the layer data is loaded
+ * @returns {Promise<void>} A promise that is resolved when the layer data is loaded
  * @private
  */
 I3SLayer.prototype.load = async function (cesium3dTilesetOptions) {
@@ -176,6 +183,9 @@ I3SLayer.prototype.load = async function (cesium3dTilesetOptions) {
     );
   }
 
+  if (this._dataProvider.applySymbology) {
+    this._symbology = new I3SSymbology(this);
+  }
   await this._dataProvider.loadGeoidData();
   await this._loadRootNode(cesium3dTilesetOptions);
   await this._create3DTileset(cesium3dTilesetOptions);
@@ -387,11 +397,20 @@ I3SLayer.prototype._create3DTileset = async function (cesium3dTilesetOptions) {
   });
 
   const tilesetUrl = URL.createObjectURL(tilesetBlob);
+  const outlineColor = this._symbology?.defaultSymbology?.edges?.color;
+  if (defined(outlineColor) && !defined(cesium3dTilesetOptions?.outlineColor)) {
+    cesium3dTilesetOptions = defined(cesium3dTilesetOptions)
+      ? clone(cesium3dTilesetOptions)
+      : {};
+    cesium3dTilesetOptions.outlineColor = Color.fromCartesian4(
+      Cartesian4.fromArray(outlineColor)
+    );
+  }
   this._tileset = await Cesium3DTileset.fromUrl(
     tilesetUrl,
     cesium3dTilesetOptions
   );
-  this._tileset.show = this._dataProvider.show;
+  this._tileset.show = this._parent.show;
   this._tileset._isI3STileSet = true;
   this._tileset.tileUnload.addEventListener(function (tile) {
     tile._i3sNode._clearGeometryData();
@@ -406,4 +425,30 @@ I3SLayer.prototype._create3DTileset = async function (cesium3dTilesetOptions) {
   });
 };
 
+/**
+ * @private
+ */
+I3SLayer.prototype._updateVisibility = function () {
+  if (defined(this._tileset)) {
+    this._tileset.show = this._parent.show;
+  }
+};
+
+/**
+ * Filters the drawn elements of a layer 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
+ */
+I3SLayer.prototype.filterByAttributes = function (filters) {
+  // Filters are applied for each node in the layer when the node model is loaded
+  this._filters = defined(filters) ? clone(filters, true) : [];
+
+  // Forced filtering is required for loaded nodes only
+  const rootNode = this._rootNode;
+  if (defined(rootNode)) {
+    return rootNode._filterFeatures();
+  }
+  return Promise.resolve();
+};
+
 export default I3SLayer;