@cesium/engine 10.1.0 → 11.1.0

package/Source/Scene/Model/Extensions/Gpm/PpeSource.js

@@ -0,0 +1,75 @@
+/**
+ * An enum of per-point error sources.
+ *
+ * This reflects the `ppeMetadata.source` definition of the
+ * {@link https://nsgreg.nga.mil/csmwg.jsp|NGA_gpm_local} glTF extension.
+ *
+ * @enum {string}
+ * @private
+ */
+const PpeSource = {
+  /**
+   * The PPE standard deviation of error in the x dimension of the MCS (sigma x). Value will be squared
+   * and used to populate the (1,1) element in the PPE covariance matrix.
+   *
+   * @type {string}
+   * @constant
+   */
+  SIGX: "SIGX",
+
+  /**
+   * The PPE standard deviation of error in the y dimension of the MCS (sigma y). Value will be squared
+   * and used to populate the (2,2) element in the PPE covariance matrix.
+   *
+   * @type {string}
+   * @constant
+   */
+  SIGY: "SIGY",
+
+  /**
+   * The PPE standard deviation of error in the z dimension of the MCS (sigma z). Value will be squared
+   * and used to populate the (3,3) element in the PPE covariance matrix.
+   *
+   * @type {string}
+   * @constant
+   */
+  SIGZ: "SIGZ",
+
+  /**
+   * The PPE variance of error in the x dimension of the MCS (sigma x2). Value will be used to populate
+   * the (1,1) element in the PPE covariance matrix.
+   *
+   * @type {string}
+   * @constant
+   */
+  VARX: "VARX",
+
+  /**
+   * The PPE variance of error in the y dimension of the MCS (sigma y2). Value will be used to populate
+   * the (2,2) element in the PPE covariance matrix.
+   *
+   * @type {string}
+   * @constant
+   */
+  VARY: "VARY",
+
+  /**
+   * The PPE variance of error in the z dimension of the MCS (sigma z2). Value will be used to populate
+   * the (3,3) element in the PPE covariance matrix.
+   *
+   * @type {string}
+   * @constant
+   */
+  VARZ: "VARZ",
+
+  /**
+   * The PPE radial error in the horizontal dimension (x-y) of the MCS (sigma radial) . Value will be squared
+   * and used to populate the (1,1) and (2,2) element in the PPE covariance matrix.
+   *
+   * @type {string}
+   * @constant
+   */
+  SIGR: "VARZ",
+};
+
+export default Object.freeze(PpeSource);

package/Source/Scene/Model/Extensions/Gpm/PpeTexture.js

