@cesium/engine 8.0.0 → 9.1.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/Primitive.js

@@ -2515,9 +2515,6 @@ function setReady(primitive, frameState, state, error) {
     primitive._ready =
       primitive._state === PrimitiveState.COMPLETE ||
       primitive._state === PrimitiveState.FAILED;
-    if (!defined(error)) {
-      return true;
-    }
   });
 }
 export default Primitive;

package/Source/Scene/SensorVolumePortionToDisplay.js

@@ -1,4 +1,4 @@
-import { DeveloperError } from "@cesium/engine";
+import DeveloperError from "../Core/DeveloperError.js";
 
 /**
  * Constants used to indicated what part of the sensor volume to display.

package/Source/Scene/Terrain.js

@@ -83,7 +83,7 @@ Object.defineProperties(Terrain.prototype, {
 
   /**
    * Returns true when the terrain provider has been successfully created. Otherwise, returns false.
-   * @memberof Viewer.prototype
+   * @memberof Terrain.prototype
    *
    * @type {boolean}
    * @readonly
@@ -96,7 +96,7 @@ Object.defineProperties(Terrain.prototype, {
 
   /**
    * The terrain provider providing surface geometry to a globe. Do not use until {@link Terrain.readyEvent} is raised.
-   * @memberof Viewer.prototype
+   * @memberof Terrain.prototype
    *
    * @type {TerrainProvider}
    * @readonly

package/Source/Scene/VoxelBoxShape.js

@@ -427,21 +427,6 @@ VoxelBoxShape.prototype.computeOrientedBoundingBoxForSample = function (
   );
 };
 
-/**
- * Computes an approximate step size for raymarching the root tile of a voxel grid.
- * The update function must be called before calling this function.
- *
- * @param {Cartesian3} dimensions The voxel grid dimensions for a tile.
- * @returns {number} The step size.
- */
-VoxelBoxShape.prototype.computeApproximateStepSize = function (dimensions) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("dimensions", dimensions);
-  //>>includeEnd('debug');
-
-  return 1.0 / Cartesian3.maximumComponent(dimensions);
-};
-
 /**
  * Defines the minimum bounds of the shape. Corresponds to minimum X, Y, Z.
  *

package/Source/Scene/VoxelCylinderShape.js

@@ -96,9 +96,8 @@ function VoxelCylinderShape() {
    * @readonly
    */
   this.shaderUniforms = {
-    cylinderUvToRenderBoundsScale: new Cartesian3(),
-    cylinderUvToRenderBoundsTranslate: new Cartesian3(),
-    cylinderUvToRenderRadiusMin: 0.0,
+    cylinderRenderHeightMinMax: new Cartesian2(),
+    cylinderRenderRadiusMinMax: new Cartesian2(),
     cylinderRenderAngleMinMax: new Cartesian2(),
     cylinderUvToShapeUvRadius: new Cartesian2(),
     cylinderUvToShapeUvHeight: new Cartesian2(),
@@ -113,10 +112,7 @@ function VoxelCylinderShape() {
    */
   this.shaderDefines = {
     CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MIN: undefined,
-    CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MAX: undefined,
     CYLINDER_HAS_RENDER_BOUNDS_RADIUS_FLAT: undefined,
-    CYLINDER_HAS_RENDER_BOUNDS_HEIGHT: undefined,
-    CYLINDER_HAS_RENDER_BOUNDS_HEIGHT_FLAT: undefined,
     CYLINDER_HAS_RENDER_BOUNDS_ANGLE: undefined,
     CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_ZERO: undefined,
     CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_UNDER_HALF: undefined,
@@ -143,17 +139,6 @@ function VoxelCylinderShape() {
 }
 
 const scratchScale = new Cartesian3();
-const scratchBoundsTranslation = new Cartesian3();
-const scratchBoundsScale = new Cartesian3();
-const scratchBoundsScaleMatrix = new Matrix3();
-const scratchTransformLocalToBounds = new Matrix4();
-const scratchTransformUvToBounds = new Matrix4();
-
-const transformUvToLocal = Matrix4.fromRotationTranslation(
-  Matrix3.fromUniformScale(2.0, new Matrix3()),
-  new Cartesian3(-1.0, -1.0, -1.0),
-  new Matrix4()
-);
 
 /**
  * Update the shape's state.
@@ -339,11 +324,7 @@ VoxelCylinderShape.prototype.update = function (
     epsilonAngleDiscontinuity
   );
 
-  const renderIsDefaultMaxRadius = renderMaxRadius === defaultMaxRadius;
   const renderIsDefaultMinRadius = renderMinRadius === defaultMinRadius;
-  const renderIsDefaultHeight =
-    renderMinHeight === defaultMinHeight &&
-    renderMaxHeight === defaultMaxHeight;
   const renderIsAngleReversed = renderMaxAngle < renderMinAngle;
   const renderAngleRange =
     renderMaxAngle - renderMinAngle + renderIsAngleReversed * defaultAngleRange;
@@ -376,22 +357,16 @@ VoxelCylinderShape.prototype.update = function (
     shaderDefines["CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MIN"] = true;
     shaderDefines["CYLINDER_INTERSECTION_INDEX_RADIUS_MIN"] = intersectionCount;
     intersectionCount += 1;
-
-    shaderUniforms.cylinderUvToRenderRadiusMin =
-      renderMaxRadius / renderMinRadius;
-  }
-  if (!renderIsDefaultMaxRadius) {
-    shaderDefines["CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MAX"] = true;
   }
+  shaderUniforms.cylinderRenderRadiusMinMax = Cartesian2.fromElements(
+    renderMinRadius,
+    renderMaxRadius,
+    shaderUniforms.cylinderRenderRadiusMinMax
+  );
+
   if (renderMinRadius === renderMaxRadius) {
     shaderDefines["CYLINDER_HAS_RENDER_BOUNDS_RADIUS_FLAT"] = true;
   }
-  if (!renderIsDefaultHeight) {
-    shaderDefines["CYLINDER_HAS_RENDER_BOUNDS_HEIGHT"] = true;
-  }
-  if (renderMinHeight === renderMaxHeight) {
-    shaderDefines["CYLINDER_HAS_RENDER_BOUNDS_HEIGHT_FLAT"] = true;
-  }
   if (!shapeIsDefaultRadius) {
     shaderDefines["CYLINDER_HAS_SHAPE_BOUNDS_RADIUS"] = true;
 
@@ -442,42 +417,11 @@ VoxelCylinderShape.prototype.update = function (
       shaderUniforms.cylinderUvToShapeUvHeight
     );
   }
-
-  if (!renderIsDefaultMaxRadius || !renderIsDefaultHeight) {
-    const heightScale = 0.5 * (renderMaxHeight - renderMinHeight);
-    const scaleLocalToBounds = Cartesian3.fromElements(
-      1.0 / renderMaxRadius,
-      1.0 / renderMaxRadius,
-      1.0 / (heightScale === 0.0 ? 1.0 : heightScale),
-      scratchBoundsScale
-    );
-    // -inverse(scale) * translation // affine inverse
-    // -inverse(scale) * 0.5 * (minHeight + maxHeight)
-    const translateLocalToBounds = Cartesian3.fromElements(
-      0.0,
-      0.0,
-      -scaleLocalToBounds.z * 0.5 * (renderMinHeight + renderMaxHeight),
-      scratchBoundsTranslation
-    );
-    const transformLocalToBounds = Matrix4.fromRotationTranslation(
-      Matrix3.fromScale(scaleLocalToBounds, scratchBoundsScaleMatrix),
-      translateLocalToBounds,
-      scratchTransformLocalToBounds
-    );
-    const transformUvToBounds = Matrix4.multiplyTransformation(
-      transformLocalToBounds,
-      transformUvToLocal,
-      scratchTransformUvToBounds
-    );
-    shaderUniforms.cylinderUvToRenderBoundsScale = Matrix4.getScale(
-      transformUvToBounds,
-      shaderUniforms.cylinderUvToRenderBoundsScale
-    );
-    shaderUniforms.cylinderUvToRenderBoundsTranslate = Matrix4.getTranslation(
-      transformUvToBounds,
-      shaderUniforms.cylinderUvToRenderBoundsTranslate
-    );
-  }
+  shaderUniforms.cylinderRenderHeightMinMax = Cartesian2.fromElements(
+    renderMinHeight,
+    renderMaxHeight,
+    shaderUniforms.cylinderRenderHeightMinMax
+  );
 
   if (shapeIsAngleReversed) {
     shaderDefines["CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED"] = true;
@@ -501,7 +445,7 @@ VoxelCylinderShape.prototype.update = function (
     shaderUniforms.cylinderRenderAngleMinMax = Cartesian2.fromElements(
       renderMinAngle,
       renderMaxAngle,
-      shaderUniforms.cylinderAngleMinMax
+      shaderUniforms.cylinderRenderAngleMinMax
     );
   }
 
@@ -716,67 +660,6 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForSample = function (
   );
 };
 
-const scratchOrientedBoundingBox = new OrientedBoundingBox();
-const scratchVoxelScale = new Cartesian3();
-const scratchRootScale = new Cartesian3();
-const scratchScaleRatio = new Cartesian3();
-
-/**
- * Computes an approximate step size for raymarching the root tile of a voxel grid.
- * The update function must be called before calling this function.
- *
- * @param {Cartesian3} dimensions The voxel grid dimensions for a tile.
- * @returns {number} The step size.
- */
-VoxelCylinderShape.prototype.computeApproximateStepSize = function (
-  dimensions
-) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("dimensions", dimensions);
-  //>>includeEnd('debug');
-
-  const shapeTransform = this.shapeTransform;
-  const minRadius = this._minimumRadius;
-  const maxRadius = this._maximumRadius;
-  const minHeight = this._minimumHeight;
-  const maxHeight = this._maximumHeight;
-  const minAngle = this._minimumAngle;
-  const maxAngle = this._maximumAngle;
-
-  const lerpRadius = 1.0 - 1.0 / dimensions.x;
-  const lerpHeight = 1.0 - 1.0 / dimensions.y;
-  const lerpAngle = 1.0 - 1.0 / dimensions.z;
-
-  // Compare the size of an outermost cylinder voxel to the total cylinder
-  const voxelMinimumRadius = CesiumMath.lerp(minRadius, maxRadius, lerpRadius);
-  const voxelMinimumHeight = CesiumMath.lerp(minHeight, maxHeight, lerpHeight);
-  const voxelMinimumAngle = CesiumMath.lerp(minAngle, maxAngle, lerpAngle);
-  const voxelMaximumRadius = maxRadius;
-  const voxelMaximumHeight = maxHeight;
-  const voxelMaximumAngle = maxAngle;
-
-  const voxelObb = getCylinderChunkObb(
-    voxelMinimumRadius,
-    voxelMaximumRadius,
-    voxelMinimumHeight,
-    voxelMaximumHeight,
-    voxelMinimumAngle,
-    voxelMaximumAngle,
-    shapeTransform,
-    scratchOrientedBoundingBox
-  );
-
-  const voxelScale = Matrix3.getScale(voxelObb.halfAxes, scratchVoxelScale);
-  const rootScale = Matrix4.getScale(shapeTransform, scratchRootScale);
-  const scaleRatio = Cartesian3.divideComponents(
-    voxelScale,
-    rootScale,
-    scratchScaleRatio
-  );
-  const stepSize = Cartesian3.minimumComponent(scaleRatio);
-  return stepSize;
-};
-
 /**
  * Defines the minimum bounds of the shape. Corresponds to minimum radius, height, angle.
  *