@cesium/engine 22.2.0 → 23.0.0

package/Source/Scene/Model/CustomShaderPipelineStage.js

@@ -95,7 +95,11 @@ CustomShaderPipelineStage.process = function (
 
   // Generate lines of code for the shader, but don't add them to the shader
   // yet.
-  const generatedCode = generateShaderLines(customShader, primitive);
+  const generatedCode = generateShaderLines(
+    customShader,
+    primitive,
+    renderResources,
+  );
 
   // In some corner cases, the primitive may not be compatible with the
   // shader. In this case, skip the custom shader.
@@ -221,14 +225,26 @@ function inferAttributeDefaults(attributeName) {
  * @private
  * @param {CustomShader} customShader
  * @param {Object<string, ModelComponents.Attribute>} attributesByName
+ * @param {Set<string>} primitivePropertyIds all property IDs referenced by the primitive being processed, across all its property textures, property attributes, and property tables.
  * @returns {object}
  */
-function generateVertexShaderLines(customShader, attributesByName) {
+function generateVertexShaderLines(
+  customShader,
+  attributesByName,
+  primitivePropertyIds,
+) {
   if (!defined(customShader.vertexShaderText)) {
     return { enabled: false };
   }
 
-  const primitiveAttributes = customShader.usedVariablesVertex.attributeSet;
+  const usedVariables = customShader.usedVariablesVertex;
+  if (
+    !checkMetadataCompatibility(usedVariables.metadataSet, primitivePropertyIds)
+  ) {
+    return { enabled: false };
+  }
+
+  const primitiveAttributes = usedVariables.attributeSet;
   const addToShader = getPrimitiveAttributesUsedInShader(
     attributesByName,
     primitiveAttributes,
@@ -318,14 +334,28 @@ function generatePositionBuiltins(customShader) {
  * @private
  * @param {CustomShader} customShader
  * @param {Object<string, ModelComponents.Attribute>} attributesByName
+ * @param {PrimitiveRenderResources} renderResources
+ * @param {ModelComponents.Primitive} primitive
+ * @param {Set<string>} primitivePropertyIds all property IDs referenced by the primitive being processed, across all its property textures, property attributes, and property tables.
  * @returns {object}
  */
-function generateFragmentShaderLines(customShader, attributesByName) {
+function generateFragmentShaderLines(
+  customShader,
+  attributesByName,
+  primitivePropertyIds,
+) {
   if (!defined(customShader.fragmentShaderText)) {
     return { enabled: false };
   }
 
-  const primitiveAttributes = customShader.usedVariablesFragment.attributeSet;
+  const usedVariables = customShader.usedVariablesFragment;
+  if (
+    !checkMetadataCompatibility(usedVariables.metadataSet, primitivePropertyIds)
+  ) {
+    return { enabled: false };
+  }
+
+  const primitiveAttributes = usedVariables.attributeSet;
   const addToShader = getPrimitiveAttributesUsedInShader(
     attributesByName,
     primitiveAttributes,
@@ -477,16 +507,26 @@ function getAttributesNeedingDefaults(
  * @private
  * @param {CustomShader} customShader
  * @param {ModelComponents.Primitive} primitive
+ * @param {PrimitiveRenderResources} renderResources
  * @returns {object}
  */
-function generateShaderLines(customShader, primitive) {
+function generateShaderLines(customShader, primitive, renderResources) {
   // Attempt to generate vertex and fragment shader lines before adding any
   // code to the shader.
   const attributesByName = getAttributesByName(primitive.attributes);
-  const vertexLines = generateVertexShaderLines(customShader, attributesByName);
+  const primitivePropertyIds = getAllPropertyIds(
+    primitive,
+    renderResources.model.structuralMetadata,
+  );
+  const vertexLines = generateVertexShaderLines(
+    customShader,
+    attributesByName,
+    primitivePropertyIds,
+  );
   const fragmentLines = generateFragmentShaderLines(
     customShader,
     attributesByName,
+    primitivePropertyIds,
   );
 
   // positionWC must be computed in the vertex shader
@@ -664,4 +704,79 @@ function addLinesToShader(shaderBuilder, customShader, generatedCode) {
   }
 }
 
+/**
+ * Get all property IDs a given primitive references (whether or not used in the shader).
+ *
+ * @param {StructuralMetadata} structuralMetadata the structural metadata for the primitive being processed
+ * @param {ModelComponents.Primitive} primitive the primitive being processed by this stage
+ *
+ * @returns {Set<string>} a set of all property IDs the primitive references
+ *
+ * @private
+ */
+function getAllPropertyIds(primitive, structuralMetadata) {
+  if (!defined(structuralMetadata)) {
+    return new Set();
+  }
+
+  const usedPropertyTextures = primitive.propertyTextureIds;
+  const usedPropertyAttributes = primitive.propertyAttributeIds;
+  const usedPropertyTables = defined(primitive.featureIds)
+    ? primitive.featureIds.map((featureId) => featureId.propertyTableId)
+    : [];
+
+  const primitivePropertyIds = new Set();
+
+  function addUsedPropertyIds(propertyContainerIds, propertyContainers) {
+    for (const id of propertyContainerIds) {
+      const propertyContainer = propertyContainers[id];
+      Object.keys(propertyContainer.properties).forEach((propertyId) =>
+        primitivePropertyIds.add(propertyId),
+      );
+    }
+  }
+
+  addUsedPropertyIds(usedPropertyTextures, structuralMetadata.propertyTextures);
+  addUsedPropertyIds(
+    usedPropertyAttributes,
+    structuralMetadata.propertyAttributes,
+  );
+  addUsedPropertyIds(usedPropertyTables, structuralMetadata.propertyTables);
+
+  return primitivePropertyIds;
+}
+
+/**
+ * Because all primitives in a tileset share the same shader, but not necessarily the same
+ * metadata schema, not all primitives will be compatible with the custom shader. This is expected-
+ * it should not cause a fatal error (compilation failure), but instead should disable the custom shader for this primitive.
+ *
+ * @param {Object<string, boolean>} metadataPropertiesUsedInShader the set of metadata properties used in the shader (see CustomShader.js)
+ * @param {Set<string>} primitivePropertyIds the set of all metadata property IDs used in the primitive being processed
+ *
+ * @returns {boolean} true if all metadata properties used in the shader exist on the primitive, false otherwise
+ *
+ * @private
+ */
+function checkMetadataCompatibility(
+  metadataPropertiesUsedInShader,
+  primitivePropertyIds,
+) {
+  for (const propertyName in metadataPropertiesUsedInShader) {
+    if (!metadataPropertiesUsedInShader.hasOwnProperty(propertyName)) {
+      continue;
+    }
+
+    if (!primitivePropertyIds.has(propertyName)) {
+      CustomShaderPipelineStage._oneTimeWarning(
+        "CustomShaderPipelineStage.checkMetadataCompatibility",
+        `A custom shader uses metadata property "${propertyName}" which is not present for all primitives in the tileset. Disabling the custom shader for these primitives.`,
+      );
+      return false;
+    }
+  }
+
+  return true;
+}
+
 export default CustomShaderPipelineStage;

package/Source/Scene/Model/GeoJsonLoader.js

@@ -33,31 +33,26 @@ import addAllToArray from "../../Core/addAllToArray.js";
  * Implements the {@link ResourceLoader} interface.
  * </p>
  *
- * @alias GeoJsonLoader
- * @constructor
- * @augments ResourceLoader
  * @private
- *
- * @param {object} options Object with the following properties:
- * @param {object} options.geoJson The GeoJson object.
  */
-function GeoJsonLoader(options) {
-  options = options ?? Frozen.EMPTY_OBJECT;
+class GeoJsonLoader extends ResourceLoader {
+  /**
+   * @param {object} options Object with the following properties:
+   * @param {object} options.geoJson The GeoJson object.
+   */
+  constructor(options) {
+    super();
 
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("options.geoJson", options.geoJson);
-  //>>includeEnd('debug');
+    options = options ?? Frozen.EMPTY_OBJECT;
 
-  this._geoJson = options.geoJson;
-  this._components = undefined;
-}
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.object("options.geoJson", options.geoJson);
+    //>>includeEnd('debug');
 
-if (defined(Object.create)) {
-  GeoJsonLoader.prototype = Object.create(ResourceLoader.prototype);
-  GeoJsonLoader.prototype.constructor = GeoJsonLoader;
-}
+    this._geoJson = options.geoJson;
+    this._components = undefined;
+  }
 
-Object.defineProperties(GeoJsonLoader.prototype, {
   /**
    * The cache key of the resource.
    *
@@ -67,11 +62,10 @@ Object.defineProperties(GeoJsonLoader.prototype, {
    * @readonly
    * @private
    */
-  cacheKey: {
-    get: function () {
-      return undefined;
-    },
-  },
+  get cacheKey() {
+    return undefined;
+  }
+
   /**
    * The loaded components.
    *
@@ -81,41 +75,47 @@ Object.defineProperties(GeoJsonLoader.prototype, {
    * @readonly
    * @private
    */
-  components: {
-    get: function () {
-      return this._components;
-    },
-  },
-});
+  get components() {
+    return this._components;
+  }
 
-/**
- * Loads the resource.
- * @returns {Promise<GeoJsonLoader>} A promise which resolves to the loader when the resource loading is completed.
- * @private
- */
-GeoJsonLoader.prototype.load = function () {
-  return Promise.resolve(this);
-};
+  /**
+   * Loads the resource.
+   * @returns {Promise<GeoJsonLoader>} A promise which resolves to the loader when the resource loading is completed.
+   * @private
+   */
+  load() {
+    return Promise.resolve(this);
+  }
 
-/**
- * Processes the resource until it becomes ready.
- *
- * @param {FrameState} frameState The frame state.
- * @private
- */
-GeoJsonLoader.prototype.process = function (frameState) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("frameState", frameState);
-  //>>includeEnd('debug');
+  /**
+   * Processes the resource until it becomes ready.
+   *
+   * @param {FrameState} frameState The frame state.
+   * @private
+   */
+  process(frameState) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.object("frameState", frameState);
+    //>>includeEnd('debug');
+
+    if (defined(this._components)) {
+      return true;
+    }
 
-  if (defined(this._components)) {
+    this._components = parse(this._geoJson, frameState);
+    this._geoJson = undefined;
     return true;
   }
 
-  this._components = parse(this._geoJson, frameState);
-  this._geoJson = undefined;
-  return true;
-};
+  /**
+   * Unloads the resource.
+   * @private
+   */
+  unload() {
+    this._components = undefined;
+  }
+}
 
 function ParsedFeature() {
   this.lines = undefined;
@@ -686,12 +686,4 @@ function parse(geoJson, frameState) {
   return components;
 }
 
-/**
- * Unloads the resource.
- * @private
- */
-GeoJsonLoader.prototype.unload = function () {
-  this._components = undefined;
-};
-
 export default GeoJsonLoader;

package/Source/Scene/Model/GeometryPipelineStage.js

@@ -174,6 +174,14 @@ GeometryPipelineStage.process = function (
       index = renderResources.attributeIndex++;
     }
 
+    // Use flat interpolation for point primitive vertex attributes (only supported in WebGL 2)
+    const interpolationQualifier =
+      !isPositionAttribute &&
+      primitive.primitiveType === PrimitiveType.POINTS &&
+      frameState.context.webgl2
+        ? "flat"
+        : undefined;
+
     processAttribute(
       renderResources,
       attribute,
@@ -181,6 +189,7 @@ GeometryPipelineStage.process = function (
       attributeLocationCount,
       use2D,
       instanced,
+      interpolationQualifier,
     );
   }
 
@@ -201,6 +210,7 @@ function processAttribute(
   attributeLocationCount,
   use2D,
   instanced,
+  interpolationQualifier,
 ) {
   const shaderBuilder = renderResources.shaderBuilder;
   const attributeInfo = ModelUtility.getAttributeInfo(attribute);
@@ -227,7 +237,7 @@ function processAttribute(
   }
 
   addAttributeDeclaration(shaderBuilder, attributeInfo, modifyFor2D);
-  addVaryingDeclaration(shaderBuilder, attributeInfo);
+  addVaryingDeclaration(shaderBuilder, attributeInfo, interpolationQualifier);
 
   // For common attributes like normals and tangents, the code is
   // already in GeometryStageVS, we just need to enable it.
@@ -363,7 +373,11 @@ function addMatrixAttributeToRenderResources(
   }
 }
 
-function addVaryingDeclaration(shaderBuilder, attributeInfo) {
+function addVaryingDeclaration(
+  shaderBuilder,
+  attributeInfo,
+  interpolationQualifier,
+) {
   const variableName = attributeInfo.variableName;
   let varyingName = `v_${variableName}`;
 
@@ -383,7 +397,7 @@ function addVaryingDeclaration(shaderBuilder, attributeInfo) {
     glslType = attributeInfo.glslType;
   }
 
-  shaderBuilder.addVarying(glslType, varyingName);
+  shaderBuilder.addVarying(glslType, varyingName, interpolationQualifier);
 }
 
 function addAttributeDeclaration(shaderBuilder, attributeInfo, modifyFor2D) {