@cesium/engine 7.0.0 → 8.0.0

package/Source/Scene/I3SSublayer.js

@@ -0,0 +1,176 @@
+import Check from "../Core/Check.js";
+import defaultValue from "../Core/defaultValue.js";
+import defined from "../Core/defined.js";
+import I3SDataProvider from "./I3SDataProvider.js";
+import I3SLayer from "./I3SLayer.js";
+import Resource from "../Core/Resource.js";
+
+/**
+ * This class implements an I3S sublayer for Building Scene Layer.
+ * <p>
+ * This object is normally not instantiated directly, use {@link I3SSublayer.fromData}.
+ * </p>
+ * @alias I3SSublayer
+ * @internalConstructor
+ */
+function I3SSublayer(dataProvider, parent, sublayerData) {
+  this._dataProvider = dataProvider;
+  this._parent = parent;
+  this._data = sublayerData;
+  this._name = sublayerData.name;
+  this._modelName = sublayerData.modelName;
+  this._visibility = defaultValue(sublayerData.visibility, true);
+  this._resource = undefined;
+  this._sublayers = [];
+  this._i3sLayers = [];
+}
+
+Object.defineProperties(I3SSublayer.prototype, {
+  /**
+   * Gets the resource for the sublayer
+   * @memberof I3SSublayer.prototype
+   * @type {Resource}
+   * @readonly
+   */
+  resource: {
+    get: function () {
+      return this._resource;
+    },
+  },
+
+  /**
+   * Gets the I3S data for this object.
+   * @memberof I3SSublayer.prototype
+   * @type {object}
+   * @readonly
+   */
+  data: {
+    get: function () {
+      return this._data;
+    },
+  },
+
+  /**
+   * Gets the name for the sublayer.
+   * @memberof I3SSublayer.prototype
+   * @type {string}
+   * @readonly
+   */
+  name: {
+    get: function () {
+      return this._name;
+    },
+  },
+
+  /**
+   * Gets the model name for the sublayer.
+   * @memberof I3SSublayer.prototype
+   * @type {string}
+   * @readonly
+   */
+  modelName: {
+    get: function () {
+      return this._modelName;
+    },
+  },
+
+  /**
+   * Gets the collection of child sublayers.
+   * @memberof I3SSublayer.prototype
+   * @type {I3SSublayer[]}
+   * @readonly
+   */
+  sublayers: {
+    get: function () {
+      return this._sublayers;
+    },
+  },
+
+  /**
+   * Gets or sets the sublayer visibility.
+   * @memberof I3SSublayer.prototype
+   * @type {boolean}
+   */
+  visibility: {
+    get: function () {
+      return this._visibility;
+    },
+    set: function (value) {
+      //>>includeStart('debug', pragmas.debug);
+      Check.defined("value", value);
+      //>>includeEnd('debug');
+
+      if (this._visibility !== value) {
+        this._visibility = value;
+        for (let i = 0; i < this._i3sLayers.length; i++) {
+          this._i3sLayers[i]._updateVisibility();
+        }
+      }
+    },
+  },
+
+  /**
+   * Determines if the sublayer will be shown.
+   * @memberof I3SSublayer.prototype
+   * @type {boolean}
+   * @readonly
+   */
+  show: {
+    get: function () {
+      return this._visibility && this._parent.show;
+    },
+  },
+});
+
+/**
+ * @private
+ */
+I3SSublayer._fromData = async function (
+  dataProvider,
+  buildingLayerUrl,
+  sublayerData,
+  parent
+) {
+  const sublayer = new I3SSublayer(dataProvider, parent, sublayerData);
+  if (sublayer._data.layerType === "group") {
+    const sublayers = sublayer._data.sublayers;
+    if (defined(sublayers)) {
+      const promises = [];
+      for (let i = 0; i < sublayers.length; i++) {
+        const promise = I3SSublayer._fromData(
+          dataProvider,
+          buildingLayerUrl,
+          sublayers[i],
+          sublayer
+        );
+        promises.push(promise);
+      }
+      const childSublayers = await Promise.all(promises);
+      for (let i = 0; i < childSublayers.length; i++) {
+        const childSublayer = childSublayers[i];
+        sublayer._sublayers.push(childSublayer);
+        sublayer._i3sLayers.push(...childSublayer._i3sLayers);
+      }
+    }
+  } else if (sublayer._data.layerType === "3DObject") {
+    const sublayerUrl = buildingLayerUrl.concat(
+      `/sublayers/${sublayer._data.id}`
+    );
+    const resource = new Resource({ url: sublayerUrl });
+    resource.setQueryParameters(dataProvider.resource.queryParameters);
+    resource.appendForwardSlash();
+    sublayer._resource = resource;
+
+    const layerData = await I3SDataProvider.loadJson(sublayer._resource);
+    const layer = new I3SLayer(dataProvider, layerData, sublayer);
+    sublayer._i3sLayers.push(layer);
+  } else {
+    // Filter other scene layer types out
+    console.log(
+      `${sublayer._data.layerType} layer ${sublayer._data.name} is skipped as not supported.`
+    );
+  }
+  return sublayer;
+};
+
+export default I3SSublayer;

