@cesium/engine 26.1.0 → 26.2.0

package/Source/Scene/ScreenSpaceCameraController.js

@@ -1959,7 +1959,7 @@ function spin3D(controller, startPosition, movement) {
       scratchMousePosition,
     );
     if (defined(mousePos)) {
-      let strafing = false;
+      let strafing;
       const ray = camera.getPickRay(
         movement.startPosition,
         pickGlobeScratchRay,
@@ -2367,7 +2367,6 @@ function zoom3D(controller, startPosition, movement) {
   if (!defined(controller._globe) && defined(distance)) {
     const targetDistance = camera.getMagnitude();
     if (targetDistance < distance) {
-      intersection = undefined;
       distance = undefined;
     }
   }

package/Source/Scene/ShadowMap.js

@@ -1719,20 +1719,25 @@ function createCastDerivedCommand(
     const isPointLight = shadowMap._isPointLight;
     const usesDepthTexture = shadowMap._usesDepthTexture;
 
+    const vertexShaderSource = shaderProgram.vertexShaderSource;
+    const fragmentShaderSource = shaderProgram.fragmentShaderSource;
+
+    const hasClipping =
+      isOpaque &&
+      ShadowMapShader.hasClippingForShadowCast(fragmentShaderSource);
+
     const keyword = ShadowMapShader.getShadowCastShaderKeyword(
       isPointLight,
       isTerrain,
       usesDepthTexture,
       isOpaque,
+      hasClipping,
     );
     castShader = context.shaderCache.getDerivedShaderProgram(
       shaderProgram,
       keyword,
     );
     if (!defined(castShader)) {
-      const vertexShaderSource = shaderProgram.vertexShaderSource;
-      const fragmentShaderSource = shaderProgram.fragmentShaderSource;
-
       const castVS = ShadowMapShader.createShadowCastVertexShader(
         vertexShaderSource,
         isPointLight,
@@ -1743,6 +1748,7 @@ function createCastDerivedCommand(
         isPointLight,
         usesDepthTexture,
         isOpaque,
+        hasClipping,
       );
 
       castShader = context.shaderCache.createDerivedShaderProgram(

package/Source/Scene/ShadowMapShader.js

@@ -6,13 +6,48 @@ import ShaderSource from "../Renderer/ShaderSource.js";
  */
 function ShadowMapShader() {}
 
+const clippingDefines = {
+  HAS_CLIPPING_PLANES: true,
+  ENABLE_CLIPPING_POLYGONS: true,
+};
+
+/**
+ * Returns true if the fragment shader clips fragments via a
+ * ClippingPlaneCollection or ClippingPolygonCollection, in which case the
+ * shadow cast pass must run the original main so that clipped fragments
+ * are discarded and do not cast shadows.
+ *
+ * @param {ShaderSource} fragmentShaderSource
+ * @returns {boolean}
+ */
+ShadowMapShader.hasClippingForShadowCast = function (fragmentShaderSource) {
+  const defines = fragmentShaderSource.defines;
+  return (
+    defined(defines) &&
+    defines.some(function (define) {
+      return clippingDefines[define] === true;
+    })
+  );
+};
+
+/**
+ * @param {boolean} isPointLight
+ * @param {boolean} isTerrain
+ * @param {boolean} usesDepthTexture
+ * @param {boolean} isOpaque
+ * @param {boolean} hasClipping True if the fragment shader discards clipped
+ *   fragments. Differentiates cached shader variants so that a shader that
+ *   must call czm_shadow_cast_main() is never reused for one that does not.
+ * @returns {string}
+ */
 ShadowMapShader.getShadowCastShaderKeyword = function (
   isPointLight,
   isTerrain,
   usesDepthTexture,
   isOpaque,
+  hasClipping,
 ) {
-  return `castShadow ${isPointLight} ${isTerrain} ${usesDepthTexture} ${isOpaque}`;
+  return `castShadow ${isPointLight} ${isTerrain} ${usesDepthTexture} ${isOpaque} ${hasClipping}`;
 };
 
 ShadowMapShader.createShadowCastVertexShader = function (
@@ -54,11 +89,22 @@ ShadowMapShader.createShadowCastVertexShader = function (
   });
 };
 
+/**
+ * @param {ShaderSource} fs
+ * @param {boolean} isPointLight
+ * @param {boolean} usesDepthTexture
+ * @param {boolean} opaque
+ * @param {boolean} hasClipping True if the fragment shader discards clipped
+ *   fragments. When true, czm_shadow_cast_main() (the renamed original main)
+ *   is called first so that clipping discards execute during the shadow cast pass.
+ * @returns {ShaderSource}
+ */
 ShadowMapShader.createShadowCastFragmentShader = function (
   fs,
   isPointLight,
   usesDepthTexture,
   opaque,
+  hasClipping,
 ) {
   const defines = fs.defines.slice(0);
   const sources = fs.sources.slice(0);
@@ -85,7 +131,9 @@ ShadowMapShader.createShadowCastFragmentShader = function (
     fsSource += "uniform vec4 shadowMap_lightPositionEC; \n";
   }
 
-  if (opaque) {
+  if (opaque && hasClipping) {
+    fsSource += "void main() \n" + "{ \n" + "    czm_shadow_cast_main(); \n";
+  } else if (opaque) {
     fsSource += "void main() \n" + "{ \n";
   } else {
     fsSource +=

package/Source/Scene/SnapFramebuffer.js

@@ -0,0 +1,121 @@
+import BoundingRectangle from "../Core/BoundingRectangle.js";
+import defined from "../Core/defined.js";
+import destroyObject from "../Core/destroyObject.js";
+import PixelFormat from "../Core/PixelFormat.js";
+import FramebufferManager from "../Renderer/FramebufferManager.js";
+import PassState from "../Renderer/PassState.js";
+import PixelDatatype from "../Renderer/PixelDatatype.js";
+
+/**
+ * @private
+ */
+function SnapFramebuffer(context) {
+  const passState = new PassState(context);
+  passState.blendingEnabled = false;
+  passState.scissorTest = {
+    enabled: true,
+    rectangle: new BoundingRectangle(),
+  };
+  passState.viewport = new BoundingRectangle();
+
+  this._context = context;
+  this._fb = new FramebufferManager({
+    depthStencil: true,
+    pixelDatatype: PixelDatatype.FLOAT,
+    pixelFormat: PixelFormat.RGBA,
+  });
+  this._passState = passState;
+}
+
+function getSnapObjectsFromPixels(context, pixels, width, height) {
+  const max = Math.max(width, height);
+  const length = max * max;
+  const halfWidth = Math.floor(width * 0.5);
+  const halfHeight = Math.floor(height * 0.5);
+
+  let x = 0;
+  let y = 0;
+  let dx = 0;
+  let dy = -1;
+
+  const results = [];
+  for (let i = 0; i < length; ++i) {
+    if (
+      -halfWidth <= x &&
+      x <= halfWidth &&
+      -halfHeight <= y &&
+      y <= halfHeight
+    ) {
+      const index = 4 * ((halfHeight - y) * width + x + halfWidth);
+
+      const pickColor = pixels[index];
+      const object = context.getObjectByPickColor(pickColor);
+      if (defined(object)) {
+        results.push({
+          object: object,
+          isEdge: pixels[index + 1] > 0.0,
+          depth: pixels[index + 2],
+          x: x,
+          y: y,
+        });
+      }
+    }
+
+    if (x === y || (x < 0 && -x === y) || (x > 0 && x === 1 - y)) {
+      const temp = dx;
+      dx = -dy;
+      dy = temp;
+    }
+
+    x += dx;
+    y += dy;
+  }
+
+  return results;
+}
+
+SnapFramebuffer.prototype.begin = function (screenSpaceRectangle, viewport) {
+  const context = this._context;
+  const { width, height } = viewport;
+
+  BoundingRectangle.clone(
+    screenSpaceRectangle,
+    this._passState.scissorTest.rectangle,
+  );
+
+  this._fb.update(context, width, height);
+  this._passState.framebuffer = this._fb.framebuffer;
+
+  this._passState.viewport.width = width;
+  this._passState.viewport.height = height;
+
+  return this._passState;
+};
+
+SnapFramebuffer.prototype.end = function (screenSpaceRectangle) {
+  const width = screenSpaceRectangle.width ?? 1.0;
+  const height = screenSpaceRectangle.height ?? 1.0;
+
+  const context = this._context;
+  const pixels = context.readPixels({
+    x: screenSpaceRectangle.x,
+    y: screenSpaceRectangle.y,
+    width: width,
+    height: height,
+    pixelDatatype: PixelDatatype.FLOAT,
+    framebuffer: this._fb.framebuffer,
+  });
+
+  return getSnapObjectsFromPixels(context, pixels, width, height);
+};
+
+SnapFramebuffer.prototype.isDestroyed = function () {
+  return false;
+};
+
+SnapFramebuffer.prototype.destroy = function () {
+  this._fb.destroy();
+  return destroyObject(this);
+};
+
+export default SnapFramebuffer;

package/Source/Scene/Snapping.js

@@ -0,0 +1,184 @@
+import BoundingRectangle from "../Core/BoundingRectangle.js";
+import Cartesian2 from "../Core/Cartesian2.js";
+import Cartesian3 from "../Core/Cartesian3.js";
+import Check from "../Core/Check.js";
+import defined from "../Core/defined.js";
+import oneTimeWarning from "../Core/oneTimeWarning.js";
+import Ray from "../Core/Ray.js";
+import { pickBegin, pickEnd } from "./Picking.js";
+import SnapFramebuffer from "./SnapFramebuffer.js";
+
+/**
+ * Implementation of {@link Scene#snap}: snap-to-geometry picking.
+ *
+ * A snapping pass is an offscreen pick render (it reuses the pick render
+ * machinery via <code>pickBegin</code>/<code>pickEnd</code>) that targets a
+ * dedicated RGBA32F framebuffer instead of the RGBA8 pick framebuffer. Each
+ * pixel carries a fuller payload than a pick color:
+ * <ul>
+ *   <li>R: pick ID (uint32)</li>
+ *   <li>G: isEdge flag (0.0/1.0)</li>
+ *   <li>B: linear eye-space depth (meters)</li>
+ *   <li>A: unused</li>
+ * </ul>
+ * The payload expression is built in PickingPipelineStage (DrawCommand.snapId)
+ * and compiled into a snap-derived shader by
+ * DerivedCommand.createSnapDerivedCommand. Only commands with a
+ * <code>snapId</code> (i.e. Model-pipeline primitives) render during a
+ * snapping pass.
+ *
+ * @namespace Snapping
+ *
+ * @private
+ */
+const Snapping = {};
+
+const scratchRectangle = new BoundingRectangle(0.0, 0.0, 3.0, 3.0);
+const scratchSnapCoord = new Cartesian2();
+const scratchSnapRay = new Ray();
+const scratchSnapOffset = new Cartesian3();
+
+// Radius around the crosshair, in pixels, used to sample the nearest surface
+// (the occluder the cursor is on).
+const SNAP_OCCLUDER_RADIUS_PIXELS = 3.0;
+
+// An edge more than this fraction deeper than that surface is treated as
+// occluded by it (the edge is only visible because it pokes through a gap in a
+// nearer silhouette), so snap doesn't punch through to geometry behind the
+// object the cursor is on.
+const SNAP_OCCLUSION_TOLERANCE = 0.1;
+
+function cursorDist(hit) {
+  return Math.sqrt(hit.x * hit.x + hit.y * hit.y);
+}
+
+function selectBestHit(hits) {
+  // Depth of the nearest surface under the crosshair; edges well behind it are
+  // occluded by the object the cursor is on and must not win.
+  let occluderDepth = Number.POSITIVE_INFINITY;
+  for (const hit of hits) {
+    if (!hit.isEdge && cursorDist(hit) <= SNAP_OCCLUDER_RADIUS_PIXELS) {
+      occluderDepth = Math.min(occluderDepth, hit.depth);
+    }
+  }
+  const maxEdgeDepth = occluderDepth * (1.0 + SNAP_OCCLUSION_TOLERANCE);
+
+  // Edges outrank surfaces, but only edges in front of (or at) the occluder;
+  // otherwise fall back to the closest surface. Within the chosen group the
+  // hit closest to the crosshair wins.
+  const visible = hits.filter(
+    (hit) => !hit.isEdge || hit.depth <= maxEdgeDepth,
+  );
+  const wantEdge = visible.some((hit) => hit.isEdge);
+  const group = visible.filter((hit) => hit.isEdge === wantEdge);
+  return group.reduce((best, hit) =>
+    cursorDist(hit) < cursorDist(best) ? hit : best,
+  );
+}
+
+// Unproject a snap hit's eye-space depth (channel B of the snap framebuffer,
+// written by the snap shader at the edge fragment itself) into a world
+// position.
+function snapHitToWorld(scene, windowPosition, hit) {
+  const coords = scratchSnapCoord;
+  coords.x = windowPosition.x + hit.x;
+  coords.y = windowPosition.y + hit.y;
+
+  const ray = scene.camera.getPickRay(coords, scratchSnapRay);
+  if (!defined(ray)) {
+    return undefined;
+  }
+
+  // hit.depth is perpendicular distance from the camera plane along the view
+  // direction; convert to distance along the (non-axis-aligned) pick ray.
+  const cos = Cartesian3.dot(ray.direction, scene.camera.directionWC);
+  if (cos <= 0.0) {
+    return undefined;
+  }
+  const t = hit.depth / cos;
+
+  const offset = Cartesian3.multiplyByScalar(
+    ray.direction,
+    t,
+    scratchSnapOffset,
+  );
+  return Cartesian3.add(ray.origin, offset, new Cartesian3());
+}
+
+/**
+ * Returns the best snap target in a screen-space region around
+ * <code>windowPosition</code>. See {@link Scene#snap} for the public API.
+ *
+ * @param {Scene} scene
+ * @param {Cartesian2} windowPosition Window coordinates at the center of the search region.
+ * @param {object} [options] Object with the following properties:
+ * @param {number} [options.width=25] Width of the search region in pixels.
+ * @param {number} [options.height=options.width] Height of the search region in pixels.
+ * @returns {SceneSnapResult | undefined}
+ *
+ * @private
+ */
+Snapping.snap = function (scene, windowPosition, options) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.defined("windowPosition", windowPosition);
+  //>>includeEnd('debug');
+
+  const width = options?.width ?? 25;
+  const height = options?.height ?? width;
+
+  const { context, defaultView } = scene;
+
+  // The snap framebuffer is RGBA32F; rendering to it requires float color
+  // attachment support.
+  if (!context.colorBufferFloat) {
+    oneTimeWarning(
+      "snap-color-buffer-float",
+      "Scene.snap requires the EXT_color_buffer_float extension, which is not supported on this platform.",
+    );
+    return undefined;
+  }
+
+  // Created lazily so applications that never snap pay no framebuffer cost.
+  if (!defined(defaultView.snapFramebuffer)) {
+    defaultView.snapFramebuffer = new SnapFramebuffer(context);
+  }
+  const snapFramebuffer = defaultView.snapFramebuffer;
+
+  const drawingBufferRectangle = scratchRectangle;
+  pickBegin(scene, windowPosition, drawingBufferRectangle, width, height, {
+    framebuffer: snapFramebuffer,
+    snap: true,
+  });
+  const hits = snapFramebuffer.end(drawingBufferRectangle);
+  pickEnd(scene);
+
+  if (hits.length === 0) {
+    return undefined;
+  }
+
+  const best = selectBestHit(hits);
+  if (!defined(best)) {
+    return undefined;
+  }
+
+  const position = snapHitToWorld(scene, windowPosition, best);
+  if (!defined(position)) {
+    return undefined;
+  }
+
+  return {
+    object: best.object,
+    isEdge: best.isEdge,
+    position: position,
+    screenPosition: new Cartesian2(
+      windowPosition.x + best.x,
+      windowPosition.y + best.y,
+    ),
+  };
+};
+
+// Exposed for testing.
+Snapping._selectBestHit = selectBestHit;
+Snapping._snapHitToWorld = snapHitToWorld;
+
+export default Snapping;

package/Source/Scene/TerrainFillMesh.js

@@ -823,6 +823,7 @@ function createFillMesh(tileProvider, frameState, tile, vertexArraysToDestroy) {
   GlobeSurfaceTile.initialize(
     tile,
     tileProvider.terrainProvider,
+    tileProvider.vectorProvider,
     tileProvider._imageryLayers,
   );
 
@@ -1243,7 +1244,7 @@ function createFillMesh(tileProvider, frameState, tile, vertexArraysToDestroy) {
 
     indices[indexOut++] = centerIndex;
     indices[indexOut++] = i;
-    indices[indexOut++] = 0;
+    indices[indexOut] = 0;
 
     const westIndicesSouthToNorth = [];
     for (i = southwestIndex; i >= northwestIndex; --i) {
@@ -1800,7 +1801,7 @@ function addEdgeMesh(
   heightRange,
 ) {
   // Handle copying edges across the anti-meridian.
-  let sourceRectangle = edgeTile.rectangle;
+  let sourceRectangle;
   if (tileEdge === TileEdge.EAST && terrainFillMesh.tile.x === 0) {
     sourceRectangle = Rectangle.clone(
       edgeTile.rectangle,

package/Source/Scene/UrlTemplate3DTilesDataProvider.js

@@ -41,7 +41,7 @@ const scratchIntersectionRectangle = new Rectangle();
  * Base provider for URL-template vector sources that are rendered through a
  * runtime-generated 3D Tiles tileset.
  *
- * @private
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
  */
 class UrlTemplate3DTilesDataProvider {
   /**

package/Source/Scene/Vector3DTileContent.js

@@ -402,8 +402,8 @@ function initialize(content, arrayBuffer, byteOffset) {
   byteOffset += sizeOfUint32;
   const polylinePositionByteLength = view.getUint32(byteOffset, true);
   byteOffset += sizeOfUint32;
-  const pointsPositionByteLength = view.getUint32(byteOffset, true);
-  byteOffset += sizeOfUint32;
+  // Ignore pointsPositionByteLength
+  byteOffset += sizeOfUint32; // For pointsPositionByteLength
 
   const featureTableJson = getJsonFromTypedArray(
     uint8Array,
@@ -687,7 +687,6 @@ function initialize(content, arrayBuffer, byteOffset) {
       byteOffset,
       numberOfPoints * 3,
     );
-    byteOffset += pointsPositionByteLength;
     content._points = new Vector3DTilePoints({
       positions: pointPositions,
       batchIds: batchIds.points,

package/Source/Scene/VectorGltf3DTileContent.js

@@ -18,6 +18,7 @@ import createVectorTileBuffersFromModelComponents from "./Model/createVectorTile
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
+import { isHeightReferenceClamp } from "./HeightReference.js";
 
 /** @import BufferPrimitive from "./BufferPrimitive.js"; */
 /** @import BufferPrimitiveCollection from "./BufferPrimitiveCollection.js"; */
@@ -319,6 +320,9 @@ class VectorGltf3DTileContent {
    * @param {FrameState} frameState
    */
   update(_tileset, frameState) {
+    const tileset = this._tileset;
+    const vectorProvider = tileset._scene?.vectorProvider;
+
     if (defined(this._model) && !this._ready) {
       const model = this._model;
       model.modelMatrix = this._tile.computedTransform;
@@ -337,13 +341,24 @@ class VectorGltf3DTileContent {
       scratchTileModelMatrix,
     );
 
+    // Only bake collections selected to render this frame (avoids duplicates).
+    const isSelected =
+      defined(vectorProvider) &&
+      this._tile._selectedFrame === frameState.frameNumber;
+
     for (let i = 0; i < this._collections.length; i++) {
+      const collection = this._collections[i];
       Matrix4.multiplyTransformation(
         scratchTileModelMatrix,
         this._collectionLocalMatrices[i],
-        this._collections[i].modelMatrix,
+        collection.modelMatrix,
       );
-      this._collections[i].update(frameState);
+
+      if (!isHeightReferenceClamp(tileset._heightReference)) {
+        collection.update(frameState);
+      } else if (isSelected) {
+        vectorProvider.markSelected(collection, frameState.frameNumber);
+      }
     }
   }
 
@@ -362,9 +377,14 @@ class VectorGltf3DTileContent {
   }
 
   destroy() {
+    const vectorProvider = this._tileset._scene?.vectorProvider;
+
     this._model?.destroy();
     this._model = undefined;
-    this._collections.forEach((collection) => collection.destroy());
+    for (const collection of this._collections) {
+      vectorProvider?.remove(collection);
+      collection.destroy();
+    }
     this._collections.length = 0;
     return destroyObject(this);
   }

package/Source/Scene/View.js

@@ -11,6 +11,7 @@ import Pass from "../Renderer/Pass.js";
 import PassState from "../Renderer/PassState.js";
 import Camera from "./Camera.js";
 import EdgeFramebuffer from "./EdgeFramebuffer.js";
+import PlanarFillIdFramebuffer from "./PlanarFillIdFramebuffer.js";
 import FrustumCommands from "./FrustumCommands.js";
 import GlobeDepth from "./GlobeDepth.js";
 import GlobeTranslucencyFramebuffer from "./GlobeTranslucencyFramebuffer.js";
@@ -62,9 +63,11 @@ function View(scene, camera, viewport) {
   this.viewport = viewport;
   this.passState = passState;
   this.pickFramebuffer = new PickFramebuffer(context);
+  this.snapFramebuffer = undefined;
   this.pickDepthFramebuffer = new PickDepthFramebuffer();
   this.sceneFramebuffer = new SceneFramebuffer();
   this.edgeFramebuffer = new EdgeFramebuffer();
+  this.planarFillIdFramebuffer = new PlanarFillIdFramebuffer();
   this.globeDepth = globeDepth;
   this.globeTranslucencyFramebuffer = new GlobeTranslucencyFramebuffer();
   this.oit = oit;
@@ -211,15 +214,11 @@ function updateFrustums(view, scene, near, far) {
       curNear = Math.max(near, Math.pow(farToNearRatio, m) * near);
       curFar = Math.min(far, farToNearRatio * curNear);
     }
-    let frustumCommands = frustumCommandsList[m];
-    if (!defined(frustumCommands)) {
-      frustumCommands = frustumCommandsList[m] = new FrustumCommands(
-        curNear,
-        curFar,
-      );
+    if (!defined(frustumCommandsList[m])) {
+      frustumCommandsList[m] = new FrustumCommands(curNear, curFar);
     } else {
-      frustumCommands.near = curNear;
-      frustumCommands.far = curFar;
+      frustumCommandsList[m].near = curNear;
+      frustumCommandsList[m].far = curFar;
     }
   }
 }
@@ -443,11 +442,14 @@ View.prototype.createPotentiallyVisibleSet = function (scene) {
 
 View.prototype.destroy = function () {
   this.pickFramebuffer = this.pickFramebuffer && this.pickFramebuffer.destroy();
+  this.snapFramebuffer = this.snapFramebuffer && this.snapFramebuffer.destroy();
   this.pickDepthFramebuffer =
     this.pickDepthFramebuffer && this.pickDepthFramebuffer.destroy();
   this.sceneFramebuffer =
     this.sceneFramebuffer && this.sceneFramebuffer.destroy();
   this.edgeFramebuffer = this.edgeFramebuffer && this.edgeFramebuffer.destroy();
+  this.planarFillIdFramebuffer =
+    this.planarFillIdFramebuffer && this.planarFillIdFramebuffer.destroy();
   this.globeDepth = this.globeDepth && this.globeDepth.destroy();
   this.oit = this.oit && this.oit.destroy();
   this.translucentTileClassification =

package/Source/Scene/VoxelTraversal.js

@@ -602,7 +602,7 @@ function updateKeyframeNodes(that, frameState) {
         that._primitive.tileFailed.raiseEvent();
         continue;
       }
-      let addNodeIndex = 0;
+      let addNodeIndex;
       if (megatexture.isFull()) {
         // If the megatexture is full, try removing a discardable node with the lowest priority.
         addNodeIndex = keyframeNodesInMegatextureCount - 1 - destroyedCount;

package/Source/Scene/createElevationBandMaterial.js

@@ -202,7 +202,7 @@ function createLayeredEntries(layers) {
   const layeredEntries = preprocess(layers);
 
   let entriesAccumNext = [];
-  let entriesAccumCurr = [];
+  let entriesAccumCurr;
   let i;
 
   function addEntry(height, color) {

package/Source/Scene/renderBufferPointCollection.js

@@ -306,8 +306,7 @@ function renderBufferPointCollection(collection, frameState, renderContext) {
 
   frameState.commandList.push(command);
 
-  collection._dirtyCount = 0;
-  collection._dirtyOffset = 0;
+  collection._makeClean();
 
   return renderContext;
 }

package/Source/Scene/renderBufferPolygonCollection.js

@@ -332,8 +332,7 @@ function renderBufferPolygonCollection(collection, frameState, renderContext) {
 
   frameState.commandList.push(command);
 
-  collection._dirtyCount = 0;
-  collection._dirtyOffset = 0;
+  collection._makeClean();
 
   return renderContext;
 }

package/Source/Scene/renderBufferPolylineCollection.js

@@ -544,8 +544,7 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
 
   frameState.commandList.push(command);
 
-  collection._dirtyCount = 0;
-  collection._dirtyOffset = 0;
+  collection._makeClean();
 
   return renderContext;
 }

package/Source/Shaders/Builtin/Constants/passCesium3DTile.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passCesium3DTile = 5.0;
+const float czm_passCesium3DTile = 6.0;

package/Source/Shaders/Builtin/Constants/passCesium3DTile.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passCesium3DTile = 5.0;\n\
+const float czm_passCesium3DTile = 6.0;\n\
 ";