@cesium/engine 21.0.1-ion.0 → 22.0.0

package/Source/Scene/Model/MetadataPipelineStage.js

@@ -122,7 +122,7 @@ MetadataPipelineStage.process = function (
  * @param {PropertyAttribute[]} propertyAttributes The PropertyAttributes with properties to be described
  * @param {ModelComponents.Primitive} primitive The primitive to be rendered
  * @param {object} [statistics] Statistics about the properties (if the model is from a 3DTiles tileset)
- * @returns {Object[]} An array of objects containing information about each PropertyAttributeProperty
+ * @returns {object[]} An array of objects containing information about each PropertyAttributeProperty
  * @private
  */
 function getPropertyAttributesInfo(propertyAttributes, primitive, statistics) {
@@ -139,7 +139,7 @@ function getPropertyAttributesInfo(propertyAttributes, primitive, statistics) {
  * @param {PropertyAttribute} propertyAttribute The PropertyAttribute with properties to be described
  * @param {ModelComponents.Primitive} primitive The primitive to be rendered
  * @param {object} [statistics] Statistics about the properties (if the model is from a 3DTiles tileset)
- * @returns {Object[]} An array of objects containing information about each PropertyAttributeProperty
+ * @returns {object[]} An array of objects containing information about each PropertyAttributeProperty
  * @private
  */
 function getPropertyAttributeInfo(propertyAttribute, primitive, statistics) {
@@ -176,7 +176,7 @@ function getPropertyAttributeInfo(propertyAttribute, primitive, statistics) {
  * return as a flattened Array
  * @param {PropertyTexture[]} propertyTextures The PropertyTextures with properties to be described
  * @param {object} [statistics] Statistics about the properties (if the model is from a 3DTiles tileset)
- * @returns {Object[]} An array of objects containing information about each PropertyTextureProperty
+ * @returns {object[]} An array of objects containing information about each PropertyTextureProperty
  * @private
  */
 function getPropertyTexturesInfo(propertyTextures, statistics) {
@@ -192,7 +192,7 @@ function getPropertyTexturesInfo(propertyTextures, statistics) {
  * Collect info about the properties of a single PropertyTexture
  * @param {PropertyTexture} propertyTexture The PropertyTexture with properties to be described
  * @param {object} [statistics] Statistics about the properties (if the model is from a 3DTiles tileset)
- * @returns {Object[]} An array of objects containing information about each PropertyTextureProperty
+ * @returns {object[]} An array of objects containing information about each PropertyTextureProperty
  * @private
  */
 function getPropertyTextureInfo(propertyTexture, statistics) {
@@ -225,7 +225,7 @@ function getPropertyTextureInfo(propertyTexture, statistics) {
 /**
  * Declare <type>MetadataClass structs in the shader for each PropertyAttributeProperty and PropertyTextureProperty
  * @param {ShaderBuilder} shaderBuilder The shader builder for the primitive
- * @param {Object[]} propertyInfos Information about the PropertyAttributeProperties and PropertyTextureProperties
+ * @param {object[]} propertyInfos Information about the PropertyAttributeProperties and PropertyTextureProperties
  * @private
  */
 function declareMetadataTypeStructs(shaderBuilder, propertyInfos) {
@@ -408,7 +408,7 @@ function addPropertyAttributePropertyMetadata(renderResources, propertyInfo) {
 /**
  * Update the shader for a single PropertyTextureProperty
  * @param {PrimitiveRenderResources} renderResources The render resources for the primitive
- * @param {Object[]} propertyInfo Info about the PropertyTextureProperty
+ * @param {object[]} propertyInfo Info about the PropertyTextureProperty
  * @private
  */
 function processPropertyTextureProperty(renderResources, propertyInfo) {
@@ -596,7 +596,7 @@ function addPropertyMetadataStatistics(shaderBuilder, propertyInfo) {
 
 /**
  * Construct GLSL assignment statements to set metadata spec values in a struct
- * @param {Object[]} fieldNames An object with the following properties:
+ * @param {object[]} fieldNames An object with the following properties:
  * @param {string} fieldNames[].specName The name of the property in the spec
  * @param {string} fieldNames[].shaderName The name of the property in the shader
  * @param {object} values A source of property values, keyed on fieldNames[].specName

package/Source/Scene/Model/ModelDrawCommand.js

@@ -50,6 +50,9 @@ function ModelDrawCommand(options) {
   const runtimePrimitive = renderResources.runtimePrimitive;
   this._runtimePrimitive = runtimePrimitive;
 
+  // Store render resources for edge command creation
+  this._primitiveRenderResources = renderResources;
+
   // If the command is translucent, or if the primitive's material is
   // double-sided, then back-face culling is automatically disabled for
   // the command. The user value for back-face culling will be ignored.
@@ -73,6 +76,8 @@ function ModelDrawCommand(options) {
 
   const needsSilhouetteCommands = hasSilhouette;
 
+  const needsEdgeCommands = defined(renderResources.edgeGeometry);
+
   this._command = command;
 
   // None of the derived commands (non-2D) use a different model matrix
@@ -96,6 +101,7 @@ function ModelDrawCommand(options) {
   this._needsTranslucentCommand = needsTranslucentCommand;
   this._needsSkipLevelOfDetailCommands = needsSkipLevelOfDetailCommands;
   this._needsSilhouetteCommands = needsSilhouetteCommands;
+  this._needsEdgeCommands = needsEdgeCommands;
 
   // Derived commands
   this._originalCommand = undefined;
@@ -104,6 +110,7 @@ function ModelDrawCommand(options) {
   this._skipLodStencilCommand = undefined;
   this._silhouetteModelCommand = undefined;
   this._silhouetteColorCommand = undefined;
+  this._edgeCommand = undefined;
 
   // All derived commands (including 2D commands)
   this._derivedCommands = [];
@@ -215,6 +222,19 @@ function initialize(drawCommand) {
     derivedCommands.push(drawCommand._silhouetteModelCommand);
     derivedCommands.push(drawCommand._silhouetteColorCommand);
   }
+
+  if (drawCommand._needsEdgeCommands) {
+    const renderResources = drawCommand._primitiveRenderResources;
+    drawCommand._edgeCommand = new ModelDerivedCommand({
+      command: deriveEdgeCommand(command, renderResources, model),
+      updateShadows: false,
+      updateBackFaceCulling: false,
+      updateCullFace: false,
+      updateDebugShowBoundingVolume: false,
+    });
+
+    derivedCommands.push(drawCommand._edgeCommand);
+  }
 }
 
 Object.defineProperties(ModelDrawCommand.prototype, {
@@ -586,6 +606,24 @@ ModelDrawCommand.prototype.pushSilhouetteCommands = function (
   return result;
 };
 
+/**
+ * @param {FrameState} frameState The frame state.
+ * @param {DrawCommand[]} result The draw commands to push to.
+ * @returns {DrawCommand[]} The modified command list.
+ *
+ * @private
+ */
+ModelDrawCommand.prototype.pushEdgeCommands = function (frameState, result) {
+  if (!defined(this._edgeCommand)) {
+    return result;
+  }
+
+  const use2D = shouldUse2DCommands(this, frameState);
+  pushCommand(result, this._edgeCommand, use2D);
+
+  return result;
+};
+
 function pushCommand(commandList, derivedCommand, use2D) {
   commandList.push(derivedCommand.command);
   if (use2D) {
@@ -644,6 +682,7 @@ function derive2DCommands(drawCommand) {
   derive2DCommand(drawCommand, drawCommand._skipLodStencilCommand);
   derive2DCommand(drawCommand, drawCommand._silhouetteModelCommand);
   derive2DCommand(drawCommand, drawCommand._silhouetteColorCommand);
+  derive2DCommand(drawCommand, drawCommand._edgeCommand);
 }
 
 function deriveTranslucentCommand(command) {
@@ -752,6 +791,36 @@ function deriveSilhouetteColorCommand(command, model) {
   return silhouetteColorCommand;
 }
 
+function deriveEdgeCommand(command, renderResources) {
+  const edgeGeometry = renderResources.edgeGeometry;
+  const edgeCommand = DrawCommand.shallowClone(command);
+
+  // Use the edge geometry instead of the original geometry
+  edgeCommand.vertexArray = edgeGeometry.vertexArray;
+  edgeCommand.primitiveType = edgeGeometry.primitiveType;
+  edgeCommand.count = edgeGeometry.indexCount;
+
+  // Use the edge shader program if available
+  if (defined(edgeGeometry.shaderProgram)) {
+    edgeCommand.shaderProgram = edgeGeometry.shaderProgram;
+  }
+
+  // Set pass for edge rendering (use the pass specified in edgeGeometry)
+  edgeCommand.pass = edgeGeometry.pass;
+
+  // Override uniformMap to set u_isEdgePass to true for the edge pass
+  const uniformMap = clone(command.uniformMap);
+  uniformMap.u_isEdgePass = function () {
+    return true; // This is the edge pass
+  };
+  edgeCommand.uniformMap = uniformMap;
+
+  edgeCommand.castShadows = false;
+  edgeCommand.receiveShadows = false;
+
+  return edgeCommand;
+}
+
 function updateSkipLodStencilCommand(drawCommand, tile, use2D) {
   const stencilDerivedComand = drawCommand._skipLodStencilCommand;
   const stencilCommand = stencilDerivedComand.command;

package/Source/Scene/Model/ModelImagery.js

@@ -100,6 +100,9 @@ class ModelImagery {
     //>>includeEnd('debug');
 
     if (!this._hasImagery) {
+      // When there is no imagery, make sure to delete any model primitive
+      // imageries that may previously have been created
+      this._deleteModelPrimitiveImageries();
       return;
     }
 
@@ -215,6 +218,7 @@ class ModelImagery {
       modelPrimitiveImagery.destroy();
     }
     delete this._modelPrimitiveImageries;
+    this._model.resetDrawCommands();
   }
 
   /**

package/Source/Scene/Model/ModelRuntimeNode.js

@@ -92,7 +92,7 @@ function ModelRuntimeNode(options) {
    * This is an array of classes, each with a static method called
    * <code>process()</code>.
    *
-   * @type {Object[]}
+   * @type {object[]}
    * @readonly
    *
    * @private
@@ -112,7 +112,7 @@ function ModelRuntimeNode(options) {
   /**
    * Update stages to apply to this node.
    *
-   * @type {Object[]}
+   * @type {object[]}
    * @readonly
    *
    * @private

package/Source/Scene/Model/ModelRuntimePrimitive.js

@@ -10,6 +10,8 @@ import CPUStylingPipelineStage from "./CPUStylingPipelineStage.js";
 import CustomShaderMode from "./CustomShaderMode.js";
 import CustomShaderPipelineStage from "./CustomShaderPipelineStage.js";
 import DequantizationPipelineStage from "./DequantizationPipelineStage.js";
+import EdgeDetectionPipelineStage from "./EdgeDetectionPipelineStage.js";
+import EdgeVisibilityPipelineStage from "./EdgeVisibilityPipelineStage.js";
 import FeatureIdPipelineStage from "./FeatureIdPipelineStage.js";
 import GeometryPipelineStage from "./GeometryPipelineStage.js";
 import ImageryPipelineStage from "./ImageryPipelineStage.js";
@@ -88,7 +90,7 @@ function ModelRuntimePrimitive(options) {
    * is an array of classes, each with a static method called
    * <code>process()</code>
    *
-   * @type {Object[]}
+   * @type {object[]}
    * @readonly
    *
    * @private
@@ -170,7 +172,7 @@ function ModelRuntimePrimitive(options) {
   /**
    * Update stages to apply to this primitive.
    *
-   * @type {Object[]}
+   * @type {object[]}
    * @readonly
    *
    * @private
@@ -244,6 +246,8 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
   const hasOutlines =
     model._enableShowOutline && defined(primitive.outlineCoordinates);
 
+  const hasEdgeVisibility = defined(primitive.edgeVisibility);
+
   const featureIdFlags = inspectFeatureIds(model, node, primitive);
 
   const hasClassification = defined(model.classificationType);
@@ -324,6 +328,13 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
     pipelineStages.push(PrimitiveOutlinePipelineStage);
   }
 
+  if (hasEdgeVisibility) {
+    // Indicate to Scene (after primitive updates) that the edge MRT should be enabled.
+    frameState.edgeVisibilityRequested = true;
+    pipelineStages.push(EdgeVisibilityPipelineStage);
+    pipelineStages.push(EdgeDetectionPipelineStage);
+  }
+
   pipelineStages.push(AlphaPipelineStage);
 
   pipelineStages.push(PrimitiveStatisticsPipelineStage);

package/Source/Scene/Model/ModelSceneGraph.js

@@ -72,7 +72,7 @@ function ModelSceneGraph(options) {
   /**
    * Pipeline stages to apply across the model.
    *
-   * @type {Object[]}
+   * @type {object[]}
    * @readonly
    *
    * @private
@@ -82,7 +82,7 @@ function ModelSceneGraph(options) {
   /**
    * Update stages to apply across the model.
    *
-   * @type {Object[]}
+   * @type {object[]}
    * @readonly
    *
    * @private
@@ -136,7 +136,7 @@ function ModelSceneGraph(options) {
    * is an array of classes, each with a static method called
    * <code>process()</code>
    *
-   * @type {Object[]}
+   * @type {object[]}
    * @readonly
    *
    * @private
@@ -985,6 +985,7 @@ function updatePrimitiveShowBoundingVolume(runtimePrimitive, options) {
 }
 
 const scratchSilhouetteCommands = [];
+const scratchEdgeCommands = [];
 const scratchPushDrawCommandOptions = {
   frameState: undefined,
   hasSilhouette: undefined,
@@ -1006,6 +1007,10 @@ ModelSceneGraph.prototype.pushDrawCommands = function (frameState) {
   const silhouetteCommands = scratchSilhouetteCommands;
   silhouetteCommands.length = 0;
 
+  // Gather edge commands for the edge pass
+  const edgeCommands = scratchEdgeCommands;
+  edgeCommands.length = 0;
+
   // Since this function is called each frame, the options object is
   // preallocated in a scratch variable
   const pushDrawCommandOptions = scratchPushDrawCommandOptions;
@@ -1020,6 +1025,7 @@ ModelSceneGraph.prototype.pushDrawCommands = function (frameState) {
   );
 
   addAllToArray(frameState.commandList, silhouetteCommands);
+  addAllToArray(frameState.commandList, edgeCommands);
 };
 
 // Callback is defined here to avoid allocating a closure in the render loop
@@ -1029,6 +1035,7 @@ function pushPrimitiveDrawCommands(runtimePrimitive, options) {
 
   const passes = frameState.passes;
   const silhouetteCommands = scratchSilhouetteCommands;
+  const edgeCommands = scratchEdgeCommands;
   const primitiveDrawCommand = runtimePrimitive.drawCommand;
   primitiveDrawCommand.pushCommands(frameState, frameState.commandList);
 
@@ -1039,6 +1046,11 @@ function pushPrimitiveDrawCommands(runtimePrimitive, options) {
   if (hasSilhouette && !passes.pick) {
     primitiveDrawCommand.pushSilhouetteCommands(frameState, silhouetteCommands);
   }
+
+  // Add edge commands to the edge pass
+  if (defined(primitiveDrawCommand.pushEdgeCommands)) {
+    primitiveDrawCommand.pushEdgeCommands(frameState, edgeCommands);
+  }
 }
 
 /**

package/Source/Scene/Model/ModelUtility.js

@@ -370,7 +370,6 @@ ModelUtility.supportedExtensions = {
   KHR_texture_transform: true,
   KHR_gaussian_splatting: true,
   KHR_gaussian_splatting_compression_spz_2: true,
-  KHR_spz_gaussian_splats_compression: true,
   WEB3D_quantized_attributes: true,
 };
 

package/Source/Scene/Model/NodeRenderResources.js

@@ -118,7 +118,7 @@ function NodeRenderResources(modelRenderResources, runtimeNode) {
    * be used to create a {@link VertexArray} for the draw command. Attributes
    * at the node level may be needed for extensions such as EXT_mesh_gpu_instancing.
    *
-   * @type {Object[]}
+   * @type {object[]}
    * @readonly
    *
    * @private

package/Source/Scene/Model/PrimitiveRenderResources.js

@@ -46,7 +46,7 @@ function PrimitiveRenderResources(nodeRenderResources, runtimePrimitive) {
    * The vertex attributes. This is shallow cloned from the node render
    * resources as the primitive will add additional properties.
    *
-   * @type {Object[]}
+   * @type {object[]}
    * @readonly
    *
    * @private

package/Source/Scene/OIT.js

@@ -531,10 +531,20 @@ function getTranslucentShaderProgram(context, shaderProgram, keyword, source) {
 
   // Discarding the fragment in main is a workaround for ANGLE D3D9
   // shader compilation errors.
+  //
+  // CESIUM_REDIRECTED_COLOR_OUTPUT: A general-purpose flag to indicate that this shader
+  // is a derived/modified version created by Cesium's rendering pipeline.
+  // This flag can be used to avoid color attachment conflicts when shaders
+  // need different output declarations for different rendering passes.
+  // For example, MRT (Multiple Render Targets) features can check this flag
+  // to conditionally declare their output variables only when not conflicting
+  // with the derived shader's output layout.
   fs.sources.splice(
     0,
     0,
-    `vec4 czm_out_FragColor;\n` + `bool czm_discard = false;\n`,
+    `#define CESIUM_REDIRECTED_COLOR_OUTPUT\n` +
+      `vec4 czm_out_FragColor;\n` +
+      `bool czm_discard = false;\n`,
   );
 
   const fragDataMatches = [...source.matchAll(/out_FragData_(\d+)/g)];

package/Source/Scene/PickFramebuffer.js

@@ -48,15 +48,14 @@ PickFramebuffer.prototype.begin = function (screenSpaceRectangle, viewport) {
   return this._passState;
 };
 
-const colorScratchForPickFramebuffer = new Color();
-
 /**
- * Return the picked object rendered within a given rectangle.
+ * Return the picked objects 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.
+ * @param {number} [limit=1] If supplied, stop iterating after collecting this many objects.
+ * @returns {object[]} A list of rendered objects, ordered by distance to the middle of the rectangle.
  */
-PickFramebuffer.prototype.end = function (screenSpaceRectangle) {
+PickFramebuffer.prototype.end = function (screenSpaceRectangle, limit = 1) {
   const width = screenSpaceRectangle.width ?? 1.0;
   const height = screenSpaceRectangle.height ?? 1.0;
 
@@ -84,6 +83,7 @@ PickFramebuffer.prototype.end = function (screenSpaceRectangle) {
 
   // The region does not have to square and the dimensions do not have to be odd, but
   // loop iterations would be wasted. Prefer square regions where the size is odd.
+  const objects = new Set();
   for (let i = 0; i < length; ++i) {
     if (
       -halfWidth <= x &&
@@ -93,22 +93,19 @@ PickFramebuffer.prototype.end = function (screenSpaceRectangle) {
     ) {
       const index = 4 * ((halfHeight - y) * width + x + halfWidth);
 
-      colorScratchForPickFramebuffer.red = Color.byteToFloat(pixels[index]);
-      colorScratchForPickFramebuffer.green = Color.byteToFloat(
+      const pickColor = Color.bytesToRgba(
+        pixels[index],
         pixels[index + 1],
-      );
-      colorScratchForPickFramebuffer.blue = Color.byteToFloat(
         pixels[index + 2],
-      );
-      colorScratchForPickFramebuffer.alpha = Color.byteToFloat(
         pixels[index + 3],
       );
 
-      const object = context.getObjectByPickColor(
-        colorScratchForPickFramebuffer,
-      );
+      const object = context.getObjectByPickColor(pickColor);
       if (defined(object)) {
-        return object;
+        objects.add(object);
+        if (objects.size >= limit) {
+          break;
+        }
       }
     }
 
@@ -123,8 +120,7 @@ PickFramebuffer.prototype.end = function (screenSpaceRectangle) {
     x += dx;
     y += dy;
   }
-
-  return undefined;
+  return [...objects];
 };
 
 /**