@cesium/engine 7.0.0 → 9.0.0

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/Label.js

@@ -85,6 +85,36 @@ function parseFont(label) {
   label._lineHeight = fontInfo.lineHeight;
 }
 
+/**
+ * @typedef {object} Label.ConstructorOptions
+ *
+ * Initialization options for the Label constructor
+ *
+ * @property {Cartesian3} position The cartesian position of the label.
+ * @property {string} [id] A user-defined object to return when the label is picked with {@link Scene#pick}.
+ * @property {boolean} [show=true] Determines if this label will be shown.
+ * @property {string} [text] A string specifying the text of the label.
+ * @property {string} [font='30px sans-serif'] A string specifying the font used to draw this label. Fonts are specified using the same syntax as the CSS 'font' property.
+ * @property {LabelStyle} [style=LabelStyle.FILL] A {@link LabelStyle} specifying the style of the label.
+ * @property {number} [scale=1.0] A number specifying the uniform scale that is multiplied with the label size.
+ * @property {boolean} [showBackground=false] Determines if a background behind this label will be shown.
+ * @property {Color} [backgroundColor=new Color(0.165, 0.165, 0.165, 0.8)] A {@link Color} specifying the background color of the label.
+ * @property {Cartesian2} [backgroundPadding=new Cartesian2(7, 5)] A {@link Cartesian2} Specifying the horizontal and vertical background padding in pixels.
+ * @property {Cartesian2} [pixelOffset=Cartesian2.ZERO] A {@link Cartesian2} specifying the pixel offset in screen space from the origin of this label.
+ * @property {Cartesian3} [eyeOffset=Cartesian3.ZERO] A {@link Cartesian3} specifying the 3D Cartesian offset applied to this label in eye coordinates.
+ * @property {HorizontalOrigin} [horizontalOrigin=HorizontalOrigin.CENTER] A {@link HorizontalOrigin} specifying the horizontal origin of this label.
+ * @property {VerticalOrigin} [verticalOrigin=VerticalOrigin.CENTER] A {@link VerticalOrigin} specifying the vertical origin of this label.
+ * @property {HeightReference} [heightReference=HeightReference.NONE] A {@link HeightReference} specifying the height reference of this label.
+ * @property {Color} [fillColor=Color.WHITE] A {@link Color} specifying the fill color of the label.
+ * @property {Color} [outlineColor=Color.BLACK] A {@link Color} specifying the outline color of the label.
+ * @property {number} [outlineWidth=1.0] A number specifying the outline width of the label.
+ * @property {NearFarScalar} [translucencyByDistance] A {@link NearFarScalar} specifying near and far translucency properties of the label based on the label's distance from the camera.
+ * @property {NearFarScalar} [pixelOffsetScaleByDistance] A {@link NearFarScalar} specifying near and far pixel offset scaling properties of the label based on the label's distance from the camera.
+ * @property {NearFarScalar} [scaleByDistance] A {@link NearFarScalar} specifying near and far scaling properties of the label based on the label's distance from the camera.
+ * @property {DistanceDisplayCondition} [distanceDisplayCondition] A {@link DistanceDisplayCondition} specifying at what distance from the camera that this label will be displayed.
+ * @property {number} [disableDepthTestDistance] A number specifying the distance from the camera at which to disable the depth test to, for example, prevent clipping against terrain.
+ */
+
 /**
  * <div class="notice">
  * Create labels by calling {@link LabelCollection#add}. Do not call the constructor directly.
@@ -94,6 +124,9 @@ function parseFont(label) {
  * @internalConstructor
  * @class
  *
+ * @param {Label.ConstructorOptions} options Object describing initialization options
+ * @param {LabelCollection} labelCollection Instance of LabelCollection
+ *
  * @exception {DeveloperError} translucencyByDistance.far must be greater than translucencyByDistance.near
  * @exception {DeveloperError} pixelOffsetScaleByDistance.far must be greater than pixelOffsetScaleByDistance.near
  * @exception {DeveloperError} distanceDisplayCondition.far must be greater than distanceDisplayCondition.near

package/Source/Scene/LabelCollection.js

@@ -710,7 +710,7 @@ Object.defineProperties(LabelCollection.prototype, {
  * Creates and adds a label with the specified initial properties to the collection.
  * The added label is returned so it can be modified or removed from the collection later.
  *
- * @param {object} [options] A template describing the label's properties as shown in Example 1.
+ * @param {Label.ConstructorOptions} [options] A template describing the label's properties as shown in Example 1.
  * @returns {Label} The label that was added to the collection.
  *
  * @performance Calling <code>add</code> is expected constant time.  However, the collection's vertex buffer
@@ -755,6 +755,7 @@ Object.defineProperties(LabelCollection.prototype, {
  *   font : '24px Helvetica',
  * });
  *
+ *
  * @see LabelCollection#remove
  * @see LabelCollection#removeAll
  */

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;