@cesium/engine 11.0.0 → 12.0.0

package/Source/Scene/MetadataPicking.js

@@ -0,0 +1,305 @@
+import Cartesian2 from "../Core/Cartesian2.js";
+import Cartesian3 from "../Core/Cartesian3.js";
+import Cartesian4 from "../Core/Cartesian4.js";
+import defined from "../Core/defined.js";
+import Matrix2 from "../Core/Matrix2.js";
+import Matrix3 from "../Core/Matrix3.js";
+import Matrix4 from "../Core/Matrix4.js";
+import RuntimeError from "../Core/RuntimeError.js";
+import MetadataComponentType from "./MetadataComponentType.js";
+import MetadataType from "./MetadataType.js";
+
+/**
+ * Utility functions for metadata picking.
+ *
+ * These are used by the `Picking.pickMetadata` function to decode
+ * the metadata values that have been read from the frame buffer
+ * into the actual metadata values, according to the structure
+ * defined by the `MetadataClassProperty`.
+ *
+ * @private
+ */
+const MetadataPicking = {};
+
+/**
+ * Returns the value at the specified index of the given data view,
+ * interpreting the data to have the given component type.
+ *
+ * @param {MetadataComponentType} componentType The `MetadataComponentType`
+ * @param {DataView} dataView The data view
+ * @param {number} index The index (byte offset)
+ * @returns {number|bigint|undefined} The value
+ *
+ * @private
+ */
+MetadataPicking.decodeRawMetadataValue = function (
+  componentType,
+  dataView,
+  index,
+) {
+  switch (componentType) {
+    case MetadataComponentType.INT8:
+      return dataView.getInt8(index);
+    case MetadataComponentType.UINT8:
+      return dataView.getUint8(index);
+    case MetadataComponentType.INT16:
+      return dataView.getInt16(index);
+    case MetadataComponentType.UINT16:
+      return dataView.getUint16(index);
+    case MetadataComponentType.INT32:
+      return dataView.getInt32(index);
+    case MetadataComponentType.UINT32:
+      return dataView.getUint32(index);
+    case MetadataComponentType.INT64:
+      return dataView.getBigInt64(index);
+    case MetadataComponentType.UINT64:
+      return dataView.getBigUint64(index);
+    case MetadataComponentType.FLOAT32:
+      return dataView.getFloat32(index);
+    case MetadataComponentType.FLOAT64:
+      return dataView.getFloat64(index);
+  }
+  throw new RuntimeError(`Invalid component type: ${componentType}`);
+};
+
+/**
+ * Decodes one component of a metadata value with the given property type
+ * from the given data view.
+ *
+ * This will decode one component (e.g. one entry of a SCALAR array,
+ * or one component of a VEC2 element).
+ *
+ * This will apply normalization to the raw component value if the given
+ * class property is 'normalized'.
+ *
+ * @param {MetadataClassProperty} classProperty The class property
+ * @param {DataView} dataView The data view containing the raw metadata values
+ * @param {number} dataViewOffset The byte offset within the data view from
+ * which the component should be read
+ * @returns {number|bigint|undefined} The metadata value component
+ */
+MetadataPicking.decodeRawMetadataValueComponent = function (
+  classProperty,
+  dataView,
+  dataViewOffset,
+) {
+  const componentType = classProperty.componentType;
+  const component = MetadataPicking.decodeRawMetadataValue(
+    componentType,
+    dataView,
+    dataViewOffset,
+  );
+  if (classProperty.normalized) {
+    return MetadataComponentType.normalize(component, componentType);
+  }
+  return component;
+};
+
+/**
+ * Decodes one element of a metadata value with the given property type
+ * from the given data view.
+ *
+ * When the given class property is vector- or matrix typed, then the
+ * result will be an array, with a length that corresponds to the
+ * number of vector- or matrix components.
+ *
+ * Otherwise, it will be a single value.
+ *
+ * In any case, the return value will be the "raw" value, which does
+ * take into account normalization, but does NOT take into account
+ * default/noData value handling.
+ *
+ * @param {MetadataClassProperty} classProperty The metadata class property
+ * @param {DataView} dataView The data view containing the raw metadata values
+ * @param {number} elementIndex The index of the element. This is the index
+ * inside the array for array-typed properties, and 0 for non-array types.
+ * @returns {number|number[]|bigint|bigint[]|undefined} The decoded metadata value element
+ */
+MetadataPicking.decodeRawMetadataValueElement = function (
+  classProperty,
+  dataView,
+  elementIndex,
+) {
+  const componentType = classProperty.componentType;
+  const componentSizeInBytes =
+    MetadataComponentType.getSizeInBytes(componentType);
+  const type = classProperty.type;
+  const componentCount = MetadataType.getComponentCount(type);
+  const elementSizeInBytes = componentSizeInBytes * componentCount;
+  if (componentCount > 1) {
+    const result = Array(componentCount);
+    for (let i = 0; i < componentCount; i++) {
+      const offset =
+        elementIndex * elementSizeInBytes + i * componentSizeInBytes;
+      const component = MetadataPicking.decodeRawMetadataValueComponent(
+        classProperty,
+        dataView,
+        offset,
+      );
+      result[i] = component;
+    }
+    return result;
+  }
+  const offset = elementIndex * elementSizeInBytes;
+  const result = MetadataPicking.decodeRawMetadataValueComponent(
+    classProperty,
+    dataView,
+    offset,
+  );
+  return result;
+};
+
+/**
+ * Decode the given raw values into the raw (array-based) form of
+ * a metadata property value.
+ *
+ * (For decoding to types like `CartesianN`, the `decodeMetadataValues`
+ * function can be used)
+ *
+ * The given values are a `Uint8Array` containing the RGBA
+ * values that have been read from the metadata picking
+ * frame buffer. They are assumed to contain the value for
+ * the given class property, as encoded by the
+ * `MetadataPickingPipelineStage` for metadata picking.
+ *
+ * When the given class property is an array, then (it has to be
+ * a fixed-length array, and) the result will be an array with
+ * the respective length.
+ *
+ * When the given class property is vector- or matrix typed,
+ * then the result will be an array, with a length that corresponds
+ * to the number of vector- or matrix components.
+ *
+ * (The case that the property is an array of vector- or matrix
+ * elements is not supported on the side of the general metadata
+ * shader infrastructure, but handled here nevertheless. For such
+ * an input, the result would be an array of arrays, with each
+ * element representing one of the vectors or matrices).
+ *
+ * In any case, the return value will be the "raw" value, which does
+ * take into account normalization, but does NOT take into account
+ * any offset/scale, or default/noData value handling.
+ *
+ * @param {MetadataClassProperty} classProperty The `MetadataClassProperty`
+ * @param {Uint8Array} rawPixelValues The raw values
+ * @returns {number|bigint|number[]|bigint[]|undefined} The value
+ *
+ * @private
+ */
+MetadataPicking.decodeRawMetadataValues = function (
+  classProperty,
+  rawPixelValues,
+) {
+  const dataView = new DataView(
+    rawPixelValues.buffer,
+    rawPixelValues.byteOffset,
+    rawPixelValues.byteLength,
+  );
+  if (classProperty.isArray) {
+    const arrayLength = classProperty.arrayLength;
+    const result = Array(arrayLength);
+    for (let i = 0; i < arrayLength; i++) {
+      const element = MetadataPicking.decodeRawMetadataValueElement(
+        classProperty,
+        dataView,
+        i,
+      );
+      result[i] = element;
+    }
+    return result;
+  }
+  const result = MetadataPicking.decodeRawMetadataValueElement(
+    classProperty,
+    dataView,
+    0,
+  );
+  return result;
+};
+
+/**
+ * Converts the given type into an object representation where appropriate.
+ *
+ * When the given type is `SCALAR`, `STRING`, `BOOLEAN`, or `ENUM`, or
+ * when the given value is `undefined`, then the given value will be
+ * returned.
+ *
+ * Otherwise, for the `VECn/MATn` types, the given value is assumed to be
+ * a numeric array, and is converted into the matching `CartesianN/MatrixN`
+ * value.
+ *
+ * @param {string} type The `ClassProperty` type
+ * @param {number|bigint|number[]|bigint[]|undefined} value The input value
+ * @returns {any} The object representation
+ */
+MetadataPicking.convertToObjectType = function (type, value) {
+  if (!defined(value)) {
+    return value;
+  }
+  if (
+    type === MetadataType.SCALAR ||
+    type === MetadataType.STRING ||
+    type === MetadataType.BOOLEAN ||
+    type === MetadataType.ENUM
+  ) {
+    return value;
+  }
+  const numbers = value.map((n) => Number(n));
+  switch (type) {
+    case MetadataType.VEC2:
+      return Cartesian2.unpack(numbers, 0, new Cartesian2());
+    case MetadataType.VEC3:
+      return Cartesian3.unpack(numbers, 0, new Cartesian3());
+    case MetadataType.VEC4:
+      return Cartesian4.unpack(numbers, 0, new Cartesian3());
+    case MetadataType.MAT2:
+      return Matrix2.unpack(numbers, 0, new Matrix2());
+    case MetadataType.MAT3:
+      return Matrix3.unpack(numbers, 0, new Matrix3());
+    case MetadataType.MAT4:
+      return Matrix4.unpack(numbers, 0, new Matrix4());
+  }
+  // Should never happen:
+  return value;
+};
+
+/**
+ * Decode the given raw values into a metadata property value.
+ *
+ * This just converts the result of `decodeRawMetadataValues`
+ * from array-based types into object types like `CartesianN`.
+ *
+ * @param {MetadataClassProperty} classProperty The `MetadataClassProperty`
+ * @param {Uint8Array} rawPixelValues The raw values
+ * @returns {any} The value
+ *
+ * @private
+ */
+MetadataPicking.decodeMetadataValues = function (
+  classProperty,
+  rawPixelValues,
+) {
+  const arrayBasedResult = MetadataPicking.decodeRawMetadataValues(
+    classProperty,
+    rawPixelValues,
+  );
+  if (classProperty.isArray) {
+    const arrayLength = classProperty.arrayLength;
+    const result = Array(arrayLength);
+    for (let i = 0; i < arrayLength; i++) {
+      const arrayBasedValue = arrayBasedResult[i];
+      const objectBasedValue = MetadataPicking.convertToObjectType(
+        classProperty.type,
+        arrayBasedValue,
+      );
+      result[i] = objectBasedValue;
+    }
+    return result;
+  }
+  const result = MetadataPicking.convertToObjectType(
+    classProperty.type,
+    arrayBasedResult,
+  );
+  return result;
+};
+
+export default Object.freeze(MetadataPicking);

