@cesium/engine 9.0.0 → 9.2.0

package/Build/Workers/transferTypedArrayTest.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.116
+ * Version 1.118
  *
  * Copyright 2011-2022 Cesium Contributors
  *

package/Build/Workers/upsampleQuantizedTerrainMesh.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.116
+ * Version 1.118
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -26,51 +26,49 @@
 import {
   EllipsoidalOccluder_default,
   TerrainEncoding_default
-} from "./chunk-BCU2LH5T.js";
+} from "./chunk-3VDHTBY5.js";
 import {
   createTaskProcessorWorker_default
-} from "./chunk-RMOEYCZW.js";
+} from "./chunk-AROLUUGS.js";
 import {
   OrientedBoundingBox_default
-} from "./chunk-WHUSTDIB.js";
+} from "./chunk-4RG6WOXH.js";
 import {
   AttributeCompression_default
-} from "./chunk-E6WXPSJS.js";
-import "./chunk-LQJ5FFFR.js";
-import "./chunk-TJBU6GML.js";
-import "./chunk-L4BW3RUA.js";
-import "./chunk-NP2GYYE5.js";
+} from "./chunk-G7IAO7CW.js";
+import "./chunk-CFBGPZU6.js";
+import "./chunk-PUQR43HZ.js";
+import "./chunk-2TRB253J.js";
+import "./chunk-3PV5HQ2R.js";
 import {
   IndexDatatype_default
-} from "./chunk-P4XKB3QZ.js";
+} from "./chunk-5OK5JFDP.js";
 import {
   BoundingSphere_default
-} from "./chunk-7COR472O.js";
-import "./chunk-2KACWKS4.js";
-import "./chunk-X6XOMPWL.js";
+} from "./chunk-7PFZ4Z7C.js";
 import {
   Rectangle_default
-} from "./chunk-2XPLH3JY.js";
-import "./chunk-NZWNZA6S.js";
+} from "./chunk-GUFV24F4.js";
+import "./chunk-WOYQB5HM.js";
 import {
   Cartesian2_default,
   Cartesian3_default,
   Cartographic_default,
   Ellipsoid_default
-} from "./chunk-ADOVHYWO.js";
+} from "./chunk-GX5LMUGZ.js";
 import {
   Math_default
-} from "./chunk-QCQUZGXI.js";
-import "./chunk-I37B3MZ2.js";
-import "./chunk-N4KXMWQU.js";
-import "./chunk-TZORKRNK.js";
+} from "./chunk-ETC45PHH.js";
+import "./chunk-UICVDDCQ.js";
+import "./chunk-U2LSTOMA.js";
+import "./chunk-EODIOQ35.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-SS4ESNE3.js";
+} from "./chunk-DIVFF6DK.js";
 import {
   defined_default
-} from "./chunk-YDVSBWEO.js";
+} from "./chunk-IF2OX6R4.js";
 
 // packages/engine/Source/Core/Intersections2D.js
 var Intersections2D = {};

package/Source/Core/Ion.js

@@ -4,7 +4,7 @@ import Resource from "./Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJjM2I5YWEyNS02NzRiLTRmOTEtYWZhNi1jNzlhZTI5Yjc3YWYiLCJpZCI6MjU5LCJpYXQiOjE3MTE1NTQ2Njd9.dawdakmPEfdAKpH2-Cv-IDOlVHwicZ1Mgk7ZzI775hQ";
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiI0YjhlOGM0Yy0xNzcwLTQwNWEtODk4Yy0xMGJkODg4MTA5ZGEiLCJpZCI6MjU5LCJpYXQiOjE3MTc0MzM4NjB9.VwBpSnRTNdg_G6uvU-JNsRNcSOCDMKW_j3Nl5E7wfwg";
 /**
  * Default settings for accessing the Cesium ion API.
  *

package/Source/Core/Math.js

@@ -205,7 +205,6 @@ CesiumMath.FOUR_GIGABYTES = 4 * 1024 * 1024 * 1024;
  * @param {number} value The value to return the sign of.
  * @returns {number} The sign of value.
  */
