@cesium/engine 26.1.0 → 26.3.0

package/Source/Scene/DerivedCommand.js

@@ -346,6 +346,100 @@ DerivedCommand.createPickDerivedCommand = function (
   return result;
 };
 
+// Repacks an RGBA8-normalized pick color into the uint32 pick ID so it can be
+// carried losslessly in the R channel of the RGBA32F snap framebuffer.
+// Injected only into snap-derived shaders; referenced by DrawCommand.snapId
+// expressions built in PickingPipelineStage.
+const snapHelperSource = `uint rgba8UnormToUint32(vec4 c)
+{
+    uvec4 b = uvec4(c * 255.0 + 0.5);
+    return (b.r) | (b.g << 8u) | (b.b << 16u) | (b.a << 24u);
+}
+`;
+
+function getSnapShaderProgram(context, shaderProgram, snapId) {
+  const cachedShader = context.shaderCache.getDerivedShaderProgram(
+    shaderProgram,
+    "snap",
+  );
+  if (defined(cachedShader)) {
+    return cachedShader;
+  }
+
+  const attributeLocations = shaderProgram._attributeLocations;
+  const { sources, defines } = shaderProgram.fragmentShaderSource;
+
+  const hasFragData = sources.some((source) => source.includes("out_FragData"));
+  const outputColorVariable = hasFragData ? "out_FragData_0" : "out_FragColor";
+  const newMain = `${snapHelperSource}
+void main ()
+{
+    czm_non_snap_main();
+    if (${outputColorVariable}.a == 0.0) {
+        discard;
+    }
+    ${outputColorVariable} = ${snapId};
+} `;
+
+  const length = sources.length;
+  const newSources = new Array(length + 1);
+  for (let i = 0; i < length; ++i) {
+    newSources[i] = ShaderSource.replaceMain(sources[i], "czm_non_snap_main");
+  }
+  newSources[length] = newMain;
+  const fragmentShaderSource = new ShaderSource({
+    sources: newSources,
+    defines: defines,
+  });
+  return context.shaderCache.createDerivedShaderProgram(shaderProgram, "snap", {
+    vertexShaderSource: shaderProgram.vertexShaderSource,
+    fragmentShaderSource: fragmentShaderSource,
+    attributeLocations: attributeLocations,
+  });
+}
+
+/**
+ * Derives the command used during a snapping pass (see Scene#snap). Identical
+ * in structure to the pick derived command, but the fragment shader writes the
+ * float snap payload (DrawCommand.snapId) into the RGBA32F snap framebuffer
+ * instead of the RGBA8 pick color.
+ *
+ * @private
+ */
+DerivedCommand.createSnapDerivedCommand = function (
+  scene,
+  command,
+  context,
+  result,
+) {
+  if (!defined(result)) {
+    result = {};
+  }
+
+  const shader = result.snapCommand?.shaderProgram;
+  const renderState = result.snapCommand?.renderState;
+
+  result.snapCommand = DrawCommand.shallowClone(command, result.snapCommand);
+
+  if (!defined(shader) || result.shaderProgramId !== command.shaderProgram.id) {
+    result.snapCommand.shaderProgram = getSnapShaderProgram(
+      context,
+      command.shaderProgram,
+      command.snapId,
+    );
+    result.snapCommand.renderState = getPickRenderState(
+      scene,
+      command.renderState,
+    );
+    result.shaderProgramId = command.shaderProgram.id;
+  } else {
+    result.snapCommand.shaderProgram = shader;
+    result.snapCommand.renderState = renderState;
+  }
+
+  return result;
+};
+
 /**
  * Replaces the value of the specified 'define' directive identifier
  * with the given value.

package/Source/Scene/EdgeFramebuffer.js

@@ -9,16 +9,12 @@ import ClearCommand from "../Renderer/ClearCommand.js";
 /**
  * Creates and manages framebuffers for edge visibility rendering.
  *
- * @param {Object} options Object with the following properties:
- *
  * @alias EdgeFramebuffer
  * @constructor
  *
  * @private
  */
