@cesium/engine 9.0.0 → 9.2.0

package/Source/Scene/Model/Model3DTileContent.js

@@ -255,6 +255,27 @@ Model3DTileContent.prototype.update = function (tileset, frameState) {
     model._clippingPlanesState = 0;
   }
 
+  // Updating clipping polygons requires more effort because of ownership checks
+  const tilesetClippingPolygons = tileset.clippingPolygons;
+  if (defined(tilesetClippingPolygons) && tile.clippingPolygonsDirty) {
+    // Dereference the clipping polygons from the model if they are irrelevant.
+    model._clippingPolygons =
+      tilesetClippingPolygons.enabled && tile._isClippedByPolygon
+        ? tilesetClippingPolygons
+        : undefined;
+  }
+
+  // If the model references a different ClippingPolygonCollection from the tileset,
+  // update the model to use the new ClippingPolygonCollection.
+  if (
+    defined(tilesetClippingPolygons) &&
+    defined(model._clippingPolygons) &&
+    model._clippingPolygons !== tilesetClippingPolygons
+  ) {
+    model._clippingPolygons = tilesetClippingPolygons;
+    model._clippingPolygonsState = 0;
+  }
+
   model.update(frameState);
 
   if (!this._ready && model.ready) {

package/Source/Scene/Model/ModelClippingPolygonsPipelineStage.js

@@ -0,0 +1,92 @@
+import combine from "../../Core/combine.js";
+import ModelClippingPolygonsStageVS from "../../Shaders/Model/ModelClippingPolygonsStageVS.js";
+import ModelClippingPolygonsStageFS from "../../Shaders/Model/ModelClippingPolygonsStageFS.js";
+import ShaderDestination from "../../Renderer/ShaderDestination.js";
+
+/**
+ * The model clipping planes stage is responsible for applying clipping planes to the model.
+ *
+ * @namespace ModelClippingPolygonsPipelineStage
+ *
+ * @private
+ */
+const ModelClippingPolygonsPipelineStage = {
+  name: "ModelClippingPolygonsPipelineStage", // Helps with debugging
+};
+
+/**
+ * Process a model for polygon clipping. This modifies the following parts of the render resources:
+ *
+ * <ul>
+ *  <li>adds a define to both the vertex and fragment shaders to indicate that the model has clipping polygons</li>
+ *  <li>adds the defines to both the vertex and fragment shaders for parameters related to clipping polygons, such as the number of polygons</li>
+ *  <li>adds a function to the vertex shader to determine lookup uvs</li>
+ *  <li>adds a function to the fragment shader to discard clipped regions</li>
+ *  <li>adds the uniforms to the vertex and fragment shaders for the clipping extents texture and clipping distance respectively</li>
+ *  <li>adds a varying for lookup uvs in the clipping texture</li>
+ *</ul>
+ *
+ * @param {ModelRenderResources} renderResources The render resources for this model.
+ * @param {Model} model The model.
+ * @param {FrameState} frameState The frameState.
+ *
+ * @private
+ */
+ModelClippingPolygonsPipelineStage.process = function (
+  renderResources,
+  model,
+  frameState
+) {
+  const clippingPolygons = model.clippingPolygons;
+  const shaderBuilder = renderResources.shaderBuilder;
+
+  shaderBuilder.addDefine(
+    "ENABLE_CLIPPING_POLYGONS",
+    undefined,
+    ShaderDestination.BOTH
+  );
+
+  if (clippingPolygons.inverse) {
+    shaderBuilder.addDefine(
+      "CLIPPING_INVERSE",
+      undefined,
+      ShaderDestination.FRAGMENT
+    );
+  }
+
+  shaderBuilder.addDefine(
+    "CLIPPING_POLYGON_REGIONS_LENGTH",
+    clippingPolygons.extentsCount,
+    ShaderDestination.BOTH
+  );
+
+  shaderBuilder.addUniform(
+    "sampler2D",
+    "model_clippingDistance",
+    ShaderDestination.FRAGMENT
+  );
+
+  shaderBuilder.addUniform(
+    "sampler2D",
+    "model_clippingExtents",
+    ShaderDestination.VERTEX
+  );
+
+  shaderBuilder.addVarying("vec2", "v_clippingPosition");
+  shaderBuilder.addVarying("int", "v_regionIndex", "flat");
+  shaderBuilder.addVertexLines(ModelClippingPolygonsStageVS);
+  shaderBuilder.addFragmentLines(ModelClippingPolygonsStageFS);
+
+  const uniformMap = {
+    model_clippingDistance: function () {
+      return clippingPolygons.clippingTexture;
+    },
+    model_clippingExtents: function () {
+      return clippingPolygons.extentsTexture;
+    },
+  };
+
+  renderResources.uniformMap = combine(uniformMap, renderResources.uniformMap);
+};
+
+export default ModelClippingPolygonsPipelineStage;

package/Source/Scene/Model/ModelSceneGraph.js

@@ -14,6 +14,7 @@ import ImageBasedLightingPipelineStage from "./ImageBasedLightingPipelineStage.j
 import ModelArticulation from "./ModelArticulation.js";
 import ModelColorPipelineStage from "./ModelColorPipelineStage.js";
 import ModelClippingPlanesPipelineStage from "./ModelClippingPlanesPipelineStage.js";
+import ModelClippingPolygonsPipelineStage from "./ModelClippingPolygonsPipelineStage.js";
 import ModelNode from "./ModelNode.js";
 import ModelRuntimeNode from "./ModelRuntimeNode.js";
 import ModelRuntimePrimitive from "./ModelRuntimePrimitive.js";
@@ -626,6 +627,10 @@ ModelSceneGraph.prototype.configurePipeline = function (frameState) {
     modelPipelineStages.push(ModelClippingPlanesPipelineStage);
   }
 
+  if (model.isClippingPolygonsEnabled()) {
+    modelPipelineStages.push(ModelClippingPolygonsPipelineStage);
+  }
+
   if (model.hasSilhouette(frameState)) {
     modelPipelineStages.push(ModelSilhouettePipelineStage);
   }

package/Source/Scene/Model/ModelUtility.js

@@ -357,6 +357,9 @@ ModelUtility.supportedExtensions = {
   KHR_techniques_webgl: true,
   KHR_materials_common: true,
   KHR_materials_pbrSpecularGlossiness: true,
+  KHR_materials_specular: true,
+  KHR_materials_anisotropy: true,
+  KHR_materials_clearcoat: true,
   KHR_materials_unlit: true,
   KHR_mesh_quantization: true,
   KHR_texture_basisu: true,

package/Source/Scene/Model/VerticalExaggerationPipelineStage.js

@@ -3,11 +3,9 @@ import ShaderDestination from "../../Renderer/ShaderDestination.js";
 import VerticalExaggerationStageVS from "../../Shaders/Model/VerticalExaggerationStageVS.js";
 
 /**
- * The custom shader pipeline stage takes GLSL callbacks from the
- * {@link CustomShader} and inserts them into the overall shader code for the
- * {@link Model}. The input to the callback is a struct with many
- * properties that depend on the attributes of the primitive. This shader code
- * is automatically generated by this stage.
+ * The vertical exaggeration pipeline stage transforms the vertex
+ * positions based on the values of {@link Scene#verticalExaggeration} and
+ * {@link Scene#verticalExaggerationRelativeHeight}
  *
  * @namespace VerticalExaggerationPipelineStage
  *
@@ -20,7 +18,7 @@ const VerticalExaggerationPipelineStage = {
 const scratchExaggerationUniform = new Cartesian2();
 
 /**
- * Add vertical exaggeration to a shader
+ * Add defines and uniforms for vertical exaggeration calculations in the vertex shader
  *
  * @param {PrimitiveRenderResources} renderResources The render resources for the primitive
  * @param {ModelComponents.Primitive} primitive The primitive to be rendered

package/Source/Scene/ModelComponents.js

@@ -1337,10 +1337,151 @@ SpecularGlossiness.DEFAULT_SPECULAR_FACTOR = Cartesian3.ONE;
  */
 SpecularGlossiness.DEFAULT_GLOSSINESS_FACTOR = 1.0;
 
+function Specular() {
+  /**
+   * The specular factor.
+   *
+   * @type {number}
+   * @default 1.0
+   * @private
+   */
+  this.specularFactor = Specular.DEFAULT_SPECULAR_FACTOR;
+
+  /**
+   * The specular texture reader.
+   *
+   * @type {ModelComponents.TextureReader}
+   * @private
+   */
+  this.specularTexture = undefined;
+
+  /**
+   * The specular color factor.
+   *
+   * @type {Cartesian3}
+   * @default new Cartesian3(1.0, 1.0, 1.0)
+   * @private
+   */
+  this.specularColorFactor = Cartesian3.clone(
+    Specular.DEFAULT_SPECULAR_COLOR_FACTOR
+  );
+
+  /**
+   * The specular color texture reader.
+   *
+   * @type {ModelComponents.TextureReader}
+   * @private
+   */
+  this.specularColorTexture = undefined;
+}
+
+/**
+ * @private
+ */
+Specular.DEFAULT_SPECULAR_FACTOR = 1.0;
+
+/**
+ * @private
+ */
+Specular.DEFAULT_SPECULAR_COLOR_FACTOR = Cartesian3.ONE;
+
+function Anisotropy() {
+  /**
+   * The anisotropy strength.
+   *
+   * @type {number}
+   * @default 0.0
+   * @private
+   */
+  this.anisotropyStrength = Anisotropy.DEFAULT_ANISOTROPY_STRENGTH;
+
+  /**
+   * The rotation of the anisotropy in tangent, bitangent space,
+   * measured in radians counter-clockwise from the tangent.
+   *
+   * @type {number}
+   * @default 0.0
+   * @private
+   */
+  this.anisotropyRotation = Anisotropy.DEFAULT_ANISOTROPY_ROTATION;
+
+  /**
+   * The anisotropy texture reader.
+   *
+   * @type {ModelComponents.TextureReader}
+   * @private
+   */
+  this.anisotropyTexture = undefined;
+}
+
+/**
+ * @private
+ */
+Anisotropy.DEFAULT_ANISOTROPY_STRENGTH = 0.0;
+
+/**
+ * @private
+ */
+Anisotropy.DEFAULT_ANISOTROPY_ROTATION = 0.0;
+
+function Clearcoat() {
+  /**
+   * The clearcoat layer intensity.
+   *
+   * @type {number}
+   * @default 0.0
+   * @private
+   */
+  this.clearcoatFactor = Clearcoat.DEFAULT_CLEARCOAT_FACTOR;
+
+  /**
+   * The clearcoat layer intensity texture reader.
+   *
+   * @type {ModelComponents.TextureReader}
+   * @private
+   */
+  this.clearcoatTexture = undefined;
+
+  /**
+   * The clearcoat layer roughness.
+   *
+   * @type {number}
+   * @default 0.0
+   * @private
+   */
+  this.clearcoatRoughnessFactor = Clearcoat.DEFAULT_CLEARCOAT_ROUGHNESS_FACTOR;
+
+  /**
+   * The clearcoat layer roughness texture.
+   *
+   * @type {ModelComponents.TextureReader}
+   * @private
+   */
+  this.clearcoatRoughnessTexture = undefined;
+
+  /**
+   * The clearcoat normal map texture.
+   *
+   * @type {ModelComponents.TextureReader}
+   * @private
+   */
+  this.clearcoatNormalTexture = undefined;
+}
+
+/**
+ * @private
+ */
+Clearcoat.DEFAULT_CLEARCOAT_FACTOR = 0.0;
+
+/**
+ * @private
+ */
+Clearcoat.DEFAULT_CLEARCOAT_ROUGHNESS_FACTOR = 0.0;
+
 /**
  * The material appearance of a primitive.
  *
- * @alias ModelComponent.Material
+ * @alias ModelComponents.Material
  * @constructor
  *
  * @private
@@ -1362,6 +1503,30 @@ function Material() {
    */
   this.specularGlossiness = undefined;
 
+  /**
+   * Material properties for the PBR specular shading model.
+   *
+   * @type {ModelComponents.Specular}
+   * @private
+   */
+  this.specular = undefined;
+
+  /**
+   * Material properties for the PBR anisotropy shading model.
+   *
+   * @type {ModelComponents.Anisotropy}
+   * @private
+   */
+  this.anisotropy = undefined;
+
+  /**
+   * Material properties for the PBR clearcoat shading model.
+   *
+   * @type {ModelComponents.Clearcoat}
+   * @private
+   */
+  this.clearcoat = undefined;
+
   /**
    * The emissive texture reader.
    *
@@ -1461,6 +1626,9 @@ ModelComponents.Components = Components;
 ModelComponents.TextureReader = TextureReader;
 ModelComponents.MetallicRoughness = MetallicRoughness;
 ModelComponents.SpecularGlossiness = SpecularGlossiness;
+ModelComponents.Specular = Specular;
+ModelComponents.Anisotropy = Anisotropy;
+ModelComponents.Clearcoat = Clearcoat;
 ModelComponents.Material = Material;
 
 export default ModelComponents;

package/Source/Scene/PickDepth.js

@@ -30,22 +30,30 @@ function updateFramebuffers(pickDepth, context, depthTexture) {
 
 function updateCopyCommands(pickDepth, context, depthTexture) {
   if (!defined(pickDepth._copyDepthCommand)) {
-    const fs =
-      "uniform highp sampler2D u_texture;\n" +
-      "in vec2 v_textureCoordinates;\n" +
-      "void main()\n" +
-      "{\n" +
-      "    out_FragColor = czm_packDepth(texture(u_texture, v_textureCoordinates).r);\n" +
-      "}\n";
-    pickDepth._copyDepthCommand = context.createViewportQuadCommand(fs, {
-      renderState: RenderState.fromCache(),
-      uniformMap: {
-        u_texture: function () {
-          return pickDepth._textureToCopy;
+    pickDepth._copyDepthCommand = context.createViewportQuadCommand(
+      `uniform highp sampler2D colorTexture;
+
+in vec2 v_textureCoordinates;
+
+void main()
+{
+  vec4 globeDepthPacked = texture(czm_globeDepthTexture, v_textureCoordinates);
+  float globeDepth = czm_unpackDepth(globeDepthPacked);
+  float depth = texture(colorTexture, v_textureCoordinates).r;
+  out_FragColor = czm_branchFreeTernary(globeDepth <= 0.0 || globeDepth >= 1.0 || depth < globeDepth && depth > 0.0 && depth < 1.0,
+    czm_packDepth(depth), globeDepthPacked);
+}
+`,
+      {
+        renderState: RenderState.fromCache(),
+        uniformMap: {
+          colorTexture: function () {
+            return pickDepth._textureToCopy;
+          },
         },
-      },
-      owner: pickDepth,
-    });
+        owner: pickDepth,
+      }
+    );
   }
 
   pickDepth._textureToCopy = depthTexture;

package/Source/Scene/ResourceCache.js

@@ -146,8 +146,7 @@ ResourceCache.unload = function (resourceLoader) {
  */
 ResourceCache.getSchemaLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const schema = options.schema;
-  const resource = options.resource;
+  const { schema, resource } = options;
 
   //>>includeStart('debug', pragmas.debug);
   if (defined(schema) === defined(resource)) {
@@ -189,9 +188,7 @@ ResourceCache.getSchemaLoader = function (options) {
  */
 ResourceCache.getEmbeddedBufferLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const parentResource = options.parentResource;
-  const bufferId = options.bufferId;
-  const typedArray = options.typedArray;
+  const { parentResource, bufferId, typedArray } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.parentResource", parentResource);
@@ -231,7 +228,7 @@ ResourceCache.getEmbeddedBufferLoader = function (options) {
  */
 ResourceCache.getExternalBufferLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const resource = options.resource;
+  const { resource } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.resource", resource);
@@ -268,10 +265,7 @@ ResourceCache.getExternalBufferLoader = function (options) {
  */
 ResourceCache.getGltfJsonLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
-  const typedArray = options.typedArray;
-  const gltfJson = options.gltfJson;
+  const { gltfResource, baseResource, typedArray, gltfJson } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltfResource", gltfResource);
@@ -313,10 +307,7 @@ ResourceCache.getGltfJsonLoader = function (options) {
  */
 ResourceCache.getBufferViewLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltf = options.gltf;
-  const bufferViewId = options.bufferViewId;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
+  const { gltf, bufferViewId, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);
@@ -363,10 +354,7 @@ ResourceCache.getBufferViewLoader = function (options) {
  */
 ResourceCache.getDracoLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltf = options.gltf;
-  const draco = options.draco;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
+  const { gltf, draco, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);
@@ -424,18 +412,20 @@ ResourceCache.getDracoLoader = function (options) {
  */
 ResourceCache.getVertexBufferLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltf = options.gltf;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
-  const frameState = options.frameState;
-  const bufferViewId = options.bufferViewId;
-  const draco = options.draco;
-  const attributeSemantic = options.attributeSemantic;
-  const accessorId = options.accessorId;
-  const asynchronous = defaultValue(options.asynchronous, true);
-  const dequantize = defaultValue(options.dequantize, false);
-  const loadBuffer = defaultValue(options.loadBuffer, false);
-  const loadTypedArray = defaultValue(options.loadTypedArray, false);
+  const {
+    gltf,
+    gltfResource,
+    baseResource,
+    frameState,
+    bufferViewId,
+    draco,
+    attributeSemantic,
+    accessorId,
+    asynchronous = true,
+    dequantize = false,
+    loadBuffer = false,
+    loadTypedArray = false,
+  } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);
@@ -541,15 +531,17 @@ function hasDracoCompression(draco, semantic) {
  */
 ResourceCache.getIndexBufferLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltf = options.gltf;
-  const accessorId = options.accessorId;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
-  const frameState = options.frameState;
-  const draco = options.draco;
-  const asynchronous = defaultValue(options.asynchronous, true);
-  const loadBuffer = defaultValue(options.loadBuffer, false);
-  const loadTypedArray = defaultValue(options.loadTypedArray, false);
+  const {
+    gltf,
+    accessorId,
+    gltfResource,
+    baseResource,
+    frameState,
+    draco,
+    asynchronous = true,
+    loadBuffer = false,
+    loadTypedArray = false,
+  } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);
@@ -610,10 +602,7 @@ ResourceCache.getIndexBufferLoader = function (options) {
  */
 ResourceCache.getImageLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltf = options.gltf;
-  const imageId = options.imageId;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
+  const { gltf, imageId, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);
@@ -663,13 +652,15 @@ ResourceCache.getImageLoader = function (options) {
  */
 ResourceCache.getTextureLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltf = options.gltf;
-  const textureInfo = options.textureInfo;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
-  const supportedImageFormats = options.supportedImageFormats;
-  const frameState = options.frameState;
-  const asynchronous = defaultValue(options.asynchronous, true);
+  const {
+    gltf,
+    textureInfo,
+    gltfResource,
+    baseResource,
+    supportedImageFormats,
+    frameState,
+    asynchronous = true,
+  } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);