@cesium/engine 8.0.0 → 9.1.0

package/Source/Core/Rectangle.js

@@ -1,9 +1,12 @@
+import Cartesian3 from "./Cartesian3.js";
 import Cartographic from "./Cartographic.js";
 import Check from "./Check.js";
 import defaultValue from "./defaultValue.js";
 import defined from "./defined.js";
 import Ellipsoid from "./Ellipsoid.js";
 import CesiumMath from "./Math.js";
+import Transforms from "./Transforms.js";
+import Matrix4 from "./Matrix4.js";
 
 /**
  * A two dimensional region specified as longitude and latitude coordinates.
@@ -337,6 +340,92 @@ Rectangle.fromCartesianArray = function (cartesians, ellipsoid, result) {
   return result;
 };
 
+const fromBoundingSphereMatrixScratch = new Cartesian3();
+const fromBoundingSphereEastScratch = new Cartesian3();
+const fromBoundingSphereNorthScratch = new Cartesian3();
+const fromBoundingSphereWestScratch = new Cartesian3();
+const fromBoundingSphereSouthScratch = new Cartesian3();
+const fromBoundingSpherePositionsScratch = new Array(5);
+for (let n = 0; n < fromBoundingSpherePositionsScratch.length; ++n) {
+  fromBoundingSpherePositionsScratch[n] = new Cartesian3();
+}
+/**
+ * Create a rectangle from a bounding sphere, ignoring height.
+ *
+ *
+ * @param {BoundingSphere} boundingSphere The bounding sphere.
+ * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid.
+ * @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
+ * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
+ */
+Rectangle.fromBoundingSphere = function (boundingSphere, ellipsoid, result) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("boundingSphere", boundingSphere);
+  //>>includeEnd('debug');
+
+  const center = boundingSphere.center;
+  const radius = boundingSphere.radius;
+
+  if (!defined(ellipsoid)) {
+    ellipsoid = Ellipsoid.WGS84;
+  }
+
+  if (!defined(result)) {
+    result = new Rectangle();
+  }
+
+  if (Cartesian3.equals(center, Cartesian3.ZERO)) {
+    Rectangle.clone(Rectangle.MAX_VALUE, result);
+    return result;
+  }
+
+  const fromENU = Transforms.eastNorthUpToFixedFrame(
+    center,
+    ellipsoid,
+    fromBoundingSphereMatrixScratch
+  );
+  const east = Matrix4.multiplyByPointAsVector(
+    fromENU,
+    Cartesian3.UNIT_X,
+    fromBoundingSphereEastScratch
+  );
+  Cartesian3.normalize(east, east);
+  const north = Matrix4.multiplyByPointAsVector(
+    fromENU,
+    Cartesian3.UNIT_Y,
+    fromBoundingSphereNorthScratch
+  );
+  Cartesian3.normalize(north, north);
+
+  Cartesian3.multiplyByScalar(north, radius, north);
+  Cartesian3.multiplyByScalar(east, radius, east);
+
+  const south = Cartesian3.negate(north, fromBoundingSphereSouthScratch);
+  const west = Cartesian3.negate(east, fromBoundingSphereWestScratch);
+
+  const positions = fromBoundingSpherePositionsScratch;
+
+  // North
+  let corner = positions[0];
+  Cartesian3.add(center, north, corner);
+
+  // West
+  corner = positions[1];
+  Cartesian3.add(center, west, corner);
+
+  // South
+  corner = positions[2];
+  Cartesian3.add(center, south, corner);
+
+  // East
+  corner = positions[3];
+  Cartesian3.add(center, east, corner);
+
+  positions[4] = center;
+
+  return Rectangle.fromCartesianArray(positions, ellipsoid, result);
+};
+
 /**
  * Duplicates a Rectangle.
  *

package/Source/Core/VerticalExaggeration.js

@@ -1,4 +1,5 @@
 import Cartesian3 from "./Cartesian3.js";
+import Cartographic from "./Cartographic.js";
 import DeveloperError from "./DeveloperError.js";
 import defined from "./defined.js";
 
@@ -26,7 +27,7 @@ VerticalExaggeration.getHeight = function (height, scale, relativeHeight) {
   return (height - relativeHeight) * scale + relativeHeight;
 };
 
-const scratchCartographic = new Cartesian3();
+const scratchCartographic = new Cartographic();
 
 /**
  * Scales a position by exaggeration.

package/Source/DataSources/DataSourceDisplay.js

@@ -325,6 +325,11 @@ DataSourceDisplay.prototype.update = function (time) {
     result = visualizers[x].update(time) && result;
   }
 
+  // Request a rendering of the scene when the data source
+  // becomes 'ready' for the first time
+  if (!this._ready && result) {
+    this._scene.requestRender();
+  }
   this._ready = result;
 
   return result;

package/Source/Renderer/ShaderBuilder.js

@@ -369,21 +369,24 @@ ShaderBuilder.prototype.addAttribute = function (type, identifier) {
  *
  * @param {string} type The GLSL type of the varying
  * @param {string} identifier An identifier for the varying. Identifiers must begin with <code>v_</code> to be consistent with Cesium's style guide.
+ * @param {string} [qualifier] A qualifier for the varying, such as <code>flat</code>.
  *
  * @example
  * // creates the line "in vec3 v_color;" in the vertex shader
  * // creates the line "out vec3 v_color;" in the fragment shader
  * shaderBuilder.addVarying("vec3", "v_color");
  */