@@ -0,0 +1,127 @@
+import Check from "../../../../Core/Check.js";
+
+/**
+ * @typedef {object} PpeTexture.ConstructorOptions
+ *
+ * Initialization options for the PpeTexture constructor
+ *
+ * @property {PpeMetadata} traits The traits that indicate which data is stored in this texture
+ * @property {number} index The index of the texture inside the glTF textures array
+ * @property {number|undefined} [texCoord] The optional set index for the TEXCOORD attribute
+ * @property {number|undefined} [noData] The value to represent missing data
+ * @property {number|undefined} [offset] An offset to apply to property values.
+ * @property {number|undefined} [scale] A scale to apply to property values.
+ */
+
+/**
+ * PPE (Per-Point Error) texture in `NGA_gpm_local`.
+ *
+ * This reflects the `ppeTexture` definition of the
+ * {@link https://nsgreg.nga.mil/csmwg.jsp|NGA_gpm_local} glTF extension.
+ *
+ * This is a valid glTF `TextureInfo` object (with a required `index`
+ * and an optional `texCoord)`, with additional properties that
+ * describe the structure of the metdata that is stored in the texture.
+ *
+ * @constructor
+ * @param {PpeTexture.ConstructorOptions} options An object describing initialization options
+ *
+ * @private
+ */
+function PpeTexture(options) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("options.traits", options.traits);
+  Check.typeOf.number.greaterThanOrEquals("options.index", options.index, 0);
+  //>>includeEnd('debug');
+
+  this._traits = options.traits;
+  this._noData = options.noData;
+  this._offset = options.offset;
+  this._scale = options.scale;
+  this._index = options.index;
+  this._texCoord = options.texCoord;
+}
+
+Object.defineProperties(PpeTexture.prototype, {
+  /**
+   * The data contained here applies to this node and corresponding
+   * texture.
+   *
+   * @memberof PpeTexture.prototype
+   * @type {PpeMetadata}
+   * @readonly
+   */
+  traits: {
+    get: function () {
+      return this._traits;
+    },
+  },
+
+  /**
+   * A value to represent missing data - also known as a sentinel value -
+   * wherever it appears.
+   *
+   * @memberof PpeTexture.prototype
+   * @type {number|undefined}
+   * @readonly
+   */
+  noData: {
+    get: function () {
+      return this._noData;
+    },
+  },
+
+  /**
+   * An offset to apply to property values.
+   *
+   * @memberof PpeTexture.prototype
+   * @type {number|undefined}
+   * @readonly
+   */
+  offset: {
+    get: function () {
+      return this._offset;
+    },
+  },
+
+  /**
+   * An scale to apply to property values.
+   *
+   * @memberof PpeTexture.prototype
+   * @type {number|undefined}
+   * @readonly
+   */
+  scale: {
+    get: function () {
+      return this._scale;
+    },
+  },
+
+  /**
+   * The index of the texture
+   *
+   * @memberof PpeTexture.prototype
+   * @type {number}
+   * @readonly
+   */
+  index: {
+    get: function () {
+      return this._index;
+    },
+  },
+
+  /**
+   * The set index of texture's TEXCOORD attribute used for texture coordinate mapping.
+   *
+   * @memberof PpeTexture.prototype
+   * @type {number|undefined}
+   * @readonly
+   */
+  texCoord: {
+    get: function () {
+      return this._texCoord;
+    },
+  },
+});
+
+export default PpeTexture;

package/Source/Scene/Model/Extensions/Gpm/Spdcf.js

@@ -0,0 +1,103 @@
+import Check from "../../../../Core/Check.js";
+
+/**
+ * @typedef {object} Spdcf.ConstructorOptions
+ *
+ * Initialization options for the Spdcf constructor
+ *
+ * @property {number} A The factor A, in (0, 1]
+ * @property {number} alpha The alpha value, in [0, 1)
+ * @property {number} beta The beta value, in [0, 10]
+ * @property {number} T the tau value, in (0, +inf)
+ */
+
+/**
+ * Variables for a Strictly Positive-Definite Correlation Function.
+ *
+ * This reflects the `spdcf` definition of the
+ * {@link https://nsgreg.nga.mil/csmwg.jsp|NGA_gpm_local} glTF extension.
+ * Instances of this type are stored as the parameters within a
+ * `CorrelationGroup`.
+ *
+ * Parameters (A, alpha, beta, T) describe the correlation decrease
+ * between points as a function of delta time:
+ * ```
+ * spdcf(delta_t) = A_t * (alpha_t + ((1 - alpha_t)(1 + beta_t)) / (beta_t + e^(delta_t/T_t)))
+ * ```
+ *
+ * @constructor
+ * @param {Spdcf.ConstructorOptions} options An object describing initialization options
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ */
+function Spdcf(options) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.number.greaterThan("options.A", options.A, 0.0);
+  Check.typeOf.number.lessThanOrEquals("options.A", options.A, 1.0);
+  Check.typeOf.number.greaterThanOrEquals("options.alpha", options.alpha, 0.0);
+  Check.typeOf.number.lessThan("options.alpha", options.alpha, 1.0);
+  Check.typeOf.number.greaterThanOrEquals("options.beta", options.beta, 0.0);
+  Check.typeOf.number.lessThanOrEquals("options.beta", options.beta, 10.0);
+  Check.typeOf.number.greaterThan("options.T", options.T, 0.0);
+  //>>includeEnd('debug');
+
+  this._A = options.A;
+  this._alpha = options.alpha;
+  this._beta = options.beta;
+  this._T = options.T;
+}
+
+Object.defineProperties(Spdcf.prototype, {
+  /**
+   * In (0, 1]
+   *
+   * @memberof Spdcf.prototype
+   * @type {number}
+   * @readonly
+   */
+  A: {
+    get: function () {
+      return this._A;
+    },
+  },
+
+  /**
+   * In [0, 1)
+   *
+   * @memberof Spdcf.prototype
+   * @type {number}
+   * @readonly
+   */
+  alpha: {
+    get: function () {
+      return this._alpha;
+    },
+  },
+
+  /**
+   * In [0, 10]
+   *
+   * @memberof Spdcf.prototype
+   * @type {number}
+   * @readonly
+   */
+  beta: {
+    get: function () {
+      return this._beta;
+    },
+  },
+
+  /**
+   * In (0, +inf)
+   *
+   * @memberof Spdcf.prototype
+   * @type {number}
+   * @readonly
+   */
+  T: {
+    get: function () {
+      return this._T;
+    },
+  },
+});
+
+export default Spdcf;