package/Source/Scene/MetadataSchemaLoader.js

@@ -34,7 +34,7 @@ function MetadataSchemaLoader(options) {
   //>>includeStart('debug', pragmas.debug);
   if (defined(schema) === defined(resource)) {
     throw new DeveloperError(
-      "One of options.schema and options.resource must be defined."
+      "One of options.schema and options.resource must be defined.",
     );
   }
   //>>includeEnd('debug');

package/Source/Scene/MetadataTable.js

@@ -124,7 +124,7 @@ MetadataTable.prototype.hasPropertyBySemantic = function (semantic) {
   return MetadataEntity.hasPropertyBySemantic(
     semantic,
     this._properties,
-    this._class
+    this._class,
   );
 };
 
@@ -270,7 +270,7 @@ MetadataTable.prototype.getPropertyBySemantic = function (index, semantic) {
 MetadataTable.prototype.setPropertyBySemantic = function (
   index,
   semantic,
-  value
+  value,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.string("semantic", semantic);

package/Source/Scene/MetadataTableProperty.js

@@ -63,23 +63,23 @@ function MetadataTableProperty(options) {
     // EXT_feature_metadata uses offsetType for both arrays and strings
     let arrayOffsetType = defaultValue(
       property.arrayOffsetType,
-      property.offsetType
+      property.offsetType,
     );
     arrayOffsetType = defaultValue(
       MetadataComponentType[arrayOffsetType],
-      MetadataComponentType.UINT32
+      MetadataComponentType.UINT32,
     );
 
     // EXT_structural_metadata uses arrayOffsets.
     // EXT_feature_metadata uses arrayOffsetBufferView
     const arrayOffsetBufferView = defaultValue(
       property.arrayOffsets,
-      property.arrayOffsetBufferView
+      property.arrayOffsetBufferView,
     );
     arrayOffsets = new BufferView(
       bufferViews[arrayOffsetBufferView],
       arrayOffsetType,
-      count + 1
+      count + 1,
     );
 
     byteLength += arrayOffsets.typedArray.byteLength;
@@ -103,23 +103,23 @@ function MetadataTableProperty(options) {
     // EXT_structural_metadata uses stringOffsetType, EXT_feature_metadata uses offsetType for both arrays and strings
     let stringOffsetType = defaultValue(
       property.stringOffsetType,
-      property.offsetType
+      property.offsetType,
     );
     stringOffsetType = defaultValue(
       MetadataComponentType[stringOffsetType],
-      MetadataComponentType.UINT32
+      MetadataComponentType.UINT32,
     );
 
     // EXT_structural_metadata uses stringOffsets.
     // EXT_feature_metadata uses stringOffsetBufferView
     const stringOffsetBufferView = defaultValue(
       property.stringOffsets,
-      property.stringOffsetBufferView
+      property.stringOffsetBufferView,
     );
     stringOffsets = new BufferView(
       bufferViews[stringOffsetBufferView],
       stringOffsetType,
-      componentCount + 1
+      componentCount + 1,
     );
 
     byteLength += stringOffsets.typedArray.byteLength;
@@ -145,7 +145,7 @@ function MetadataTableProperty(options) {
   const values = new BufferView(
     bufferViews[valuesBufferView],
     valueType,
-    valueCount
+    valueCount,
   );
   byteLength += values.typedArray.byteLength;
 
@@ -402,7 +402,7 @@ function checkIndex(table, index) {
   if (!defined(index) || index < 0 || index >= count) {
     const maximumIndex = count - 1;
     throw new DeveloperError(
-      `index is required and between zero and count - 1. Actual value: ${maximumIndex}`
+      `index is required and between zero and count - 1. Actual value: ${maximumIndex}`,
     );
   }
 }
@@ -510,7 +510,7 @@ function getString(index, values, stringOffsets) {
   return getStringFromTypedArray(
     values.typedArray,
     stringByteOffset,
-    stringByteLength
+    stringByteLength,
   );
 }
 
@@ -734,7 +734,7 @@ function applyValueTransform(property, value) {
     value,
     property._offset,
     property._scale,
-    MetadataComponentType.applyValueTransform
+    MetadataComponentType.applyValueTransform,
   );
 }
 
@@ -749,7 +749,7 @@ function unapplyValueTransform(property, value) {
     value,
     property._offset,
     property._scale,
-    MetadataComponentType.unapplyValueTransform
+    MetadataComponentType.unapplyValueTransform,
   );
 }
 
@@ -763,12 +763,12 @@ function BufferView(bufferView, componentType, length) {
   if (componentType === MetadataComponentType.INT64) {
     if (!FeatureDetection.supportsBigInt()) {
       oneTimeWarning(
-        "INT64 type is not fully supported on this platform. Values greater than 2^53 - 1 or less than -(2^53 - 1) may lose precision when read."
+        "INT64 type is not fully supported on this platform. Values greater than 2^53 - 1 or less than -(2^53 - 1) may lose precision when read.",
       );
       typedArray = new Uint8Array(
         bufferView.buffer,
         bufferView.byteOffset,
-        length * 8
+        length * 8,
       );
       getFunction = function (index) {
         return getInt64NumberFallback(index, that);
@@ -777,7 +777,7 @@ function BufferView(bufferView, componentType, length) {
       typedArray = new Uint8Array(
         bufferView.buffer,
         bufferView.byteOffset,
-        length * 8
+        length * 8,
       );
       getFunction = function (index) {
         return getInt64BigIntFallback(index, that);
@@ -787,7 +787,7 @@ function BufferView(bufferView, componentType, length) {
       typedArray = new BigInt64Array(
         bufferView.buffer,
         bufferView.byteOffset,
-        length
+        length,
       );
       setFunction = function (index, value) {
         // Convert the number to a BigInt before setting the value in the typed array
@@ -797,12 +797,12 @@ function BufferView(bufferView, componentType, length) {
   } else if (componentType === MetadataComponentType.UINT64) {
     if (!FeatureDetection.supportsBigInt()) {
       oneTimeWarning(
-        "UINT64 type is not fully supported on this platform. Values greater than 2^53 - 1 may lose precision when read."
+        "UINT64 type is not fully supported on this platform. Values greater than 2^53 - 1 may lose precision when read.",
       );
       typedArray = new Uint8Array(
         bufferView.buffer,
         bufferView.byteOffset,
-        length * 8
+        length * 8,
       );
       getFunction = function (index) {
         return getUint64NumberFallback(index, that);
@@ -811,7 +811,7 @@ function BufferView(bufferView, componentType, length) {
       typedArray = new Uint8Array(
         bufferView.buffer,
         bufferView.byteOffset,
-        length * 8
+        length * 8,
       );
       getFunction = function (index) {
         return getUint64BigIntFallback(index, that);
@@ -821,7 +821,7 @@ function BufferView(bufferView, componentType, length) {
       typedArray = new BigUint64Array(
         bufferView.buffer,
         bufferView.byteOffset,
-        length
+        length,
       );
       setFunction = function (index, value) {
         // Convert the number to a BigInt before setting the value in the typed array
@@ -834,7 +834,7 @@ function BufferView(bufferView, componentType, length) {
       componentDatatype,
       bufferView.buffer,
       bufferView.byteOffset,
-      length
+      length,
     );
     setFunction = function (index, value) {
       that.typedArray[index] = value;

package/Source/Scene/Model/AlphaPipelineStage.js

@@ -36,12 +36,12 @@ AlphaPipelineStage.process = function (renderResources, primitive, frameState) {
     shaderBuilder.addDefine(
       "ALPHA_MODE_MASK",
       undefined,
-      ShaderDestination.FRAGMENT
+      ShaderDestination.FRAGMENT,
     );
     shaderBuilder.addUniform(
       "float",
       "u_alphaCutoff",
-      ShaderDestination.FRAGMENT
+      ShaderDestination.FRAGMENT,
     );
     uniformMap.u_alphaCutoff = function () {
       return alphaOptions.alphaCutoff;

package/Source/Scene/Model/AtmospherePipelineStage.js

@@ -16,18 +16,23 @@ const AtmospherePipelineStage = {
   name: "AtmospherePipelineStage", // Helps with debugging
 };
 
+/**
+ * @param {ModelRenderResources} modelRenderResources
+ * @param {Model} model
+ * @param {FrameState} frameState
+ */
 AtmospherePipelineStage.process = function (
-  renderResources,
+  modelRenderResources,
   model,
-  frameState
+  frameState,
 ) {
-  const shaderBuilder = renderResources.shaderBuilder;
+  const shaderBuilder = modelRenderResources.shaderBuilder;
 
   shaderBuilder.addDefine("HAS_ATMOSPHERE", undefined, ShaderDestination.BOTH);
   shaderBuilder.addDefine(
     "COMPUTE_POSITION_WC_ATMOSPHERE",
     undefined,
-    ShaderDestination.BOTH
+    ShaderDestination.BOTH,
   );
 
   shaderBuilder.addVarying("vec3", "v_atmosphereRayleighColor");
@@ -37,17 +42,17 @@ AtmospherePipelineStage.process = function (
   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
+  // Add a uniform so fog is only calculated when the effect 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 () {
+  modelRenderResources.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
+      model.boundingSphere.center,
     );
 
     return (

package/Source/Scene/Model/B3dmLoader.js

@@ -66,24 +66,24 @@ function B3dmLoader(options) {
   const asynchronous = defaultValue(options.asynchronous, true);
   const incrementallyLoadTextures = defaultValue(
     options.incrementallyLoadTextures,
-    true
+    true,
   );
   const upAxis = defaultValue(options.upAxis, Axis.Y);
   const forwardAxis = defaultValue(options.forwardAxis, Axis.X);
   const loadAttributesAsTypedArray = defaultValue(
     options.loadAttributesAsTypedArray,
-    false
+    false,
   );
   const loadAttributesFor2D = defaultValue(options.loadAttributesFor2D, false);
   const enablePick = defaultValue(options.enablePick, false);
   const loadIndicesForWireframe = defaultValue(
     options.loadIndicesForWireframe,
-    false
+    false,
   );
   const loadPrimitiveOutline = defaultValue(options.loadPrimitiveOutline, true);
   const loadForClassification = defaultValue(
     options.loadForClassification,
-    false
+    false,
   );
 
   //>>includeStart('debug', pragmas.debug);
@@ -196,7 +196,7 @@ B3dmLoader.prototype.load = function () {
 
   const featureTable = new Cesium3DTileFeatureTable(
     featureTableJson,
-    featureTableBinary
+    featureTableBinary,
   );
   batchLength = featureTable.getGlobalProperty("BATCH_LENGTH");
   // Set batch length.
@@ -205,7 +205,7 @@ B3dmLoader.prototype.load = function () {
   const rtcCenter = featureTable.getGlobalProperty(
     "RTC_CENTER",
     ComponentDatatype.FLOAT,
-    3
+    3,
   );
   if (defined(rtcCenter)) {
     this._transform = Matrix4.fromTranslation(Cartesian3.fromArray(rtcCenter));
@@ -293,7 +293,7 @@ B3dmLoader.prototype.process = function (frameState) {
   components.transform = Matrix4.multiplyTransformation(
     this._transform,
     components.transform,
-    components.transform
+    components.transform,
   );
   createStructuralMetadata(this, components);
   this._components = components;
@@ -354,7 +354,7 @@ function processNode(node) {
     const primitive = node.primitives[i];
     const featureIdVertexAttribute = ModelUtility.getAttributeBySemantic(
       primitive,
-      VertexAttributeSemantic.FEATURE_ID
+      VertexAttributeSemantic.FEATURE_ID,
     );
     if (defined(featureIdVertexAttribute)) {
       featureIdVertexAttribute.setIndex = 0;

package/Source/Scene/Model/BatchTexturePipelineStage.js

@@ -25,7 +25,7 @@ const BatchTexturePipelineStage = {
 BatchTexturePipelineStage.process = function (
   renderResources,
   primitive,
-  frameState
+  frameState,
 ) {
   const shaderBuilder = renderResources.shaderBuilder;
   const batchTextureUniforms = {};
@@ -65,7 +65,7 @@ BatchTexturePipelineStage.process = function (
 
   renderResources.uniformMap = combine(
     batchTextureUniforms,
-    renderResources.uniformMap
+    renderResources.uniformMap,
   );
 };
 

package/Source/Scene/Model/CPUStylingPipelineStage.js

@@ -35,7 +35,7 @@ const CPUStylingPipelineStage = {
 CPUStylingPipelineStage.process = function (
   renderResources,
   primitive,
-  frameState
+  frameState,
 ) {
   const model = renderResources.model;
   const shaderBuilder = renderResources.shaderBuilder;
@@ -50,14 +50,14 @@ CPUStylingPipelineStage.process = function (
     shaderBuilder.addUniform(
       "float",
       ModelColorPipelineStage.COLOR_BLEND_UNIFORM_NAME,
-      ShaderDestination.FRAGMENT
+      ShaderDestination.FRAGMENT,
     );
     renderResources.uniformMap[
       ModelColorPipelineStage.COLOR_BLEND_UNIFORM_NAME
     ] = function () {
       return ColorBlendMode.getColorBlend(
         model.colorBlendMode,
-        model.colorBlendAmount
+        model.colorBlendAmount,
       );
     };
   }
@@ -65,7 +65,7 @@ CPUStylingPipelineStage.process = function (
   shaderBuilder.addUniform(
     "bool",
     "model_commandTranslucent",
-    ShaderDestination.BOTH
+    ShaderDestination.BOTH,
   );
   renderResources.uniformMap.model_commandTranslucent = function () {
     // Always check the current value, because custom shaders may