-ShaderBuilder.prototype.addVarying = function (type, identifier) {
+ShaderBuilder.prototype.addVarying = function (type, identifier, qualifier) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.string("type", type);
   Check.typeOf.string("identifier", identifier);
   //>>includeEnd('debug');
 
+  qualifier = defined(qualifier) ? `${qualifier} ` : "";
+
   const line = `${type} ${identifier};`;
-  this._vertexShaderParts.varyingLines.push(`out ${line}`);
-  this._fragmentShaderParts.varyingLines.push(`in ${line}`);
+  this._vertexShaderParts.varyingLines.push(`${qualifier}out ${line}`);
+  this._fragmentShaderParts.varyingLines.push(`${qualifier}in ${line}`);
 };
 
 /**

package/Source/Scene/ArcGisMapService.js

@@ -4,7 +4,7 @@ import Resource from "../Core/Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "AAPKc6e43bbc520149f79229d173c04883558jat1YV8r6Xjl50ulCDeLTkHzW0vzUC-9m6ASQvGmPbo4-xY_kAzsJxJZm-j_Unr";
+  "AAPK809db8a668914f14bf886dcf16d4dc82Hm5SsO4xOJY2n4-V_ypQyxlGKJRQugNnPIslyTLkk5-HHQl9BRpgdNXaKNGe7oxx";
 /**
  * Default options for accessing the ArcGIS image tile service.
  *

package/Source/Scene/Billboard.js

@@ -22,6 +22,35 @@ import SceneMode from "./SceneMode.js";
 import SceneTransforms from "./SceneTransforms.js";
 import VerticalOrigin from "./VerticalOrigin.js";
 
+/**
+ * @typedef {object} Billboard.ConstructorOptions
+ *
+ * Initialization options for the first param of Billboard constructor
+ *
+ * @property {Cartesian3} position The cartesian position of the billboard.
+ * @property {string} [id] A user-defined object to return when the billboard is picked with {@link Scene#pick}.
+ * @property {boolean} [show=true] Determines if this billboard will be shown.
+ * @property {string | HTMLCanvasElement} [image] A loaded HTMLImageElement, ImageData, or a url to an image to use for the billboard.
+ * @property {number} [scale=1.0] A number specifying the uniform scale that is multiplied with the billboard's image size in pixels.
+ * @property {Cartesian2} [pixelOffset=Cartesian2.ZERO] A {@link Cartesian2} Specifying the pixel offset in screen space from the origin of this billboard.
+ * @property {Cartesian3} [eyeOffset=Cartesian3.ZERO] A {@link Cartesian3} Specifying the 3D Cartesian offset applied to this billboard in eye coordinates.
+ * @property {HorizontalOrigin} [horizontalOrigin=HorizontalOrigin.CENTER] A {@link HorizontalOrigin} Specifying the horizontal origin of this billboard.
+ * @property {VerticalOrigin} [verticalOrigin=VerticalOrigin.CENTER] A {@link VerticalOrigin} Specifying the vertical origin of this billboard.
+ * @property {HeightReference} [heightReference=HeightReference.NONE] A {@link HeightReference} Specifying the height reference of this billboard.
+ * @property {Color} [color=Color.WHITE] A {@link Color} Specifying the color that is multiplied with the billboard's texture.
+ * @property {number} [rotation=0] A number specifying the rotation angle in radians.
+ * @property {Cartesian3} [alignedAxis=Cartesian3.ZERO] A {@link Cartesian3} Specifying the aligned axis in world space.
+ * @property {boolean} [sizeInMeters] A boolean specifying if the billboard size is in meters or pixels.
+ * @property {number} [width] A number specifying the width of the billboard. If undefined, the image width will be used.
+ * @property {number} [height] A number specifying the height of the billboard. If undefined, the image height will be used.
+ * @property {NearFarScalar} [scaleByDistance] A {@link NearFarScalar} Specifying near and far scaling properties of a Billboard based on the billboard's distance from the camera.
+ * @property {NearFarScalar} [translucencyByDistance] A {@link NearFarScalar} Specifying near and far translucency properties of a Billboard based on the billboard's distance from the camera.
+ * @property {NearFarScalar} [pixelOffsetScaleByDistance] A {@link NearFarScalar} Specifying near and far pixel offset scaling properties of a Billboard based on the billboard's distance from the camera.
+ * @property {BoundingRectangle} [imageSubRegion] A {@link BoundingRectangle} Specifying the sub-region of the image to use for the billboard, rather than the entire image.
+ * @property {DistanceDisplayCondition} [distanceDisplayCondition] A {@link DistanceDisplayCondition} Specifying the distance from the camera at which this billboard will be displayed.
+ * @property {number} [disableDepthTestDistance] A number specifying the distance from the camera at which to disable the depth test to, for example, prevent clipping against terrain.
+ */
+
 /**
  * <div class="notice">
  * A billboard is created and its initial
@@ -56,6 +85,9 @@ import VerticalOrigin from "./VerticalOrigin.js";
  * @internalConstructor
  * @class
  *
+ * @param {Billboard.ConstructorOptions} options Object describing initialization options
+ * @param {BillboardCollection} billboardCollection Instance of BillboardCollection
+ *
  * @demo {@link https://sandcastle.cesium.com/index.html?src=Billboards.html|Cesium Sandcastle Billboard Demo}
  */
 function Billboard(options, billboardCollection) {
@@ -1107,7 +1139,7 @@ Billboard._updateClamping = function (collection, owner) {
   }
 
   function updateFunction(clampedPosition) {
-    owner._clampedPosition = ellipsoid.cartographicToCartesian(
+    const updatedClampedPosition = ellipsoid.cartographicToCartesian(
       clampedPosition,
       owner._clampedPosition
     );
@@ -1117,12 +1149,14 @@ Billboard._updateClamping = function (collection, owner) {
         clampedPosition.height += position.height;
         ellipsoid.cartographicToCartesian(
           clampedPosition,
-          owner._clampedPosition
+          updatedClampedPosition
         );
       } else {
-        owner._clampedPosition.x += position.height;
+        updatedClampedPosition.x += position.height;
       }
     }
+
+    owner._clampedPosition = updatedClampedPosition;
   }
 
   owner._removeCallbackFunc = scene.updateHeight(

package/Source/Scene/BillboardCollection.js

@@ -426,7 +426,7 @@ function destroyBillboards(billboards) {
  * Creates and adds a billboard with the specified initial properties to the collection.
  * The added billboard is returned so it can be modified or removed from the collection later.
  *
- * @param {object}[options] A template describing the billboard's properties as shown in Example 1.
+ * @param {Billboard.ConstructorOptions}[options] A template describing the billboard's properties as shown in Example 1.
  * @returns {Billboard} The billboard that was added to the collection.
  *
  * @performance Calling <code>add</code> is expected constant time.  However, the collection's vertex buffer

package/Source/Scene/BingMapsImageryProvider.js

@@ -500,6 +500,10 @@ BingMapsImageryProvider.fromUrl = async function (url, options) {
     queryParameters.mapLayer = options.mapLayer;
   }
 
+  if (defined(options.culture)) {
+    queryParameters.culture = options.culture;
+  }
+
   const metadataResource = resource.getDerivedResource({
     url: `REST/v1/Imagery/Metadata/${mapStyle}`,
     queryParameters: queryParameters,

package/Source/Scene/Cesium3DTile.js

@@ -411,6 +411,16 @@ function Cesium3DTile(tileset, baseResource, header, parent) {
    */
   this.clippingPlanesDirty = false;
 
+  /**
+   * Tracks if the tile's relationship with a ClippingPolygonCollection has changed with regards
+   * to the ClippingPolygonCollection's state.
+   *
+   * @type {boolean}
+   *
+   * @private
+   */
+  this.clippingPolygonsDirty = false;
+
   /**
    * Tracks if the tile's request should be deferred until all non-deferred
    * tiles load.
@@ -481,7 +491,9 @@ function Cesium3DTile(tileset, baseResource, header, parent) {
   this._refines = false;
   this._shouldSelect = false;
   this._isClipped = true;
+  this._isClippedByPolygon = false;
   this._clippingPlanesState = 0; // encapsulates (_isClipped, clippingPlanes.enabled) and number/function
+  this._clippingPolygonsState = 0; // encapsulates (_isClipped, clippingPolygons.enabled) and number/function
   this._debugBoundingVolume = undefined;
   this._debugContentBoundingVolume = undefined;
   this._debugViewerRequestVolume = undefined;
@@ -1418,6 +1430,8 @@ Cesium3DTile.prototype.unloadContent = function () {
   this.lastStyleTime = 0.0;
   this.clippingPlanesDirty = this._clippingPlanesState === 0;
   this._clippingPlanesState = 0;
+  this.clippingPolygonsDirty = this._clippingPolygonsState === 0;
+  this._clippingPolygonsState = 0;
 
   this._debugColorizeTiles = false;
 
@@ -1516,6 +1530,17 @@ Cesium3DTile.prototype.visibility = function (
     }
   }
 
+  const clippingPolygons = tileset.clippingPolygons;
+  if (defined(clippingPolygons) && clippingPolygons.enabled) {
+    const intersection = clippingPolygons.computeIntersectionWithBoundingVolume(
+      boundingVolume
+    );
+
+    this._isClippedByPolygon = intersection !== Intersect.OUTSIDE;
+    // Polygon clipping intersections are determined by outer rectangles, therefore we cannot
+    // preemptively determine if a tile is completely clipped or not here.
+  }
+
   return cullingVolume.computeVisibilityWithPlaneMask(
     boundingVolume,
     parentVisibilityPlaneMask
@@ -1562,6 +1587,17 @@ Cesium3DTile.prototype.contentVisibility = function (frameState) {
     }
   }
 
+  const clippingPolygons = tileset.clippingPolygons;
+  if (defined(clippingPolygons) && clippingPolygons.enabled) {
+    const intersection = clippingPolygons.computeIntersectionWithBoundingVolume(
+      boundingVolume
+    );
+    this._isClippedByPolygon = intersection !== Intersect.OUTSIDE;
+    if (intersection === Intersect.INSIDE) {
+      return Intersect.OUTSIDE;
+    }
+  }
+
   return cullingVolume.computeVisibility(boundingVolume);
 };
 
@@ -2150,6 +2186,33 @@ function updateClippingPlanes(tile, tileset) {
   }
 }
 
+/**
+ * Compute and compare ClippingPolygons state:
+ *  - enabled-ness - are clipping polygons enabled? is this tile clipped?
+ *  - clipping polygon count & position count
+ *  - clipping function (inverse)
+
+ * @private
+ * @param {Cesium3DTile} tile
+ * @param {Cesium3DTileset} tileset
+ */
+function updateClippingPolygons(tile, tileset) {
+  const clippingPolygons = tileset.clippingPolygons;
+  let currentClippingPolygonsState = 0;
+  if (
+    defined(clippingPolygons) &&
+    tile._isClippedByPolygon &&
+    clippingPolygons.enabled
+  ) {
+    currentClippingPolygonsState = clippingPolygons.clippingPolygonsState;
+  }
+  // If clippingPolygonState for tile changed, mark clippingPolygonsDirty so content can update
+  if (currentClippingPolygonsState !== tile._clippingPolygonsState) {
+    tile._clippingPolygonsState = currentClippingPolygonsState;
+    tile.clippingPolygonsDirty = true;
+  }
+}
+
 /**
  * Get the draw commands needed to render this tile.
  *
@@ -2163,6 +2226,7 @@ Cesium3DTile.prototype.update = function (tileset, frameState, passOptions) {
   const commandStart = commandList.length;
 
   updateClippingPlanes(this, tileset);
+  updateClippingPolygons(this, tileset);
   applyDebugSettings(this, tileset, frameState, passOptions);
   updateContent(this, tileset, frameState);
 
@@ -2176,6 +2240,7 @@ Cesium3DTile.prototype.update = function (tileset, frameState, passOptions) {
   }
 
   this.clippingPlanesDirty = false; // reset after content update
+  this.clippingPolygonsDirty = false;
 };
 
 const scratchCommandList = [];

package/Source/Scene/Cesium3DTilesVoxelProvider.js

@@ -247,15 +247,8 @@ function getEllipsoidShape(region) {
 
   const shapeTransform = Matrix4.fromScale(Ellipsoid.WGS84.radii);
 
-  const minBoundsX = west;
-  const maxBoundsX = east;
-  const minBoundsY = south;
-  const maxBoundsY = north;
-  const minBoundsZ = minHeight;
-  const maxBoundsZ = maxHeight;
-
-  const minBounds = new Cartesian3(minBoundsX, minBoundsY, minBoundsZ);
-  const maxBounds = new Cartesian3(maxBoundsX, maxBoundsY, maxBoundsZ);
+  const minBounds = new Cartesian3(west, south, minHeight);
+  const maxBounds = new Cartesian3(east, north, maxHeight);
 
   return {
     shape: VoxelShapeType.ELLIPSOID,

package/Source/Scene/Cesium3DTileset.js

@@ -41,6 +41,7 @@ import Cesium3DTilesetHeatmap from "./Cesium3DTilesetHeatmap.js";
 import Cesium3DTilesetStatistics from "./Cesium3DTilesetStatistics.js";
 import Cesium3DTileStyleEngine from "./Cesium3DTileStyleEngine.js";
 import ClippingPlaneCollection from "./ClippingPlaneCollection.js";
+import ClippingPolygonCollection from "./ClippingPolygonCollection.js";
 import hasExtension from "./hasExtension.js";
 import ImplicitTileset from "./ImplicitTileset.js";
 import ImplicitTileCoordinates from "./ImplicitTileCoordinates.js";
@@ -97,6 +98,7 @@ import Ray from "../Core/Ray.js";
  * @property {boolean} [immediatelyLoadDesiredLevelOfDetail=false] When <code>skipLevelOfDetail</code> is <code>true</code>, only tiles that meet the maximum screen space error will ever be downloaded. Skipping factors are ignored and just the desired tiles are loaded.
  * @property {boolean} [loadSiblings=false] When <code>skipLevelOfDetail</code> is <code>true</code>, determines whether siblings of visible tiles are always downloaded during traversal.
  * @property {ClippingPlaneCollection} [clippingPlanes] The {@link ClippingPlaneCollection} used to selectively disable rendering the tileset.
+ * @property {ClippingPolygonCollection} [clippingPolygons] The {@link ClippingPolygonCollection} used to selectively disable rendering the tileset.
  * @property {ClassificationType} [classificationType] Determines whether terrain, 3D Tiles or both will be classified by this tileset. See {@link Cesium3DTileset#classificationType} for details about restrictions and limitations.
  * @property {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid determining the size and shape of the globe.
  * @property {object} [pointCloudShading] Options for constructing a {@link PointCloudShading} object to control point attenuation based on geometric error and lighting.
@@ -113,7 +115,6 @@ import Ray from "../Core/Ray.js";
  * @property {boolean} [showCreditsOnScreen=false] Whether to display the credits of this tileset on screen.
  * @property {SplitDirection} [splitDirection=SplitDirection.NONE] The {@link SplitDirection} split to apply to this tileset.
  * @property {boolean} [enableCollision=false] When <code>true</code>, enables collisions for camera or CPU picking. While this is <code>true</code> the camera will be prevented from going below the tileset surface if {@link ScreenSpaceCameraController#enableCollisionDetection} is true.
- * @property {boolean} [disableCollision=true] Whether to turn off collisions for camera collisions or picking. While this is <code>true</code> the camera will be allowed to go in or below the tileset surface if {@link ScreenSpaceCameraController#enableCollisionDetection} is true. Deprecated.
  * @property {boolean} [projectTo2D=false] Whether to accurately project the tileset to 2D. If this is true, the tileset will be projected accurately to 2D, but it will use more memory to do so. If this is false, the tileset will use less memory and will still render in 2D / CV mode, but its projected positions may be inaccurate. This cannot be set after the tileset has been created.
  * @property {boolean} [enablePick=false] Whether to allow collision and CPU picking with <code>pick</code> when using WebGL 1. If using WebGL 2 or above, this option will be ignored. If using WebGL 1 and this is true, the <code>pick</code> operation will work correctly, but it will use more memory to do so. If running with WebGL 1 and this is false, the model will use less memory, but <code>pick</code> will always return <code>undefined</code>. This cannot be set after the tileset has loaded.
  * @property {string} [debugHeatmapTilePropertyName] The tile variable to colorize as a heatmap. All rendered tiles will be colorized relative to each other's specified variable value.
@@ -801,7 +802,22 @@ function Cesium3DTileset(options) {
   this.loadSiblings = defaultValue(options.loadSiblings, false);
 
   this._clippingPlanes = undefined;
-  this.clippingPlanes = options.clippingPlanes;
+  if (defined(options.clippingPlanes)) {
+    ClippingPlaneCollection.setOwner(
+      options.clippingPlanes,
+      this,
+      "_clippingPlanes"
+    );
+  }
+
+  this._clippingPolygons = undefined;
+  if (defined(options.clippingPolygons)) {
+    ClippingPolygonCollection.setOwner(
+      options.clippingPolygons,
+      this,
+      "_clippingPolygons"
+    );
+  }
 
   if (defined(options.imageBasedLighting)) {
     this._imageBasedLighting = options.imageBasedLighting;
@@ -871,16 +887,6 @@ function Cesium3DTileset(options) {
    * @default false
    */
   this.enableCollision = defaultValue(options.enableCollision, false);
-
-  if (defined(options.disableCollision)) {
-    deprecationWarning(
-      "Cesium3DTileset options.disableCollision",
-      "Cesium3DTileset options.disableCollision has been deprecated in CesiumJS 1.115.  It will be removed in CesiumJS 1.116. Use options.enableCollision instead."
-    );
-
-    this.enableCollision = !options.disableCollision;
-  }
-
   this._projectTo2D = defaultValue(options.projectTo2D, false);
   this._enablePick = defaultValue(options.enablePick, false);
 
@@ -1083,34 +1089,6 @@ Object.defineProperties(Cesium3DTileset.prototype, {
     },
   },
 
-  /**
-   * Whether to turn off collisions for camera collisions or picking. While this is <code>true</code> the camera will be allowed to go in or below the tileset surface if {@link ScreenSpaceCameraController#enableCollisionDetection} is true.
-   * @memberof Cesium3DTileset.prototype
-   *
-   * @type {boolean}
-   * @default true
-   *
-   * @deprecated
-   */
-  disableCollision: {
-    get: function () {
-      deprecationWarning(
-        "Cesium3DTileset.disableCollision",
-        "Cesium3DTileset.disableCollision has been deprecated in CesiumJS 1.115.  It will be removed in CesiumJS 1.116. Use Cesium3DTileset.enableCollision instead."
-      );
-
-      return !this.enableCollision;
-    },
-    set: function (value) {
-      deprecationWarning(
-        "Cesium3DTileset.disableCollision",
-        "Cesium3DTileset.disableCollision has been deprecated in CesiumJS 1.115.  It will be removed in CesiumJS 1.116. Use Cesium3DTileset.enableCollision instead."
-      );
-
-      this.enableCollision = !value;
-    },
-  },
-
   /**
    * Gets the tileset's asset object property, which contains metadata about the tileset.
    * <p>
@@ -1159,6 +1137,22 @@ Object.defineProperties(Cesium3DTileset.prototype, {
     },
   },
 
+  /**
+   * The {@link ClippingPolygonCollection} used to selectively disable rendering the tileset.
+   *
+   * @memberof Cesium3DTileset.prototype
+   *
+   * @type {ClippingPolygonCollection}
+   */
+  clippingPolygons: {
+    get: function () {
+      return this._clippingPolygons;
+    },
+    set: function (value) {
+      ClippingPolygonCollection.setOwner(value, this, "_clippingPolygons");
+    },
+  },
+
   /**
    * Gets the tileset's properties dictionary object, which contains metadata about per-feature properties.
    * <p>
@@ -2558,6 +2552,12 @@ Cesium3DTileset.prototype.prePassesUpdate = function (frameState) {
     clippingPlanes.update(frameState);
   }
 
+  // Update clipping polygons
+  const clippingPolygons = this._clippingPolygons;
+  if (defined(clippingPolygons) && clippingPolygons.enabled) {
+    clippingPolygons.update(frameState);
+  }
+
   if (!defined(this._loadTimestamp)) {
     this._loadTimestamp = JulianDate.clone(frameState.time);
   }
@@ -2677,6 +2677,10 @@ const scratchUpdateHeightCartographic = new Cartographic();
 const scratchUpdateHeightCartographic2 = new Cartographic();
 const scratchUpdateHeightCartesian = new Cartesian3();
 function processUpdateHeight(tileset, tile, frameState) {
+  if (!tileset.enableCollision || !tileset.show) {
+    return;
+  }
+
   const heightCallbackData = tileset._addHeightCallbacks;
   const boundingSphere = tile.boundingSphere;
 
@@ -3407,6 +3411,12 @@ Cesium3DTileset.prototype.updateForPass = function (
     originalCullingVolume
   );
 
+  // Update clipping polygons
+  const clippingPolygons = this._clippingPolygons;
+  if (defined(clippingPolygons) && clippingPolygons.enabled) {
+    clippingPolygons.queueCommands(frameState);
+  }
+
   const passStatistics = this._statisticsPerPass[pass];
 
   if (this.show || ignoreCommands) {
@@ -3475,6 +3485,8 @@ Cesium3DTileset.prototype.destroy = function () {
   this._tileDebugLabels =
     this._tileDebugLabels && this._tileDebugLabels.destroy();
   this._clippingPlanes = this._clippingPlanes && this._clippingPlanes.destroy();
+  this._clippingPolygons =
+    this._clippingPolygons && this._clippingPolygons.destroy();
 
   // Traverse the tree and destroy all tiles
   if (defined(this._root)) {