-// eslint-disable-next-line es/no-math-sign
 CesiumMath.sign = defaultValue(Math.sign, function sign(value) {
   value = +value; // coerce to number
   if (value === 0 || value !== value) {
@@ -292,7 +291,6 @@ CesiumMath.normalize = function (value, rangeMinimum, rangeMaximum) {
  * @param {number} value The number whose hyperbolic sine is to be returned.
  * @returns {number} The hyperbolic sine of <code>value</code>.
  */
-// eslint-disable-next-line es/no-math-sinh
 CesiumMath.sinh = defaultValue(Math.sinh, function sinh(value) {
   return (Math.exp(value) - Math.exp(-value)) / 2.0;
 });
@@ -317,7 +315,6 @@ CesiumMath.sinh = defaultValue(Math.sinh, function sinh(value) {
  * @param {number} value The number whose hyperbolic cosine is to be returned.
  * @returns {number} The hyperbolic cosine of <code>value</code>.
  */
-// eslint-disable-next-line es/no-math-cosh
 CesiumMath.cosh = defaultValue(Math.cosh, function cosh(value) {
   return (Math.exp(value) + Math.exp(-value)) / 2.0;
 });
@@ -1034,7 +1031,6 @@ CesiumMath.logBase = function (number, base) {
  * @param {number} [number] The number.
  * @returns {number} The result.
  */
-// eslint-disable-next-line es/no-math-cbrt
 CesiumMath.cbrt = defaultValue(Math.cbrt, function cbrt(number) {
   const result = Math.pow(Math.abs(number), 1.0 / 3.0);
   return number < 0.0 ? -result : result;
@@ -1047,7 +1043,6 @@ CesiumMath.cbrt = defaultValue(Math.cbrt, function cbrt(number) {
  * @param {number} number The number.
  * @returns {number} The result.
  */
-// eslint-disable-next-line es/no-math-log2
 CesiumMath.log2 = defaultValue(Math.log2, function log2(number) {
   return Math.log(number) * Math.LOG2E;
 });

package/Source/Core/PixelFormat.js

@@ -240,6 +240,7 @@ PixelFormat.validate = function (pixelFormat) {
  */
 PixelFormat.isColorFormat = function (pixelFormat) {
   return (
+    pixelFormat === PixelFormat.RED ||
     pixelFormat === PixelFormat.ALPHA ||
     pixelFormat === PixelFormat.RGB ||
     pixelFormat === PixelFormat.RGBA ||

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/TaskProcessor.js

@@ -81,18 +81,34 @@ function urlFromScript(script) {
 function createWorker(url) {
   const uri = new Uri(url);
   const isUri = uri.scheme().length !== 0 && uri.fragment().length === 0;
+  const moduleID = url.replace(/\.js$/, "");
 
   const options = {};
   let workerPath;
+  let crossOriginUrl;
+
+  // If we are provided a fully resolved URL, check it is cross-origin
+  // Or if provided a module ID, check the full absolute URL instead.
   if (isCrossOriginUrl(url)) {
+    crossOriginUrl = url;
+  } else if (!isUri) {
+    const moduleAbsoluteUrl = buildModuleUrl(
+      `${TaskProcessor._workerModulePrefix}/${moduleID}.js`
+    );
+
+    if (isCrossOriginUrl(moduleAbsoluteUrl)) {
+      crossOriginUrl = moduleAbsoluteUrl;
+    }
+  }
+
+  if (crossOriginUrl) {
     // To load cross-origin, create a shim worker from a blob URL
-    const script = `importScripts("${url}");`;
+    const script = `import "${crossOriginUrl}";`;
     workerPath = urlFromScript(script);
+    options.type = "module";
     return new Worker(workerPath, options);
   }
 
-  const moduleID = url.replace(/\.js$/, "");
-
   /* global CESIUM_WORKERS */
   if (!isUri && typeof CESIUM_WORKERS !== "undefined") {
     // If the workers are embedded, create a shim worker from the embedded script data

package/Source/Core/sampleTerrain.js

@@ -20,7 +20,7 @@ import defined from "./defined.js";
  * @param {TerrainProvider} terrainProvider The terrain provider from which to query heights.
  * @param {number} level The terrain level-of-detail from which to query terrain heights.
  * @param {Cartographic[]} positions The positions to update with terrain heights.
- * @param {boolean} [rejectOnTileFail=false] If true, for a failed terrain tile request the promise will be rejected. If false, returned heights will be undefined.
+ * @param {boolean} [rejectOnTileFail=false] If true, for any failed terrain tile requests, the promise will be rejected. If false, returned heights will be undefined.
  * @returns {Promise<Cartographic[]>} A promise that resolves to the provided list of positions when terrain the query has completed.
  *
  * @see sampleTerrainMostDetailed
@@ -139,12 +139,12 @@ function drainTileRequestQueue(tileRequests, results, rejectOnTileFail) {
     rejectOnTileFail
   );
   if (success) {
-    return drainTileRequestQueue(tileRequests, results);
+    return drainTileRequestQueue(tileRequests, results, rejectOnTileFail);
   }
 
   // wait a small fixed amount of time first, before retrying the same request again
   return delay(100).then(() => {
-    return drainTileRequestQueue(tileRequests, results);
+    return drainTileRequestQueue(tileRequests, results, rejectOnTileFail);
   });
 }
 

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 =
-  "AAPK3b7fccd1509046758d03c6641e404040gQG5edfR9eun2VcwtbXJKNbQjIZ7ma2vUd9ulqZK4lo3R_DJIAhwoGW9p86JNauB";
+  "AAPKe5e6f1571ad74096bfacbdf289c5cdb687BUrehhWYnNo9tN4coC66_qhHDNruh3ygZV90buspkWdOqZUq6tb0kCb_dms9Ir";
 /**
  * Default options for accessing the ArcGIS image tile service.
  *

package/Source/Scene/Billboard.js

@@ -28,7 +28,7 @@ import VerticalOrigin from "./VerticalOrigin.js";
  * 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 {*} [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.
@@ -892,7 +892,7 @@ Object.defineProperties(Billboard.prototype, {
   /**
    * Gets or sets the user-defined object returned when the billboard is picked.
    * @memberof Billboard.prototype
-   * @type {object}
+   * @type {*}
    */
   id: {
     get: function () {
@@ -1139,7 +1139,7 @@ Billboard._updateClamping = function (collection, owner) {
   }
 
   function updateFunction(clampedPosition) {
-    owner._clampedPosition = ellipsoid.cartographicToCartesian(
+    const updatedClampedPosition = ellipsoid.cartographicToCartesian(
       clampedPosition,
       owner._clampedPosition
     );
@@ -1149,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/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/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.
@@ -800,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;
@@ -1120,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>
@@ -2519,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);
   }
@@ -3372,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) {
@@ -3440,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)) {