package/Source/Scene/Model/Extensions/Gpm/StorageType.js

@@ -0,0 +1,30 @@
+/**
+ * An enum of storage types for covariance information.
+ *
+ * This reflects the `gltfGpmLocal.storageType` definition of the
+ * {@link https://nsgreg.nga.mil/csmwg.jsp|NGA_gpm_local} glTF extension.
+ *
+ * @enum {string}
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ */
+const StorageType = {
+  /**
+   * Store the full error covariance of the anchor points, to include the cross-covariance terms
+   *
+   * @type {string}
+   * @constant
+   */
+  Direct: "Direct",
+
+  /**
+   * A full covariance matrix is stored for each of the anchor points. However, in this case the
+   * cross-covariance terms are not directly stored, but can be computed by a set of spatial
+   * correlation function parameters which are stored in the metadata.
+   *
+   * @type {string}
+   * @constant
+   */
+  Indirect: "Indirect",
+};
+
+export default Object.freeze(StorageType);

package/Source/Scene/Model/FeatureIdPipelineStage.js

@@ -53,7 +53,7 @@ const FeatureIdPipelineStage = {
 FeatureIdPipelineStage.process = function (
   renderResources,
   primitive,
-  frameState
+  frameState,
 ) {
   const shaderBuilder = renderResources.shaderBuilder;
   declareStructsAndFunctions(shaderBuilder);
@@ -75,12 +75,12 @@ function declareStructsAndFunctions(shaderBuilder) {
   shaderBuilder.addStruct(
     FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_VS,
     FeatureIdPipelineStage.STRUCT_NAME_FEATURE_IDS,
-    ShaderDestination.VERTEX
+    ShaderDestination.VERTEX,
   );
   shaderBuilder.addStruct(
     FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_FS,
     FeatureIdPipelineStage.STRUCT_NAME_FEATURE_IDS,
-    ShaderDestination.FRAGMENT
+    ShaderDestination.FRAGMENT,
   );
 
   // declare the initializeFeatureIds() function. The details may differ
@@ -88,12 +88,12 @@ function declareStructsAndFunctions(shaderBuilder) {
   shaderBuilder.addFunction(
     FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_VS,
     FeatureIdPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_FEATURE_IDS,
-    ShaderDestination.VERTEX
+    ShaderDestination.VERTEX,
   );
   shaderBuilder.addFunction(
     FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_FS,
     FeatureIdPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_FEATURE_IDS,
-    ShaderDestination.FRAGMENT
+    ShaderDestination.FRAGMENT,
   );
 
   // declare the initializeFeatureIdAliases() function. The details may differ
@@ -101,19 +101,19 @@ function declareStructsAndFunctions(shaderBuilder) {
   shaderBuilder.addFunction(
     FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_ID_ALIASES_VS,
     FeatureIdPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_FEATURE_ID_ALIASES,
-    ShaderDestination.VERTEX
+    ShaderDestination.VERTEX,
   );
   shaderBuilder.addFunction(
     FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_ID_ALIASES_FS,
     FeatureIdPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_FEATURE_ID_ALIASES,
-    ShaderDestination.FRAGMENT
+    ShaderDestination.FRAGMENT,
   );
 
   // declare the setFeatureIdVaryings() function in the vertex shader only
   shaderBuilder.addFunction(
     FeatureIdPipelineStage.FUNCTION_ID_SET_FEATURE_ID_VARYINGS,
     FeatureIdPipelineStage.FUNCTION_SIGNATURE_SET_FEATURE_ID_VARYINGS,
-    ShaderDestination.VERTEX
+    ShaderDestination.VERTEX,
   );
 }
 
@@ -135,7 +135,7 @@ function processInstanceFeatureIds(renderResources, instances, frameState) {
         variableName,
         count,
         instanceDivisor,
-        frameState
+        frameState,
       );
     }
 
@@ -150,7 +150,7 @@ function processPrimitiveFeatureIds(renderResources, primitive, frameState) {
   const featureIdsArray = primitive.featureIds;
   const positionAttribute = ModelUtility.getAttributeBySemantic(
     primitive,
-    VertexAttributeSemantic.POSITION
+    VertexAttributeSemantic.POSITION,
   );
   const count = positionAttribute.count;
 
@@ -168,7 +168,7 @@ function processPrimitiveFeatureIds(renderResources, primitive, frameState) {
         variableName,
         count,
         undefined,
-        frameState
+        frameState,
       );
     } else {
       processTexture(renderResources, featureIds, variableName, i, frameState);
@@ -185,7 +185,7 @@ function processPrimitiveFeatureIds(renderResources, primitive, frameState) {
 function processInstanceAttribute(
   renderResources,
   featureIdAttribute,
-  variableName
+  variableName,
 ) {
   // Add a field to the FeatureIds struct.
   // Example:
@@ -198,12 +198,12 @@ function processInstanceAttribute(
   shaderBuilder.addStructField(
     FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_VS,
     "int",
-    variableName
+    variableName,
   );
   shaderBuilder.addStructField(
     FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_FS,
     "int",
-    variableName
+    variableName,
   );
 
   // Initialize the field from the corresponding attribute.
@@ -218,11 +218,11 @@ function processInstanceAttribute(
 
   shaderBuilder.addFunctionLines(
     FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_VS,
-    [vertexLine]
+    [vertexLine],
   );
   shaderBuilder.addFunctionLines(
     FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_FS,
-    [fragmentLine]
+    [fragmentLine],
   );
 
   // Instanced attributes don't normally need varyings, so add one here
@@ -233,7 +233,7 @@ function processInstanceAttribute(
   // v_instanceFeatureId_n = a_instanceFeatureId_n;
   shaderBuilder.addFunctionLines(
     FeatureIdPipelineStage.FUNCTION_ID_SET_FEATURE_ID_VARYINGS,
-    [`${varyingName} = ${attributeName};`]
+    [`${varyingName} = ${attributeName};`],
   );
 }
 
@@ -249,12 +249,12 @@ function processAttribute(renderResources, featureIdAttribute, variableName) {
   shaderBuilder.addStructField(
     FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_VS,
     "int",
-    variableName
+    variableName,
   );
   shaderBuilder.addStructField(
     FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_FS,
     "int",
-    variableName
+    variableName,
   );
 
   // Initialize the field from the corresponding attribute.
@@ -269,11 +269,11 @@ function processAttribute(renderResources, featureIdAttribute, variableName) {
   ];
   shaderBuilder.addFunctionLines(
     FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_VS,
-    initializationLines
+    initializationLines,
   );
   shaderBuilder.addFunctionLines(
     FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_FS,
-    initializationLines
+    initializationLines,
   );
 }
 
@@ -283,7 +283,7 @@ function processImplicitRange(
   variableName,
   count,
   instanceDivisor,
-  frameState
+  frameState,
 ) {
   // Generate a vertex attribute for the implicit IDs since WebGL 1 does not
   // support gl_VertexID
@@ -292,7 +292,7 @@ function processImplicitRange(
     implicitFeatureIds,
     count,
     instanceDivisor,
-    frameState
+    frameState,
   );
 
   // Declare the vertex attribute in the shader
@@ -316,12 +316,12 @@ function processImplicitRange(
   shaderBuilder.addStructField(
     FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_VS,
     "int",
-    variableName
+    variableName,
   );
   shaderBuilder.addStructField(
     FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_FS,
     "int",
-    variableName
+    variableName,
   );
 
   // The varying needs initialization in the vertex shader
@@ -329,7 +329,7 @@ function processImplicitRange(
   // v_implicit_featureId_n = a_implicit_featureId_n;
   shaderBuilder.addFunctionLines(
     FeatureIdPipelineStage.FUNCTION_ID_SET_FEATURE_ID_VARYINGS,
-    [`${implicitVaryingName} = ${implicitAttributeName};`]
+    [`${implicitVaryingName} = ${implicitAttributeName};`],
   );
 
   // Initialize the field from the generated attribute/varying.
@@ -338,11 +338,11 @@ function processImplicitRange(
   // featureIds.featureId_n = v_implicit_featureId_n; (FS)
   shaderBuilder.addFunctionLines(
     FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_VS,
-    [`featureIds.${variableName} = int(czm_round(${implicitAttributeName}));`]
+    [`featureIds.${variableName} = int(czm_round(${implicitAttributeName}));`],
   );
   shaderBuilder.addFunctionLines(
     FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_FS,
-    [`featureIds.${variableName} = int(czm_round(${implicitVaryingName}));`]
+    [`featureIds.${variableName} = int(czm_round(${implicitVaryingName}));`],
   );
 }
 
@@ -351,7 +351,7 @@ function processTexture(
   featureIdTexture,
   variableName,
   index,
-  frameState
+  frameState,
 ) {
   // Create the feature ID texture uniform. The index matches the index from
   // the featureIds array, even if this is not consecutive.
@@ -361,7 +361,7 @@ function processTexture(
   uniformMap[uniformName] = function () {
     return defaultValue(
       textureReader.texture,
-      frameState.context.defaultTexture
+      frameState.context.defaultTexture,
     );
   };
 
@@ -378,14 +378,14 @@ function processTexture(
   shaderBuilder.addStructField(
     FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_FS,
     "int",
-    variableName
+    variableName,
   );
 
   // Declare the uniform in the fragment shader
   shaderBuilder.addUniform(
     "sampler2D",
     uniformName,
-    ShaderDestination.FRAGMENT
+    ShaderDestination.FRAGMENT,
   );
 
   // Get a GLSL expression for the texture coordinates
@@ -401,7 +401,7 @@ function processTexture(
     shaderBuilder.addUniform(
       "mat3",
       transformUniformName,
-      ShaderDestination.FRAGMENT
+      ShaderDestination.FRAGMENT,
     );
     uniformMap[transformUniformName] = function () {
       return transform;
@@ -421,7 +421,7 @@ function processTexture(
 
   shaderBuilder.addFunctionLines(
     FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_FS,
-    [initializationLine]
+    [initializationLine],
   );
 }
 
@@ -439,13 +439,13 @@ function addAlias(renderResources, variableName, alias, shaderDestination) {
     shaderBuilder.addStructField(
       FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_VS,
       "int",
-      alias
+      alias,
     );
   }
   shaderBuilder.addStructField(
     FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_FS,
     "int",
-    alias
+    alias,
   );
 
   // Initialize the field from the original variable
@@ -456,12 +456,12 @@ function addAlias(renderResources, variableName, alias, shaderDestination) {
   if (updateVS) {
     shaderBuilder.addFunctionLines(
       FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_ID_ALIASES_VS,
-      initializationLines
+      initializationLines,
     );
   }
   shaderBuilder.addFunctionLines(
     FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_ID_ALIASES_FS,
-    initializationLines
+    initializationLines,
   );
 }
 
@@ -470,7 +470,7 @@ function generateImplicitFeatureIdAttribute(
   implicitFeatureIds,
   count,
   instanceDivisor,
-  frameState
+  frameState,
 ) {
   const model = renderResources.model;
   let vertexBuffer;
@@ -478,7 +478,7 @@ function generateImplicitFeatureIdAttribute(
   if (defined(implicitFeatureIds.repeat)) {
     const typedArray = generateImplicitFeatureIdTypedArray(
       implicitFeatureIds,
-      count
+      count,
     );
     vertexBuffer = Buffer.createVertexBuffer({
       context: frameState.context,