package/Source/Scene/I3SSymbology.js

@@ -0,0 +1,337 @@
+import Color from "../Core/Color.js";
+import defaultValue from "../Core/defaultValue.js";
+import defined from "../Core/defined.js";
+import srgbToLinear from "../Core/srgbToLinear.js";
+
+/**
+ * This class implements an I3S symbology for I3S Layers.
+ * <p>
+ * Do not construct this directly, instead access symbology through {@link I3SLayer}.
+ * </p>
+ * @alias I3SSymbology
+ * @internalConstructor
+ */
+function I3SSymbology(layer) {
+  this._layer = layer;
+  this._defaultSymbology = undefined;
+  this._valueFields = [];
+  this._uniqueValueHash = undefined;
+  this._classBreaksHash = undefined;
+
+  this._parseLayerSymbology();
+}
+
+Object.defineProperties(I3SSymbology.prototype, {
+  /**
+   * Gets the default symbology data.
+   * @memberof I3SSymbology.prototype
+   * @type {object}
+   * @readonly
+   */
+  defaultSymbology: {
+    get: function () {
+      return this._defaultSymbology;
+    },
+  },
+});
+
+function convertColor(color, transparency) {
+  // color is represented as a three or four-element array, values range from 0 through 255.
+  // transparency value has to lie between 100 (full transparency) and 0 (full opacity).
+  const convertedColor = [];
+  for (let i = 0; i < color.length; i++) {
+    const floatColor = Color.byteToFloat(color[i]);
+    if (i < 3) {
+      convertedColor.push(srgbToLinear(floatColor));
+    } else {
+      convertedColor.push(floatColor);
+    }
+  }
+  if (convertedColor.length === 3) {
+    if (defined(transparency)) {
+      convertedColor.push(1.0 - transparency / 100.0);
+    } else {
+      convertedColor.push(1.0);
+    }
+  }
+  return convertedColor;
+}
+
+function parseSymbol(symbol, isColorCaptured) {
+  const symbology = {
+    edges: undefined,
+    material: undefined,
+  };
+  if (defined(symbol) && defined(symbol.symbolLayers)) {
+    for (let i = 0; i < symbol.symbolLayers.length; i++) {
+      const symbolLayer = symbol.symbolLayers[i];
+      if (symbolLayer.type === "Fill") {
+        const edges = symbolLayer.edges;
+        const outline = symbolLayer.outline;
+        if (defined(edges)) {
+          symbology.edges = {};
+          if (defined(edges.color)) {
+            symbology.edges.color = convertColor(
+              edges.color,
+              edges.transparency
+            );
+          }
+        } else if (defined(outline)) {
+          symbology.edges = {};
+          if (defined(outline.color)) {
+            symbology.edges.color = convertColor(
+              outline.color,
+              outline.transparency
+            );
+          }
+        }
+
+        if (!isColorCaptured) {
+          const material = symbolLayer.material;
+          if (defined(material)) {
+            symbology.material = {
+              colorMixMode: material.colorMixMode,
+            };
+            if (defined(material.color)) {
+              symbology.material.color = convertColor(
+                material.color,
+                material.transparency
+              );
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+  return symbology;
+}
+
+function buildUniqueValueHash(renderer, isColorCaptured) {
+  if (defined(renderer.uniqueValueGroups)) {
+    const valueHash = {};
+    for (
+      let groupIndex = 0;
+      groupIndex < renderer.uniqueValueGroups.length;
+      groupIndex++
+    ) {
+      const classes = renderer.uniqueValueGroups[groupIndex].classes;
+      if (defined(classes)) {
+        for (let classIndex = 0; classIndex < classes.length; classIndex++) {
+          const classSymbology = parseSymbol(
+            classes[classIndex].symbol,
+            isColorCaptured
+          );
+          const values = classes[classIndex].values;
+          for (let valueIndex = 0; valueIndex < values.length; valueIndex++) {
+            const fieldValues = values[valueIndex];
+            let hash = valueHash;
+            for (
+              let fieldIndex = 0;
+              fieldIndex < fieldValues.length;
+              fieldIndex++
+            ) {
+              const fieldValue = fieldValues[fieldIndex];
+              if (fieldIndex === fieldValues.length - 1) {
+                hash[fieldValue] = classSymbology;
+              } else {
+                if (!defined(hash[fieldValue])) {
+                  hash[fieldValue] = {};
+                }
+                hash = hash[fieldValue];
+              }
+            }
+          }
+        }
+      }
+    }
+    return valueHash;
+  }
+  if (defined(renderer.uniqueValueInfos)) {
+    const valueHash = {};
+    for (
+      let infoIndex = 0;
+      infoIndex < renderer.uniqueValueInfos.length;
+      infoIndex++
+    ) {
+      const info = renderer.uniqueValueInfos[infoIndex];
+      valueHash[info.value] = parseSymbol(info.symbol, isColorCaptured);
+    }
+    return valueHash;
+  }
+  return undefined;
+}
+
+function buildClassBreaksHash(renderer, isColorCaptured) {
+  if (defined(renderer.classBreakInfos)) {
+    const classBreakInfos = [...renderer.classBreakInfos];
+    classBreakInfos.sort(function (a, b) {
+      const aMax = defaultValue(a.classMaxValue, a.classMinValue);
+      const bMax = defaultValue(b.classMaxValue, b.classMinValue);
+      return aMax - bMax;
+    });
+    const valueHash = {
+      ranges: [],
+      symbols: [],
+    };
+
+    if (defined(renderer.minValue)) {
+      valueHash.ranges.push(renderer.minValue);
+      valueHash.symbols.push(undefined);
+    }
+    for (let infoIndex = 0; infoIndex < classBreakInfos.length; infoIndex++) {
+      const info = classBreakInfos[infoIndex];
+      if (defined(info.classMinValue)) {
+        if (
+          valueHash.ranges.length === 0 ||
+          info.classMinValue > valueHash.ranges[valueHash.ranges.length - 1]
+        ) {
+          valueHash.ranges.push(info.classMinValue);
+          valueHash.symbols.push(undefined);
+        }
+      }
+      if (defined(info.classMaxValue)) {
+        if (
+          valueHash.ranges.length === 0 ||
+          info.classMaxValue > valueHash.ranges[valueHash.ranges.length - 1]
+        ) {
+          valueHash.ranges.push(info.classMaxValue);
+          valueHash.symbols.push(parseSymbol(info.symbol, isColorCaptured));
+        }
+      }
+    }
+    valueHash.symbols.push(undefined);
+
+    return valueHash;
+  }
+  return undefined;
+}
+
+/**
+ * @private
+ */
+I3SSymbology.prototype._parseLayerSymbology = function () {
+  const drawingInfo = this._layer.data.drawingInfo;
+  if (defined(drawingInfo) && defined(drawingInfo.renderer)) {
+    const cachedDrawingInfo = this._layer.data.cachedDrawingInfo;
+    const isColorCaptured =
+      defined(cachedDrawingInfo) && cachedDrawingInfo.color === true;
+    const renderer = drawingInfo.renderer;
+    if (renderer.type === "simple") {
+      this._defaultSymbology = parseSymbol(renderer.symbol, isColorCaptured);
+    } else if (renderer.type === "uniqueValue") {
+      this._defaultSymbology = parseSymbol(
+        renderer.defaultSymbol,
+        isColorCaptured
+      );
+      this._valueFields.push(renderer.field1);
+      if (defined(renderer.field2)) {
+        this._valueFields.push(renderer.field2);
+      }
+      if (defined(renderer.field3)) {
+        this._valueFields.push(renderer.field3);
+      }
+      this._uniqueValueHash = buildUniqueValueHash(renderer, isColorCaptured);
+    } else if (renderer.type === "classBreaks") {
+      this._defaultSymbology = parseSymbol(
+        renderer.defaultSymbol,
+        isColorCaptured
+      );
+      this._valueFields.push(renderer.field);
+      this._classBreaksHash = buildClassBreaksHash(renderer, isColorCaptured);
+    }
+  }
+};
+
+function findHashForUniqueValues(hash, values, hashLevel, valueIndex) {
+  const levelValues = values[hashLevel];
+  if (valueIndex < levelValues.length) {
+    const hashValue = levelValues[valueIndex];
+    const innerHash = hash[hashValue];
+    if (defined(innerHash) && ++hashLevel < values.length) {
+      return findHashForUniqueValues(innerHash, values, hashLevel, valueIndex);
+    }
+    return innerHash;
+  }
+  return undefined;
+}
+
+function bisect(array, value) {
+  let low = 0;
+  let high = array.length;
+  if (low < high) {
+    do {
+      const mid = (low + high) >>> 1;
+      if (array[mid] < value) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    } while (low < high);
+  }
+  return low;
+}
+
+function findHashForClassBreaks(hash, values, valueIndex) {
+  const value = values[valueIndex];
+  const range = bisect(hash.ranges, value);
+  return hash.symbols[range];
+}
+
+/**
+ * @private
+ */
+I3SSymbology.prototype._getSymbology = async function (node) {
+  const symbology = {
+    default: this._defaultSymbology,
+  };
+
+  if (this._valueFields.length > 0) {
+    const promises = [];
+    for (let i = 0; i < this._valueFields.length; i++) {
+      promises.push(node.loadField(this._valueFields[i]));
+    }
+    await Promise.all(promises);
+
+    const fieldsValues = [];
+    for (let i = 0; i < this._valueFields.length; i++) {
+      fieldsValues.push(node.fields[this._valueFields[i]].values);
+    }
+
+    let featureHashFn;
+    if (defined(this._uniqueValueHash)) {
+      featureHashFn = (featureIndex) =>
+        findHashForUniqueValues(
+          this._uniqueValueHash,
+          fieldsValues,
+          0,
+          featureIndex
+        );
+    } else if (defined(this._classBreaksHash)) {
+      featureHashFn = (featureIndex) =>
+        findHashForClassBreaks(
+          this._classBreaksHash,
+          fieldsValues[0],
+          featureIndex
+        );
+    }
+
+    if (defined(featureHashFn)) {
+      const firstFieldValues = fieldsValues[0];
+      for (
+        let featureIndex = 0;
+        featureIndex < firstFieldValues.length;
+        featureIndex++
+      ) {
+        const featureSymbology = featureHashFn(featureIndex);
+        if (defined(featureSymbology)) {
+          symbology[featureIndex] = featureSymbology;
+        }
+      }
+    }
+  }
+
+  return symbology;
+};
+
+export default I3SSymbology;

package/Source/Scene/KeyframeNode.js

@@ -20,7 +20,7 @@ function KeyframeNode(spatialNode, keyframe) {
   this.spatialNode = spatialNode;
   this.keyframe = keyframe;
   this.state = LoadState.UNLOADED;
-  this.metadatas = [];
+  this.metadata = [];
   this.megatextureIndex = -1;
   this.priority = -Number.MAX_VALUE;
   this.highPriorityFrameNumber = -1;

package/Source/Scene/Model/pickModel.js

@@ -198,6 +198,8 @@ export default function pickModel(
         primitive,
         VertexAttributeSemantic.POSITION
       );
+      const byteOffset = positionAttribute.byteOffset;
+      const byteStride = positionAttribute.byteStride;
       const vertexCount = positionAttribute.count;
 
       if (!defined(primitive.indices)) {
@@ -234,7 +236,19 @@ export default function pickModel(
       }
 
       const numComponents = AttributeType.getNumberOfComponents(attributeType);
-      const elementCount = vertexCount * numComponents;
+      const bytes = ComponentDatatype.getSizeInBytes(componentDatatype);
+      const isInterleaved =
+        !defined(vertices) &&
+        defined(byteStride) &&
+        byteStride !== numComponents * bytes;
+
+      let elementStride = numComponents;
+      let offset = 0;
+      if (isInterleaved) {
+        elementStride = byteStride / bytes;
+        offset = byteOffset / bytes;
+      }
+      const elementCount = vertexCount * elementStride;
 
       if (!defined(vertices)) {
         const verticesBuffer = positionAttribute.buffer;
@@ -246,7 +260,7 @@ export default function pickModel(
           );
           verticesBuffer.getBufferData(
             vertices,
-            positionAttribute.byteOffset,
+            isInterleaved ? 0 : byteOffset,
             0,
             elementCount
           );
@@ -280,7 +294,8 @@ export default function pickModel(
           const v0 = getVertexPosition(
             vertices,
             i0,
-            numComponents,
+            offset,
+            elementStride,
             quantization,
             instanceTransform,
             verticalExaggeration,
@@ -291,7 +306,8 @@ export default function pickModel(
           const v1 = getVertexPosition(
             vertices,
             i1,
-            numComponents,
+            offset,
+            elementStride,
             quantization,
             instanceTransform,
             verticalExaggeration,
@@ -302,7 +318,8 @@ export default function pickModel(
           const v2 = getVertexPosition(
             vertices,
             i2,
-            numComponents,
+            offset,
+            elementStride,
             quantization,
             instanceTransform,
             verticalExaggeration,
@@ -350,7 +367,8 @@ export default function pickModel(
 function getVertexPosition(
   vertices,
   index,
-  numComponents,
+  offset,
+  numElements,
   quantization,
   instanceTransform,
   verticalExaggeration,
@@ -358,7 +376,7 @@ function getVertexPosition(
   ellipsoid,
   result
 ) {
-  const i = index * numComponents;
+  const i = offset + index * numElements;
   result.x = vertices[i];
   result.y = vertices[i + 1];
   result.z = vertices[i + 2];

package/Source/Scene/PickFramebuffer.js

@@ -27,10 +27,10 @@ function PickFramebuffer(context) {
   this._width = 0;
   this._height = 0;
 }
+
 PickFramebuffer.prototype.begin = function (screenSpaceRectangle, viewport) {
   const context = this._context;
-  const width = viewport.width;
-  const height = viewport.height;
+  const { width, height } = viewport;
 
   BoundingRectangle.clone(
     screenSpaceRectangle,
@@ -51,6 +51,12 @@ PickFramebuffer.prototype.begin = function (screenSpaceRectangle, viewport) {
 
 const colorScratch = new Color();
 
+/**
+ * Return the picked object rendered within a given rectangle.
+ *
+ * @param {BoundingRectangle} screenSpaceRectangle
+ * @returns {object|undefined} The object rendered in the middle of the rectangle, or undefined if nothing was rendered.
+ */
 PickFramebuffer.prototype.end = function (screenSpaceRectangle) {
   const width = defaultValue(screenSpaceRectangle.width, 1.0);
   const height = defaultValue(screenSpaceRectangle.height, 1.0);
@@ -114,6 +120,34 @@ PickFramebuffer.prototype.end = function (screenSpaceRectangle) {
   return undefined;
 };
 
+/**
+ * Return voxel tile and sample information as rendered by a pickVoxel pass,
+ * within a given rectangle.
+ *
+ * @param {BoundingRectangle} screenSpaceRectangle
+ * @returns {TypedArray}
+ */
+PickFramebuffer.prototype.readVoxelInfo = function (screenSpaceRectangle) {
+  const width = defaultValue(screenSpaceRectangle.width, 1.0);
+  const height = defaultValue(screenSpaceRectangle.height, 1.0);
+
+  const context = this._context;
+  const pixels = context.readPixels({
+    x: screenSpaceRectangle.x,
+    y: screenSpaceRectangle.y,
+    width: width,
+    height: height,
+    framebuffer: this._fb.framebuffer,
+  });
+
+  // Read the center pixel
+  const halfWidth = Math.floor(width * 0.5);
+  const halfHeight = Math.floor(height * 0.5);
+  const index = 4 * (halfHeight * width + halfWidth);
+
+  return pixels.slice(index, index + 4);
+};
+
 PickFramebuffer.prototype.isDestroyed = function () {
   return false;
 };
@@ -122,4 +156,5 @@ PickFramebuffer.prototype.destroy = function () {
   this._fb.destroy();
   return destroyObject(this);
 };
+
 export default PickFramebuffer;