-function EdgeFramebuffer(options) {
-  options = options || {};
-
+function EdgeFramebuffer() {
   // Create framebuffer manager with multiple render targets (MRT)
   // Color attachment 0: edge color output (visualization / debug)
   // Color attachment 1: R: edge type, G: featureId (metadata / ids)

package/Source/Scene/FrameState.js

@@ -190,6 +190,7 @@ function FrameState(context, creditDisplay, jobScheduler) {
    * @property {boolean} render <code>true</code> if the primitive should update for a render pass, <code>false</code> otherwise.
    * @property {boolean} pick <code>true</code> if the primitive should update for a picking pass, <code>false</code> otherwise.
    * @property {boolean} pickVoxel <code>true</code> if the primitive should update for a voxel picking pass, <code>false</code> otherwise.
+   * @property {boolean} snap <code>true</code> if the current picking pass is a snapping pass (see {@link Scene#snap}), <code>false</code> otherwise. Only ever <code>true</code> while <code>pick</code> is also <code>true</code>.
    * @property {boolean} depth <code>true</code> if the primitive should update for a depth only pass, <code>false</code> otherwise.
    * @property {boolean} postProcess <code>true</code> if the primitive should update for a per-feature post-process pass, <code>false</code> otherwise.
    * @property {boolean} offscreen <code>true</code> if the primitive should update for an offscreen pass, <code>false</code> otherwise.
@@ -211,6 +212,10 @@ function FrameState(context, creditDisplay, jobScheduler) {
      * @default false
      */
     pickVoxel: false,
+    /**
+     * @default false
+     */
+    snap: false,
     /**
      * @default false
      */
@@ -473,6 +478,18 @@ function FrameState(context, creditDisplay, jobScheduler) {
    * @private
    */
   this.edgeVisibilityRequested = false;
+
+  /**
+   * Internal toggle indicating that at least one primitive for this frame has
+   * the BENTLEY_materials_planar_fill extension present. This allows lazy
+   * allocation of the planar fill feature-ID framebuffer.
+   * Set by MaterialPipelineStage at draw command build time and renewed
+   * per frame by ModelSceneGraph while planar fill primitives render.
+   * Consumed by Scene to update its _enablePlanarFillId flag.
+   * @type {boolean}
+   * @private
+   */
+  this.planarFillRequested = false;
 }
 
 /**

package/Source/Scene/GeoJsonPrimitive.js

@@ -1,8 +1,5 @@
 // @ts-check
 
-/** @import {GeoJson, GeoJsonFeature, GeoJsonGeometry, GeoJsonPosition} from "../Core/globalTypes.js"; */
-/** @import FrameState from "./FrameState.js"; */
-
 import Cartesian2 from "../Core/Cartesian2.js";
 import Cartesian3 from "../Core/Cartesian3.js";
 import Check from "../Core/Check.js";
@@ -11,6 +8,7 @@ import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import Ellipsoid from "../Core/Ellipsoid.js";
 import Frozen from "../Core/Frozen.js";
+import HeightReference, { isHeightReferenceClamp } from "./HeightReference.js";
 import PolygonPipeline from "../Core/PolygonPipeline.js";
 import Resource from "../Core/Resource.js";
 import RuntimeError from "../Core/RuntimeError.js";
@@ -20,6 +18,13 @@ import BufferPolygon from "./BufferPolygon.js";
 import BufferPolygonCollection from "./BufferPolygonCollection.js";
 import BufferPolyline from "./BufferPolyline.js";
 import BufferPolylineCollection from "./BufferPolylineCollection.js";
+import assert from "../Core/assert.js";
+import oneTimeWarning from "../Core/oneTimeWarning.js";
+
+/** @import FrameState from "./FrameState.js"; */
+/** @import Scene from "./Scene.js"; */
+/** @import {GeoJson, GeoJsonFeature, GeoJsonGeometry, GeoJsonPosition} from "../Core/globalTypes.js"; */
+/** @import VectorProvider from "../Core/VectorProvider.js"; */
 
 /**
  * @typedef {object} GeoJsonPrimitiveConstructorOptions
@@ -29,6 +34,9 @@ import BufferPolylineCollection from "./BufferPolylineCollection.js";
  * @property {boolean} [allowPicking=true]
  * @property {boolean} [show=true]
  * @property {function(number, object, Record<string, unknown>):object} [pickObjectFactory]
+ * @property {HeightReference} [heightReference=HeightReference.NONE] Allows clamping (draping)
+ *  polylines and polygons on terrain and 3D Tiles. Point clamping is not currently supported.
+ * @property {Scene} [scene] Required for primitives that use a clamping {@link HeightReference}.
  */
 
 /**
@@ -41,14 +49,36 @@ import BufferPolylineCollection from "./BufferPolylineCollection.js";
  * added directly to {@link Scene#primitives}.
  *
  * @example
+ * // Load GeoJSON
  * const loader = await Cesium.GeoJsonPrimitive.fromUrl("./data.geojson");
  * viewer.scene.primitives.add(loader);
  *
+ * @example
+ * // Access GeoJSON features and properties
  * loader.points;     // BufferPointCollection | undefined
  * loader.polylines;  // BufferPolylineCollection | undefined
  * loader.polygons;   // BufferPolygonCollection | undefined
  * loader.ids;        // source feature IDs
  * loader.properties; // source feature properties
+ *
+ * @example
+ * // Style GeoJSON
+ * const material = new Cesium.BufferPolylineMaterial({
+ *   color: Cesium.Color.RED,
+ *   width: 4,
+ * });
+ *
+ * const polyline = new Cesium.BufferPolyline();
+ * const count = primitive.polylines.primitiveCount;
+ * for (let i = 0; i < count; i++) {
+ *   primitive.polylines.get(i, polyline);
+ *
+ *   const properties = primitive.getProperties(polyline.featureId);
+ *   if (properties.myCustomProperty === true) {
+ *     polyline.setMaterial(material);
+ *   }
+ * }
+ *
  * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
  */
 class GeoJsonPrimitive {
@@ -59,9 +89,7 @@ class GeoJsonPrimitive {
     options = options ?? Frozen.EMPTY_OBJECT;
 
     //>>includeStart('debug', pragmas.debug);
-    if (!defined(options.geoJson)) {
-      throw new DeveloperError("options.geoJson is required.");
-    }
+    Check.defined("geoJson", options.geoJson);
     //>>includeEnd('debug');
 
     const parseResult = parseGeoJson(/** @type {GeoJson} */ (options.geoJson));
@@ -86,35 +114,62 @@ class GeoJsonPrimitive {
     this._polylines = undefined;
     this._polygons = undefined;
 
+    /**
+     * @type {HeightReference}
+     * @private
+     */
+    this._heightReference = options.heightReference ?? HeightReference.NONE;
+
+    /**
+     * @type {Scene|undefined}
+     * @private
+     */
+    this._scene = options.scene;
+
+    const heightReference = this._heightReference;
+    const scene = this._scene;
+
+    //>>includeStart('debug', pragmas.debug);
+    assert(
+      !isHeightReferenceClamp(heightReference) || defined(scene),
+      "Clamped HeightReference requires `options.scene`.",
+    );
+    //>>includeEnd('debug');
+
     if (parseResult.pointCount > 0) {
-      /** @type {Record<string, unknown>} */
-      const pointOptions = {
+      //>>includeStart('debug', pragmas.debug);
+      if (isHeightReferenceClamp(heightReference)) {
+        oneTimeWarning(
+          "geojson-heightref",
+          "Clamped HeightReference unsupported on BufferPointCollection.",
+        );
+      }
+      //>>includeEnd('debug');
+
+      this._points = new BufferPointCollection({
         primitiveCountMax: parseResult.pointCount,
         allowPicking: allowPicking,
-      };
-      this._points = new BufferPointCollection(pointOptions);
+      });
     }
 
     if (parseResult.polylineCount > 0) {
-      /** @type {Record<string, unknown>} */
-      const polylineOptions = {
+      this._polylines = new BufferPolylineCollection({
         primitiveCountMax: parseResult.polylineCount,
         vertexCountMax: parseResult.polylineVertexCount,
         allowPicking: allowPicking,
-      };
-      this._polylines = new BufferPolylineCollection(polylineOptions);
+        heightReference,
+      });
     }
 
     if (parseResult.polygonCount > 0) {
-      /** @type {Record<string, unknown>} */
-      const polygonOptions = {
+      this._polygons = new BufferPolygonCollection({
         primitiveCountMax: parseResult.polygonCount,
         vertexCountMax: parseResult.polygonVertexCount,
         holeCountMax: parseResult.polygonHoleCount,
         triangleCountMax: parseResult.polygonTriangleCount,
         allowPicking: allowPicking,
-      };
-      this._polygons = new BufferPolygonCollection(polygonOptions);
+        heightReference,
+      });
     }
 
     const scratch = new Cartesian3();
@@ -338,30 +393,65 @@ class GeoJsonPrimitive {
       return;
     }
 
-    if (defined(this._points)) {
-      this._points.update(frameState);
+    const points = this._points;
+    const polylines = this._polylines;
+    const polygons = this._polygons;
+    const frameNumber = frameState.frameNumber;
+    const heightReference = this._heightReference;
+
+    const vectorProvider = isHeightReferenceClamp(heightReference)
+      ? // @ts-expect-error Missing types, non-ES6 class.
+        /** @type {VectorProvider} */ (this._scene.vectorProvider)
+      : null;
+
+    if (defined(points)) {
+      points.update(frameState);
     }
-    if (defined(this._polylines)) {
-      this._polylines.update(frameState);
+
+    if (defined(polylines)) {
+      if (defined(vectorProvider)) {
+        vectorProvider.markForFrame(polylines, frameNumber, heightReference);
+      } else {
+        polylines.update(frameState);
+      }
     }
-    if (defined(this._polygons)) {
-      this._polygons.update(frameState);
+
+    if (defined(polygons)) {
+      if (defined(vectorProvider)) {
+        vectorProvider.markForFrame(polygons, frameNumber, heightReference);
+      } else {
+        polygons.update(frameState);
+      }
     }
   }
 
   destroy() {
+    const vectorProvider = isHeightReferenceClamp(this._heightReference)
+      ? // @ts-expect-error Missing types, non-ES6 class.
+        /** @type {VectorProvider} */ (this._scene.vectorProvider)
+      : null;
+
     if (this._points) {
       this._points.destroy();
       this._points = undefined;
     }
+
     if (this._polylines) {
+      if (defined(vectorProvider)) {
+        vectorProvider.remove(this._polylines);
+      }
       this._polylines.destroy();
       this._polylines = undefined;
     }
+
     if (this._polygons) {
+      if (defined(vectorProvider)) {
+        vectorProvider.remove(this._polygons);
+      }
       this._polygons.destroy();
       this._polygons = undefined;
     }
+
     return destroyObject(this);
   }
 

package/Source/Scene/Globe.js

@@ -28,6 +28,7 @@ import QuadtreePrimitive from "./QuadtreePrimitive.js";
 import SceneMode from "./SceneMode.js";
 import ShadowMode from "./ShadowMode.js";
 import CesiumMath from "../Core/Math.js";
+import VectorProvider from "../Core/VectorProvider.js";
 
 /**
  * The globe rendered in the scene, including its terrain ({@link Globe#terrainProvider})
@@ -45,6 +46,9 @@ function Globe(ellipsoid) {
     ellipsoid: ellipsoid,
   });
   const imageryLayerCollection = new ImageryLayerCollection();
+  const vectorProvider = new VectorProvider({
+    tilingScheme: terrainProvider.tilingScheme,
+  });
 
   this._ellipsoid = ellipsoid;
   this._imageryLayerCollection = imageryLayerCollection;
@@ -57,12 +61,15 @@ function Globe(ellipsoid) {
       terrainProvider: terrainProvider,
       imageryLayers: imageryLayerCollection,
       surfaceShaderSet: this._surfaceShaderSet,
+      vectorProvider,
     }),
   });
 
   this._terrainProvider = terrainProvider;
   this._terrainProviderChanged = new Event();
 
+  this._vectorProvider = vectorProvider;
+
   this._undergroundColor = Color.clone(Color.BLACK);
   this._undergroundColorAlphaByDistance = new NearFarScalar(
     ellipsoid.maximumRadius / 1000.0,
@@ -515,6 +522,9 @@ Object.defineProperties(Globe.prototype, {
     set: function (value) {
       if (value !== this._terrainProvider) {
         this._terrainProvider = value;
+        if (defined(value)) {
+          this._vectorProvider.tilingScheme = value.tilingScheme;
+        }
         this._terrainProviderChanged.raiseEvent(value);
         if (defined(this._material)) {
           makeShadersDirty(this);
@@ -534,6 +544,16 @@ Object.defineProperties(Globe.prototype, {
       return this._terrainProviderChanged;
     },
   },
+  /**
+   * @memberof Globe.prototype
+   * @type {VectorProvider}
+   * @ignore
+   */
+  vectorProvider: {
+    get: function () {
+      return this._vectorProvider;
+    },
+  },
   /**
    * Gets an event that's raised when the length of the tile load queue has changed since the last render frame.  When the load queue is empty,
    * all terrain and imagery for the current view have been loaded.  The event passes the new length of the tile load queue.

package/Source/Scene/GlobeDepth.js

@@ -2,6 +2,7 @@ import BoundingRectangle from "../Core/BoundingRectangle.js";
 import Color from "../Core/Color.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
+import PixelFormat from "../Core/PixelFormat.js";
 import ClearCommand from "../Renderer/ClearCommand.js";
 import FramebufferManager from "../Renderer/FramebufferManager.js";
 import PixelDatatype from "../Renderer/PixelDatatype.js";
@@ -21,6 +22,7 @@ import StencilOperation from "./StencilOperation.js";
  */
 function GlobeDepth() {
   this._picking = false;
+  this._snapping = false;
   this._numSamples = 1;
   this._tempCopyDepthTexture = undefined;
 
@@ -28,6 +30,16 @@ function GlobeDepth() {
     depthStencil: true,
     supportsDepthTexture: true,
   });
+  // Float twin of the pick color framebuffer, used during a snapping pass
+  // (see Scene#snap). RGBA32F so each pixel can carry the snap payload
+  // (uint32 pick ID, isEdge flag, eye-space depth). GPU resources are only
+  // allocated on first use (FramebufferManager allocates lazily in update).
+  this._snapColorFramebuffer = new FramebufferManager({
+    depthStencil: true,
+    supportsDepthTexture: true,
+    pixelDatatype: PixelDatatype.FLOAT,
+    pixelFormat: PixelFormat.RGBA,
+  });
   this._outputFramebuffer = new FramebufferManager({
     depthStencil: true,
     supportsDepthTexture: true,
@@ -61,6 +73,9 @@ function GlobeDepth() {
 Object.defineProperties(GlobeDepth.prototype, {
   colorFramebufferManager: {
     get: function () {
+      if (this._snapping) {
+        return this._snapColorFramebuffer;
+      }
       return this._picking
         ? this._pickColorFramebuffer
         : this._outputFramebuffer;
@@ -84,6 +99,14 @@ Object.defineProperties(GlobeDepth.prototype, {
       this._picking = value;
     },
   },
+  snapping: {
+    get: function () {
+      return this._snapping;
+    },
+    set: function (value) {
+      this._snapping = value;
+    },
+  },
 });
 
 function updateCopyCommands(globeDepth, context, width, height, passState) {
@@ -260,7 +283,9 @@ GlobeDepth.prototype.update = function (
       : PixelDatatype.FLOAT
     : PixelDatatype.UNSIGNED_BYTE;
   this._numSamples = numSamples;
-  if (this.picking) {
+  if (this.snapping) {
+    this._snapColorFramebuffer.update(context, width, height);
+  } else if (this.picking) {
     this._pickColorFramebuffer.update(context, width, height);
   } else {
     this._outputFramebuffer.update(
@@ -377,6 +402,7 @@ GlobeDepth.prototype.isDestroyed = function () {
 
 GlobeDepth.prototype.destroy = function () {
   this._pickColorFramebuffer.destroy();
+  this._snapColorFramebuffer.destroy();
   this._outputFramebuffer.destroy();
   this._copyDepthFramebuffer.destroy();
   this._tempCopyDepthFramebuffer.destroy();

package/Source/Scene/GlobeSurfaceShaderSet.js

@@ -4,6 +4,7 @@ import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
 import TerrainQuantization from "../Core/TerrainQuantization.js";
 import ShaderProgram from "../Renderer/ShaderProgram.js";
+import VectorCommon from "../Shaders/VectorCommon.js";
 import getClippingFunction from "./getClippingFunction.js";
 import SceneMode from "./SceneMode.js";
 
@@ -81,7 +82,8 @@ class GlobeSurfaceShader {
  * @property {boolean} [hasExaggeration]
  * @property {boolean} [showUndergroundColor]
  * @property {boolean} [translucent]
- * @ignore
+ * @property {boolean} [vectorAntialias]
+ * @private
  */
 
 /**
@@ -138,6 +140,14 @@ class GlobeSurfaceShaderSet {
     const hasExaggeration = options.hasExaggeration;
     const showUndergroundColor = options.showUndergroundColor;
     const translucent = options.translucent;
+    const vectorData = surfaceTile.vectorData;
+    const hasVectorLayer = vectorData?.show;
+    const hasVectorPolylines = hasVectorLayer && vectorData.hasPolylines;
+    const hasVectorPolygons = hasVectorLayer && vectorData.hasPolygons;
+    const vectorAntialias = hasVectorLayer && options.vectorAntialias;
+    const vectorWidthInMeters = hasVectorPolylines && vectorData.hasMeterWidths;
+    const vectorMixedWidthUnits =
+      vectorWidthInMeters && vectorData.hasPixelWidths;
 
     let quantization = 0;
     let quantizationDefine = "";
@@ -201,7 +211,13 @@ class GlobeSurfaceShaderSet {
         (+showUndergroundColor << 30) |
         (+translucent << 31)) >>>
         0) +
-      (applyDayNightAlpha ? 0x100000000 : 0);
+      (applyDayNightAlpha ? 0x100000000 : 0) +
+      (hasVectorLayer ? 0x200000000 : 0) +
+      (hasVectorPolylines ? 0x400000000 : 0) +
+      (hasVectorPolygons ? 0x800000000 : 0) +
+      (vectorAntialias ? 0x1000000000 : 0) +
+      (vectorWidthInMeters ? 0x2000000000 : 0) +
+      (vectorMixedWidthUnits ? 0x4000000000 : 0);
 
     let currentClippingShaderState = 0;
     // @ts-expect-error Missing types.
@@ -259,12 +275,6 @@ class GlobeSurfaceShaderSet {
         );
       }
 
-      // Need to go before GlobeFS
-      if (currentClippingPolygonsShaderState !== 0) {
-        fs.sources.unshift(getPolygonClippingFunction(frameState.context));
-        vs.sources.unshift(getUnpackClippingFunction(frameState.context));
-      }
-
       vs.defines.push(quantizationDefine);
       fs.defines.push(
         `TEXTURE_UNITS ${numberOfDayTextures}`,
@@ -360,20 +370,10 @@ class GlobeSurfaceShaderSet {
 
       if (enableClippingPolygons) {
         fs.defines.push("ENABLE_CLIPPING_POLYGONS");
-        vs.defines.push("ENABLE_CLIPPING_POLYGONS");
 
         if (clippingPolygons.inverse) {
           fs.defines.push("CLIPPING_INVERSE");
         }
-
-        fs.defines.push(
-          // @ts-expect-error Missing types.
-          `CLIPPING_POLYGON_REGIONS_LENGTH ${clippingPolygons.extentsCount}`,
-        );
-        vs.defines.push(
-          // @ts-expect-error Missing types.
-          `CLIPPING_POLYGON_REGIONS_LENGTH ${clippingPolygons.extentsCount}`,
-        );
       }
 
       if (colorCorrect) {
@@ -392,6 +392,30 @@ class GlobeSurfaceShaderSet {
         vs.defines.push("EXAGGERATION");
       }
 
+      if (hasVectorLayer) {
+        fs.defines.push("HAS_VECTOR_LAYER");
+        if (hasVectorPolylines) {
+          fs.defines.push("HAS_VECTOR_POLYLINES");
+        }
+        if (hasVectorPolygons) {
+          fs.defines.push("HAS_VECTOR_POLYGONS");
+        }
+        if (vectorAntialias) {
+          fs.defines.push("VECTOR_ANTIALIAS");
+        }
+        if (vectorWidthInMeters) {
+          fs.defines.push("VECTOR_WIDTH_IN_METERS");
+        }
+        if (vectorMixedWidthUnits) {
+          fs.defines.push("VECTOR_WIDTH_MIXED_UNITS");
+        }
+      }
+
+      // Polygon clipping builds on top of the same machinery vector rendering uses
+      if (hasVectorLayer || enableClippingPolygons) {
+        fs.sources.unshift(VectorCommon);
+      }
+
       let computeDayColor =
         "\
       vec4 computeDayColor(vec4 initialColor, vec3 textureCoordinates, float nightBlend)\n\
@@ -528,41 +552,6 @@ function getPositionMode(sceneMode) {
   return positionMode;
 }
 
-/**
- * @param {Context} context
- * @ignore
- */
-function getPolygonClippingFunction(context) {
-  // return a noop for webgl1
-  // @ts-expect-error Missing types.
-  if (!context.webgl2) {
-    return `void clipPolygons(highp sampler2D clippingDistance, int regionsLength, vec2 clippingPosition, int regionIndex) {
-    }`;
-  }
-
-  return `void clipPolygons(highp sampler2D clippingDistance, int regionsLength, vec2 clippingPosition, int regionIndex) {
-    czm_clipPolygons(clippingDistance, regionsLength, clippingPosition, regionIndex);
-  }`;
-}
-
-/**
- * @param {Context} context
- * @ignore
- */
-function getUnpackClippingFunction(context) {
-  // return a noop for webgl1
-  // @ts-expect-error Missing types.
-  if (!context.webgl2) {
-    return `vec4 unpackClippingExtents(highp sampler2D extentsTexture, int index) {
-      return vec4();
-    }`;
-  }
-
-  return `vec4 unpackClippingExtents(highp sampler2D extentsTexture, int index) {
-    return czm_unpackClippingExtents(extentsTexture, index);
-  }`;
-}
-
 /**
  * @param {boolean} useWebMercatorProjection
  * @returns {string}