@cesium/engine 6.2.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/Implicit3DTileContent.js

@@ -1177,6 +1177,10 @@ Implicit3DTileContent.prototype.applyStyle = function (style) {};
 
 Implicit3DTileContent.prototype.update = function (tileset, frameState) {};
 
+Implicit3DTileContent.prototype.pick = function (ray, frameState, result) {
+  return undefined;
+};
+
 Implicit3DTileContent.prototype.isDestroyed = function () {
   return false;
 };

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

@@ -10,7 +10,7 @@ import writeTextToCanvas from "../Core/writeTextToCanvas.js";
 import bitmapSDF from "bitmap-sdf";
 import BillboardCollection from "./BillboardCollection.js";
 import BlendOption from "./BlendOption.js";
-import HeightReference from "./HeightReference.js";
+import { isHeightReferenceClamp } from "./HeightReference.js";
 import HorizontalOrigin from "./HorizontalOrigin.js";
 import Label from "./Label.js";
 import LabelStyle from "./LabelStyle.js";
@@ -510,7 +510,7 @@ function repositionAllGlyphs(label) {
     );
   }
 
-  if (label.heightReference === HeightReference.CLAMP_TO_GROUND) {
+  if (isHeightReferenceClamp(label.heightReference)) {
     for (glyphIndex = 0; glyphIndex < glyphLength; ++glyphIndex) {
       glyph = glyphs[glyphIndex];
       const billboard = glyph.billboard;

package/Source/Scene/Model/AtmospherePipelineStage.js

@@ -0,0 +1,59 @@
+import Cartesian3 from "../../Core/Cartesian3.js";
+import CesiumMath from "../../Core/Math.js";
+import ShaderDestination from "../../Renderer/ShaderDestination.js";
+import AtmosphereStageFS from "../../Shaders/Model/AtmosphereStageFS.js";
+import AtmosphereStageVS from "../../Shaders/Model/AtmosphereStageVS.js";
+
+/**
+ * The atmosphere pipeline stage applies all earth atmosphere effects that apply
+ * to models, including fog.
+ *
+ * @namespace AtmospherePipelineStage
+ *
+ * @private
+ */
+const AtmospherePipelineStage = {
+  name: "AtmospherePipelineStage", // Helps with debugging
+};
+
+AtmospherePipelineStage.process = function (
+  renderResources,
+  model,
+  frameState
+) {
+  const shaderBuilder = renderResources.shaderBuilder;
+
+  shaderBuilder.addDefine("HAS_ATMOSPHERE", undefined, ShaderDestination.BOTH);
+  shaderBuilder.addDefine(
+    "COMPUTE_POSITION_WC_ATMOSPHERE",
+    undefined,
+    ShaderDestination.BOTH
+  );
+
+  shaderBuilder.addVarying("vec3", "v_atmosphereRayleighColor");
+  shaderBuilder.addVarying("vec3", "v_atmosphereMieColor");
+  shaderBuilder.addVarying("float", "v_atmosphereOpacity");
+
+  shaderBuilder.addVertexLines([AtmosphereStageVS]);
+  shaderBuilder.addFragmentLines([AtmosphereStageFS]);
+
+  // Add a uniform so fog is only calculated when the efcfect would
+  // be non-negligible For example when the camera is in space, fog density decreases
+  // to 0 so fog shouldn't be rendered. Since this state may change rapidly if
+  // the camera is moving, this is implemented as a uniform, not a define.
+  shaderBuilder.addUniform("bool", "u_isInFog", ShaderDestination.FRAGMENT);
+  renderResources.uniformMap.u_isInFog = function () {
+    // We only need a rough measure of distance to the model, so measure
+    // from the camera to the bounding sphere center.
+    const distance = Cartesian3.distance(
+      frameState.camera.positionWC,
+      model.boundingSphere.center
+    );
+
+    return (
+      CesiumMath.fog(distance, frameState.fog.density) > CesiumMath.EPSILON3
+    );
+  };
+};
+
+export default AtmospherePipelineStage;

package/Source/Scene/Model/B3dmLoader.js

@@ -50,6 +50,7 @@ const FeatureIdAttribute = ModelComponents.FeatureIdAttribute;
  * @param {Axis} [options.forwardAxis=Axis.X] The forward-axis of the glTF model.
  * @param {boolean} [options.loadAttributesAsTypedArray=false] If <code>true</code>, load all attributes as typed arrays instead of GPU buffers. If the attributes are interleaved in the glTF they will be de-interleaved in the typed array.
  * @param {boolean} [options.loadAttributesFor2D=false] If <code>true</code>, load the positions buffer and any instanced attribute buffers as typed arrays for accurately projecting models to 2D.
+ * @param {boolean} [options.enablePick=false]  If <code>true</code>, load the positions buffer, any instanced attribute buffers, and index buffer as typed arrays for CPU-enabled picking in WebGL1.
  * @param {boolean} [options.loadIndicesForWireframe=false] If <code>true</code>, load the index buffer as a typed array. This is useful for creating wireframe indices in WebGL1.
  * @param {boolean} [options.loadPrimitiveOutline=true] If <code>true</code>, load outlines from the {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline} extension. This can be set false to avoid post-processing geometry at load time.
  * @param {boolean} [options.loadForClassification=false] If <code>true</code> and if the model has feature IDs, load the feature IDs and indices as typed arrays. This is useful for batching features for classification.
@@ -74,6 +75,7 @@ function B3dmLoader(options) {
     false
   );
   const loadAttributesFor2D = defaultValue(options.loadAttributesFor2D, false);
+  const enablePick = defaultValue(options.enablePick, false);
   const loadIndicesForWireframe = defaultValue(
     options.loadIndicesForWireframe,
     false
@@ -102,6 +104,7 @@ function B3dmLoader(options) {
   this._forwardAxis = forwardAxis;
   this._loadAttributesAsTypedArray = loadAttributesAsTypedArray;
   this._loadAttributesFor2D = loadAttributesFor2D;
+  this._enablePick = enablePick;
   this._loadIndicesForWireframe = loadIndicesForWireframe;
   this._loadPrimitiveOutline = loadPrimitiveOutline;
   this._loadForClassification = loadForClassification;
@@ -223,6 +226,7 @@ B3dmLoader.prototype.load = function () {
     incrementallyLoadTextures: this._incrementallyLoadTextures,
     loadAttributesAsTypedArray: this._loadAttributesAsTypedArray,
     loadAttributesFor2D: this._loadAttributesFor2D,
+    enablePick: this._enablePick,
     loadIndicesForWireframe: this._loadIndicesForWireframe,
     loadPrimitiveOutline: this._loadPrimitiveOutline,
     loadForClassification: this._loadForClassification,

package/Source/Scene/Model/FeatureIdPipelineStage.js

@@ -9,6 +9,7 @@ import FeatureIdStageVS from "../../Shaders/Model/FeatureIdStageVS.js";
 import ModelComponents from "../ModelComponents.js";
 import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
 import ModelUtility from "./ModelUtility.js";
+import Matrix3 from "../../Core/Matrix3.js";
 
 /**
  * The feature ID pipeline stage is responsible for processing feature IDs
@@ -387,10 +388,32 @@ function processTexture(
     ShaderDestination.FRAGMENT
   );
 
+  // Get a GLSL expression for the texture coordinates
+  const texCoord = textureReader.texCoord;
+  const texCoordVariable = `v_texCoord_${texCoord}`;
+  let texCoordVariableExpression = texCoordVariable;
+
+  // Check if the texture defines a `transform` from a `KHR_texture_transform`
+  const transform = textureReader.transform;
+  if (defined(transform) && !Matrix3.equals(transform, Matrix3.IDENTITY)) {
+    // Add a uniform for the transformation matrix
+    const transformUniformName = `${uniformName}Transform`;
+    shaderBuilder.addUniform(
+      "mat3",
+      transformUniformName,
+      ShaderDestination.FRAGMENT
+    );
+    uniformMap[transformUniformName] = function () {
+      return transform;
+    };
+    // Update the expression for the texture coordinates
+    // with one that transforms the texture coordinates
+    // with the transform matrix first
+    texCoordVariableExpression = `vec2(${transformUniformName} * vec3(${texCoordVariable}, 1.0))`;
+  }
   // Read one or more channels from the texture
   // example: texture(u_featureIdTexture_0, v_texCoord_1).rg
-  const texCoord = `v_texCoord_${textureReader.texCoord}`;
-  const textureRead = `texture(${uniformName}, ${texCoord}).${channels}`;
+  const textureRead = `texture(${uniformName}, ${texCoordVariableExpression}).${channels}`;
 
   // Finally, assign to the struct field. Example:
   // featureIds.featureId_0 = unpacked;