@cesium/engine 8.0.0 → 9.1.0

package/Source/Scene/VoxelPrimitive.js

@@ -22,6 +22,9 @@ import PolylineCollection from "./PolylineCollection.js";
 import VoxelShapeType from "./VoxelShapeType.js";
 import VoxelTraversal from "./VoxelTraversal.js";
 import CustomShader from "./Model/CustomShader.js";
+import Cartographic from "../Core/Cartographic.js";
+import Ellipsoid from "../Core/Ellipsoid.js";
+import VerticalExaggeration from "../Core/VerticalExaggeration.js";
 
 /**
  * A primitive that renders voxel data from a {@link VoxelProvider}.
@@ -231,6 +234,14 @@ function VoxelPrimitive(options) {
     defaultValue(options.modelMatrix, Matrix4.IDENTITY)
   );
 
+  /**
+   * Model matrix with vertical exaggeration applied. Only used for BOX shape type.
+   *
+   * @type {Matrix4}
+   * @private
+   */
+  this._exaggeratedModelMatrix = Matrix4.clone(this._modelMatrix);
+
   /**
    * The primitive's model matrix multiplied by the provider's model matrix.
    * This member is not known until the provider is ready.
@@ -320,18 +331,12 @@ function VoxelPrimitive(options) {
    */
   this._transformNormalLocalToWorld = new Matrix3();
 
-  /**
-   * @type {number}
-   * @private
-   */
-  this._stepSizeUv = 1.0;
-
   // Rendering
   /**
    * @type {boolean}
    * @private
    */
-  this._jitter = true;
+  this._jitter = false;
 
   /**
    * @type {boolean}
@@ -469,12 +474,25 @@ function initialize(primitive, provider) {
   primitive.minClippingBounds = VoxelShapeType.getMinBounds(shapeType);
   primitive.maxClippingBounds = VoxelShapeType.getMaxBounds(shapeType);
 
+  // Initialize the exaggerated versions of bounds and model matrix
+  primitive._exaggeratedMinBounds = Cartesian3.clone(
+    primitive._minBounds,
+    primitive._exaggeratedMinBounds
+  );
+  primitive._exaggeratedMaxBounds = Cartesian3.clone(
+    primitive._maxBounds,
+    primitive._exaggeratedMaxBounds
+  );
+  primitive._exaggeratedModelMatrix = Matrix4.clone(
+    primitive._modelMatrix,
+    primitive._exaggeratedModelMatrix
+  );
+
   checkTransformAndBounds(primitive, provider);
 
   // Create the shape object, and update it so it is valid for VoxelTraversal
   const ShapeConstructor = VoxelShapeType.getShapeConstructor(shapeType);
   primitive._shape = new ShapeConstructor();
-  updateVerticalExaggeration(primitive);
   primitive._shapeVisible = updateShapeAndTransforms(
     primitive,
     primitive._shape,
@@ -1132,7 +1150,7 @@ VoxelPrimitive.prototype.update = function (frameState) {
     cameraPositionWorld,
     uniforms.cameraPositionUv
   );
-  uniforms.stepSize = this._stepSizeUv * this._stepSizeMultiplier;
+  uniforms.stepSize = this._stepSizeMultiplier;
 
   // Render the primitive
   const command = frameState.passes.pick
@@ -1144,11 +1162,16 @@ VoxelPrimitive.prototype.update = function (frameState) {
   frameState.commandList.push(command);
 };
 
+const scratchExaggerationScale = new Cartesian3();
+const scratchExaggerationCenter = new Cartesian3();
+const scratchCartographicCenter = new Cartographic();
+const scratchExaggerationTranslation = new Cartesian3();
+
 /**
  * Update the exaggerated bounds of a primitive to account for vertical exaggeration
  * Currently only applies to Ellipsoid shape type
  * @param {VoxelPrimitive} primitive
- * @param {FrameState} [frameState]
+ * @param {FrameState} frameState
  * @private
  */
 function updateVerticalExaggeration(primitive, frameState) {
@@ -1160,16 +1183,87 @@ function updateVerticalExaggeration(primitive, frameState) {
     primitive._maxBounds,
     primitive._exaggeratedMaxBounds
   );
-  if (defined(frameState) && primitive.shape === VoxelShapeType.ELLIPSOID) {
+
+  if (primitive.shape === VoxelShapeType.ELLIPSOID) {
+    // Apply the exaggeration by stretching the height bounds
     const relativeHeight = frameState.verticalExaggerationRelativeHeight;
     const exaggeration = frameState.verticalExaggeration;
     primitive._exaggeratedMinBounds.z =
       (primitive._minBounds.z - relativeHeight) * exaggeration + relativeHeight;
     primitive._exaggeratedMaxBounds.z =
       (primitive._maxBounds.z - relativeHeight) * exaggeration + relativeHeight;
+  } else if (primitive.shape === VoxelShapeType.BOX) {
+    // Apply the exaggeration via the model matrix
+    const exaggerationScale = Cartesian3.fromElements(
+      1.0,
+      1.0,
+      frameState.verticalExaggeration,
+      scratchExaggerationScale
+    );
+    primitive._exaggeratedModelMatrix = Matrix4.multiplyByScale(
+      primitive._modelMatrix,
+      exaggerationScale,
+      primitive._exaggeratedModelMatrix
+    );
+    primitive._exaggeratedModelMatrix = Matrix4.multiplyByTranslation(
+      primitive._exaggeratedModelMatrix,
+      computeBoxExaggerationTranslation(primitive, frameState),
+      primitive._exaggeratedModelMatrix
+    );
   }
 }
 
+function computeBoxExaggerationTranslation(primitive, frameState) {
+  // Compute translation based on box center, relative height, and exaggeration
+  const {
+    shapeTransform = Matrix4.IDENTITY,
+    globalTransform = Matrix4.IDENTITY,
+  } = primitive._provider;
+
+  // Find the Cartesian position of the center of the OBB
+  const initialCenter = Matrix4.getTranslation(
+    shapeTransform,
+    scratchExaggerationCenter
+  );
+  const intermediateCenter = Matrix4.multiplyByPoint(
+    primitive._modelMatrix,
+    initialCenter,
+    scratchExaggerationCenter
+  );
+  const transformedCenter = Matrix4.multiplyByPoint(
+    globalTransform,
+    intermediateCenter,
+    scratchExaggerationCenter
+  );
+
+  // Find the cartographic height
+  const ellipsoid = Ellipsoid.WGS84;
+  const centerCartographic = ellipsoid.cartesianToCartographic(
+    transformedCenter,
+    scratchCartographicCenter
+  );
+
+  let centerHeight = 0.0;
+  if (defined(centerCartographic)) {
+    centerHeight = centerCartographic.height;
+  }
+
+  // Find the shift that will put the center in the right position relative
+  // to relativeHeight, after it is scaled by verticalExaggeration
+  const exaggeratedHeight = VerticalExaggeration.getHeight(
+    centerHeight,
+    frameState.verticalExaggeration,
+    frameState.verticalExaggerationRelativeHeight
+  );
+
+  return Cartesian3.fromElements(
+    0.0,
+    0.0,
+    (exaggeratedHeight - centerHeight) / frameState.verticalExaggeration,
+    scratchExaggerationTranslation
+  );
+}
+
 /**
  * Initialize primitive properties that are derived from the voxel provider
  * @param {VoxelPrimitive} primitive
@@ -1254,7 +1348,7 @@ function checkTransformAndBounds(primitive, provider) {
   // Compound model matrix = global transform * model matrix * shape transform
   Matrix4.multiplyTransformation(
     globalTransform,
-    primitive._modelMatrix,
+    primitive._exaggeratedModelMatrix,
     primitive._compoundModelMatrix
   );
   Matrix4.multiplyTransformation(
@@ -1345,8 +1439,6 @@ function updateShapeAndTransforms(primitive, shape, provider) {
   );
 
   // Set member variables when the shape is dirty
-  const dimensions = provider.dimensions;
-  primitive._stepSizeUv = shape.computeApproximateStepSize(dimensions);
   primitive._transformPositionWorldToUv = Matrix4.multiplyTransformation(
     transformPositionLocalToUv,
     transformPositionWorldToLocal,

package/Source/Scene/VoxelRenderResources.js

@@ -3,6 +3,7 @@ import combine from "../Core/combine.js";
 import defined from "../Core/defined.js";
 import ShaderBuilder from "../Renderer/ShaderBuilder.js";
 import ShaderDestination from "../Renderer/ShaderDestination.js";
+import VoxelUtils from "../Shaders/Voxels/VoxelUtils.js";
 import VoxelFS from "../Shaders/Voxels/VoxelFS.js";
 import VoxelVS from "../Shaders/Voxels/VoxelVS.js";
 import IntersectionUtils from "../Shaders/Voxels/IntersectionUtils.js";
@@ -89,6 +90,7 @@ function VoxelRenderResources(primitive) {
     customShader.fragmentShaderText,
     "#line 0",
     Octree,
+    VoxelUtils,
     IntersectionUtils,
     Megatexture,
   ]);
@@ -124,7 +126,6 @@ function VoxelRenderResources(primitive) {
 
   const shapeType = primitive._provider.shape;
   if (shapeType === "BOX") {
-    shaderBuilder.addDefine("SHAPE_BOX", undefined, ShaderDestination.FRAGMENT);
     shaderBuilder.addFragmentLines([
       convertUvToBox,
       IntersectBox,
@@ -132,17 +133,22 @@ function VoxelRenderResources(primitive) {
     ]);
   } else if (shapeType === "CYLINDER") {
     shaderBuilder.addFragmentLines([
+      convertUvToCylinder,
       IntersectLongitude,
       IntersectCylinder,
       Intersection,
-      convertUvToCylinder,
     ]);
   } else if (shapeType === "ELLIPSOID") {
+    shaderBuilder.addDefine(
+      "SHAPE_ELLIPSOID",
+      undefined,
+      ShaderDestination.FRAGMENT
+    );
     shaderBuilder.addFragmentLines([
+      convertUvToEllipsoid,
       IntersectLongitude,
       IntersectEllipsoid,
       Intersection,
-      convertUvToEllipsoid,
     ]);
   }
 

package/Source/Scene/VoxelShape.js

@@ -130,16 +130,6 @@ VoxelShape.prototype.computeOrientedBoundingBoxForTile =
 VoxelShape.prototype.computeOrientedBoundingBoxForSample =
   DeveloperError.throwInstantiationError;
 
-/**
- * Computes an approximate step size for raymarching the root tile of a voxel grid.
- * The update function must be called before calling this function.
- *
- * @param {Cartesian3} voxelDimensions The voxel grid dimensions for a tile.
- * @returns {number} The step size.
- */
-VoxelShape.prototype.computeApproximateStepSize =
-  DeveloperError.throwInstantiationError;
-
 /**
  * Defines the minimum bounds of the shape. The meaning can vary per-shape.
  *

package/Source/Scene/processVoxelProperties.js

@@ -153,6 +153,7 @@ function processVoxelProperties(renderResources, primitive) {
   shaderBuilder.addStructField(voxelStructId, "vec3", "viewDirWorld");
   shaderBuilder.addStructField(voxelStructId, "vec3", "surfaceNormal");
   shaderBuilder.addStructField(voxelStructId, "float", "travelDistance");
+  shaderBuilder.addStructField(voxelStructId, "int", "stepCount");
   shaderBuilder.addStructField(voxelStructId, "int", "tileIndex");
   shaderBuilder.addStructField(voxelStructId, "int", "sampleIndex");
 

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -64,6 +64,7 @@ import czm_cascadeColor from './Functions/cascadeColor.js'
 import czm_cascadeDistance from './Functions/cascadeDistance.js'
 import czm_cascadeMatrix from './Functions/cascadeMatrix.js'
 import czm_cascadeWeights from './Functions/cascadeWeights.js'
+import czm_clipPolygons from './Functions/clipPolygons.js'
 import czm_columbusViewMorph from './Functions/columbusViewMorph.js'
 import czm_computeAtmosphereColor from './Functions/computeAtmosphereColor.js'
 import czm_computeGroundAtmosphereScattering from './Functions/computeGroundAtmosphereScattering.js'
@@ -127,6 +128,7 @@ import czm_transformPlane from './Functions/transformPlane.js'
 import czm_translateRelativeToEye from './Functions/translateRelativeToEye.js'
 import czm_translucentPhong from './Functions/translucentPhong.js'
 import czm_transpose from './Functions/transpose.js'
+import czm_unpackClippingExtents from './Functions/unpackClippingExtents.js'
 import czm_unpackDepth from './Functions/unpackDepth.js'
 import czm_unpackFloat from './Functions/unpackFloat.js'
 import czm_unpackUint from './Functions/unpackUint.js'
@@ -203,6 +205,7 @@ export default {
     czm_cascadeDistance : czm_cascadeDistance,
     czm_cascadeMatrix : czm_cascadeMatrix,
     czm_cascadeWeights : czm_cascadeWeights,
+    czm_clipPolygons : czm_clipPolygons,
     czm_columbusViewMorph : czm_columbusViewMorph,
     czm_computeAtmosphereColor : czm_computeAtmosphereColor,
     czm_computeGroundAtmosphereScattering : czm_computeGroundAtmosphereScattering,
@@ -266,6 +269,7 @@ export default {
     czm_translateRelativeToEye : czm_translateRelativeToEye,
     czm_translucentPhong : czm_translucentPhong,
     czm_transpose : czm_transpose,
+    czm_unpackClippingExtents : czm_unpackClippingExtents,
     czm_unpackDepth : czm_unpackDepth,
     czm_unpackFloat : czm_unpackFloat,
     czm_unpackUint : czm_unpackUint,

package/Source/Shaders/Builtin/Functions/clipPolygons.glsl

@@ -0,0 +1,37 @@
+float getSignedDistance(vec2 uv, highp sampler2D clippingDistance) {
+    float signedDistance = texture(clippingDistance, uv).r;
+    return (signedDistance - 0.5) * 2.0;
+}
+
+void czm_clipPolygons(highp sampler2D clippingDistance, int extentsLength, vec2 clippingPosition, int regionIndex) {
+    // Position is completely outside of polygons bounds
+    vec2 rectUv = clippingPosition;
+    if (regionIndex < 0 || rectUv.x <= 0.0 || rectUv.y <= 0.0 || rectUv.x >= 1.0 || rectUv.y >= 1.0) {
+        #ifdef CLIPPING_INVERSE 
+            discard;
+        #endif
+        return;
+    }
+
+    vec2 clippingDistanceTextureDimensions = vec2(textureSize(clippingDistance, 0));
+    vec2 sampleOffset = max(1.0 / clippingDistanceTextureDimensions, vec2(0.005));
+    float dimension = float(extentsLength);
+    if (extentsLength > 2) {
+       dimension = ceil(log2(float(extentsLength)));
+    }
+
+    vec2 textureOffset = vec2(mod(float(regionIndex), dimension), floor(float(regionIndex) / dimension)) / dimension;
+    vec2 uv = textureOffset + rectUv / dimension;
+
+    float signedDistance = getSignedDistance(uv, clippingDistance);
+
+    #ifdef CLIPPING_INVERSE
+    if (signedDistance > 0.0)  {
+        discard;
+    }
+    #else
+    if (signedDistance < 0.0)  {
+        discard;
+    }
+    #endif
+}

package/Source/Shaders/Builtin/Functions/clipPolygons.js

@@ -0,0 +1,39 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "float getSignedDistance(vec2 uv, highp sampler2D clippingDistance) {\n\
+    float signedDistance = texture(clippingDistance, uv).r;\n\
+    return (signedDistance - 0.5) * 2.0;\n\
+}\n\
+\n\
+void czm_clipPolygons(highp sampler2D clippingDistance, int extentsLength, vec2 clippingPosition, int regionIndex) {\n\
+    // Position is completely outside of polygons bounds\n\
+    vec2 rectUv = clippingPosition;\n\
+    if (regionIndex < 0 || rectUv.x <= 0.0 || rectUv.y <= 0.0 || rectUv.x >= 1.0 || rectUv.y >= 1.0) {\n\
+        #ifdef CLIPPING_INVERSE \n\
+            discard;\n\
+        #endif\n\
+        return;\n\
+    }\n\
+\n\
+    vec2 clippingDistanceTextureDimensions = vec2(textureSize(clippingDistance, 0));\n\
+    vec2 sampleOffset = max(1.0 / clippingDistanceTextureDimensions, vec2(0.005));\n\
+    float dimension = float(extentsLength);\n\
+    if (extentsLength > 2) {\n\
+       dimension = ceil(log2(float(extentsLength)));\n\
+    }\n\
+\n\
+    vec2 textureOffset = vec2(mod(float(regionIndex), dimension), floor(float(regionIndex) / dimension)) / dimension;\n\
+    vec2 uv = textureOffset + rectUv / dimension;\n\
+\n\
+    float signedDistance = getSignedDistance(uv, clippingDistance);\n\
+\n\
+    #ifdef CLIPPING_INVERSE\n\
+    if (signedDistance > 0.0)  {\n\
+        discard;\n\
+    }\n\
+    #else\n\
+    if (signedDistance < 0.0)  {\n\
+        discard;\n\
+    }\n\
+    #endif\n\
+}\n\
+";

package/Source/Shaders/Builtin/Functions/unpackClippingExtents.glsl

@@ -0,0 +1,14 @@
+vec2 getLookupUv(vec2 dimensions, int i) {
+    int pixY = i / int(dimensions.x);
+    int pixX = i - (pixY * int(dimensions.x));
+    float pixelWidth = 1.0 / dimensions.x;
+    float pixelHeight = 1.0 / dimensions.y;
+    float u = (float(pixX) + 0.5) * pixelWidth; // sample from center of pixel
+    float v = (float(pixY) + 0.5) * pixelHeight;
+    return vec2(u, v);
+}
+
+vec4 czm_unpackClippingExtents(highp sampler2D extentsTexture, int index) {
+    vec2 textureDimensions = vec2(textureSize(extentsTexture, 0));
+    return texture(extentsTexture, getLookupUv(textureDimensions, index));
+}

package/Source/Shaders/Builtin/Functions/unpackClippingExtents.js

@@ -0,0 +1,15 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "vec2 getLookupUv(vec2 dimensions, int i) {\n\
+    int pixY = i / int(dimensions.x);\n\
+    int pixX = i - (pixY * int(dimensions.x));\n\
+    float pixelWidth = 1.0 / dimensions.x;\n\
+    float pixelHeight = 1.0 / dimensions.y;\n\
+    float u = (float(pixX) + 0.5) * pixelWidth; // sample from center of pixel\n\
+    float v = (float(pixY) + 0.5) * pixelHeight;\n\
+    return vec2(u, v);\n\
+}\n\
+\n\
+vec4 czm_unpackClippingExtents(highp sampler2D extentsTexture, int index) {\n\
+    vec2 textureDimensions = vec2(textureSize(extentsTexture, 0));\n\
+    return texture(extentsTexture, getLookupUv(textureDimensions, index));\n\
+}";

package/Source/Shaders/GlobeFS.glsl

@@ -77,6 +77,12 @@ uniform mat4 u_clippingPlanesMatrix;
 uniform vec4 u_clippingPlanesEdgeStyle;
 #endif
 
+#ifdef ENABLE_CLIPPING_POLYGONS
+uniform highp sampler2D u_clippingDistance;
+in vec2 v_clippingPosition;
+flat in int v_regionIndex;
+#endif
+
 #if defined(GROUND_ATMOSPHERE) || defined(FOG) && defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_VERTEX_LIGHTING) || defined(ENABLE_DAYNIGHT_SHADING))
 uniform float u_minimumBrightness;
 #endif
@@ -413,6 +419,12 @@ void main()
     }
 #endif
 
+#ifdef ENABLE_CLIPPING_POLYGONS
+    vec2 clippingPosition = v_clippingPosition;
+    int regionIndex = v_regionIndex;
+    clipPolygons(u_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);    
+#endif
+
 #ifdef HIGHLIGHT_FILL_TILE
     finalColor = vec4(mix(finalColor.rgb, u_fillHighlightColor.rgb, u_fillHighlightColor.a), finalColor.a);
 #endif

package/Source/Shaders/GlobeFS.js

@@ -78,6 +78,12 @@ uniform mat4 u_clippingPlanesMatrix;\n\
 uniform vec4 u_clippingPlanesEdgeStyle;\n\
 #endif\n\
 \n\
+#ifdef ENABLE_CLIPPING_POLYGONS\n\
+uniform highp sampler2D u_clippingDistance;\n\
+in vec2 v_clippingPosition;\n\
+flat in int v_regionIndex;\n\
+#endif\n\
+\n\
 #if defined(GROUND_ATMOSPHERE) || defined(FOG) && defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_VERTEX_LIGHTING) || defined(ENABLE_DAYNIGHT_SHADING))\n\
 uniform float u_minimumBrightness;\n\
 #endif\n\
@@ -414,6 +420,12 @@ void main()\n\
     }\n\
 #endif\n\
 \n\
+#ifdef ENABLE_CLIPPING_POLYGONS\n\
+    vec2 clippingPosition = v_clippingPosition;\n\
+    int regionIndex = v_regionIndex;\n\
+    clipPolygons(u_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);    \n\
+#endif\n\
+\n\
 #ifdef HIGHLIGHT_FILL_TILE\n\
     finalColor = vec4(mix(finalColor.rgb, u_fillHighlightColor.rgb, u_fillHighlightColor.a), finalColor.a);\n\
 #endif\n\

package/Source/Shaders/GlobeVS.glsl

@@ -46,6 +46,12 @@ out vec3 v_atmosphereMieColor;
 out float v_atmosphereOpacity;
 #endif
 
+#ifdef ENABLE_CLIPPING_POLYGONS
+uniform highp sampler2D u_clippingExtents;
+out vec2 v_clippingPosition;
+flat out int v_regionIndex;
+#endif
+
 // These functions are generated at runtime.
 vec4 getPosition(vec3 position, float height, vec2 textureCoordinates);
 float get2DYPositionFraction(vec2 textureCoordinates);
@@ -207,6 +213,32 @@ void main()
     v_normalEC = czm_normal3D * v_normalMC;
 #endif
 
+#ifdef ENABLE_CLIPPING_POLYGONS
+    vec2 sphericalLatLong = czm_approximateSphericalCoordinates(position3DWC);
+    sphericalLatLong.y = czm_branchFreeTernary(sphericalLatLong.y < czm_pi, sphericalLatLong.y, sphericalLatLong.y - czm_twoPi);
+    
+    vec2 minDistance = vec2(czm_infinity);
+    v_clippingPosition = vec2(czm_infinity);
+    v_regionIndex = -1;
+
+    for (int regionIndex = 0; regionIndex < CLIPPING_POLYGON_REGIONS_LENGTH; regionIndex++) {
+        vec4 extents = unpackClippingExtents(u_clippingExtents, regionIndex);
+        vec2 rectUv = (sphericalLatLong.yx - extents.yx) * extents.wz;
+
+        vec2 clamped = clamp(rectUv, vec2(0.0), vec2(1.0));
+        vec2 distance = abs(rectUv - clamped) * extents.wz;
+
+        float threshold = 0.01;
+        if (minDistance.x > distance.x || minDistance.y > distance.y) {
+            minDistance = distance;
+            v_clippingPosition = rectUv;
+            if (rectUv.x > threshold && rectUv.y > threshold && rectUv.x < 1.0 - threshold && rectUv.y < 1.0 - threshold) {
+                v_regionIndex = regionIndex;
+            }
+        }
+    }
+#endif
+
 #if defined(FOG) || (defined(GROUND_ATMOSPHERE) && !defined(PER_FRAGMENT_GROUND_ATMOSPHERE))
 
     bool dynamicLighting = false;

package/Source/Shaders/GlobeVS.js

@@ -47,6 +47,12 @@ out vec3 v_atmosphereMieColor;\n\
 out float v_atmosphereOpacity;\n\
 #endif\n\
 \n\
+#ifdef ENABLE_CLIPPING_POLYGONS\n\
+uniform highp sampler2D u_clippingExtents;\n\
+out vec2 v_clippingPosition;\n\
+flat out int v_regionIndex;\n\
+#endif\n\
+\n\
 // These functions are generated at runtime.\n\
 vec4 getPosition(vec3 position, float height, vec2 textureCoordinates);\n\
 float get2DYPositionFraction(vec2 textureCoordinates);\n\
@@ -208,6 +214,32 @@ void main()\n\
     v_normalEC = czm_normal3D * v_normalMC;\n\
 #endif\n\
 \n\
+#ifdef ENABLE_CLIPPING_POLYGONS\n\
+    vec2 sphericalLatLong = czm_approximateSphericalCoordinates(position3DWC);\n\
+    sphericalLatLong.y = czm_branchFreeTernary(sphericalLatLong.y < czm_pi, sphericalLatLong.y, sphericalLatLong.y - czm_twoPi);\n\
+    \n\
+    vec2 minDistance = vec2(czm_infinity);\n\
+    v_clippingPosition = vec2(czm_infinity);\n\
+    v_regionIndex = -1;\n\
+\n\
+    for (int regionIndex = 0; regionIndex < CLIPPING_POLYGON_REGIONS_LENGTH; regionIndex++) {\n\
+        vec4 extents = unpackClippingExtents(u_clippingExtents, regionIndex);\n\
+        vec2 rectUv = (sphericalLatLong.yx - extents.yx) * extents.wz;\n\
+\n\
+        vec2 clamped = clamp(rectUv, vec2(0.0), vec2(1.0));\n\
+        vec2 distance = abs(rectUv - clamped) * extents.wz;\n\
+\n\
+        float threshold = 0.01;\n\
+        if (minDistance.x > distance.x || minDistance.y > distance.y) {\n\
+            minDistance = distance;\n\
+            v_clippingPosition = rectUv;\n\
+            if (rectUv.x > threshold && rectUv.y > threshold && rectUv.x < 1.0 - threshold && rectUv.y < 1.0 - threshold) {\n\
+                v_regionIndex = regionIndex;\n\
+            }\n\
+        }\n\
+    }\n\
+#endif\n\
+\n\
 #if defined(FOG) || (defined(GROUND_ATMOSPHERE) && !defined(PER_FRAGMENT_GROUND_ATMOSPHERE))\n\
 \n\
     bool dynamicLighting = false;\n\

package/Source/Shaders/Model/GeometryStageVS.glsl

@@ -16,7 +16,7 @@ vec4 geometryStage(inout ProcessedAttributes attributes, mat4 modelView, mat3 no
     #endif
 
     // Sometimes the custom shader and/or style needs this
-    #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE)
+    #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE) || defined(ENABLE_CLIPPING_POLYGONS)
     // Note that this is a 32-bit position which may result in jitter on small
     // scales.
     v_positionWC = (czm_model * vec4(positionMC, 1.0)).xyz;

package/Source/Shaders/Model/GeometryStageVS.js

@@ -17,7 +17,7 @@ export default "vec4 geometryStage(inout ProcessedAttributes attributes, mat4 mo
     #endif\n\
 \n\
     // Sometimes the custom shader and/or style needs this\n\
-    #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE)\n\
+    #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE) || defined(ENABLE_CLIPPING_POLYGONS)\n\
     // Note that this is a 32-bit position which may result in jitter on small\n\
     // scales.\n\
     v_positionWC = (czm_model * vec4(positionMC, 1.0)).xyz;\n\

package/Source/Shaders/Model/ModelClippingPolygonsStageFS.glsl

@@ -0,0 +1,6 @@
+void modelClippingPolygonsStage()
+{
+    vec2 clippingPosition = v_clippingPosition;
+    int regionIndex = v_regionIndex;
+    czm_clipPolygons(model_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);
+}

package/Source/Shaders/Model/ModelClippingPolygonsStageFS.js

@@ -0,0 +1,8 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "void modelClippingPolygonsStage()\n\
+{\n\
+    vec2 clippingPosition = v_clippingPosition;\n\
+    int regionIndex = v_regionIndex;\n\
+    czm_clipPolygons(model_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);\n\
+}\n\
+";

package/Source/Shaders/Model/ModelClippingPolygonsStageVS.glsl

@@ -0,0 +1,27 @@
+void modelClippingPolygonsStage(ProcessedAttributes attributes)
+{
+    vec2 sphericalLatLong = czm_approximateSphericalCoordinates(v_positionWC);
+    sphericalLatLong.y = czm_branchFreeTernary(sphericalLatLong.y < czm_pi, sphericalLatLong.y, sphericalLatLong.y - czm_twoPi);
+
+    vec2 minDistance = vec2(czm_infinity);
+    v_regionIndex = -1;
+    v_clippingPosition = vec2(czm_infinity);
+
+    for (int regionIndex = 0; regionIndex < CLIPPING_POLYGON_REGIONS_LENGTH; regionIndex++) {
+        vec4 extents = czm_unpackClippingExtents(model_clippingExtents, regionIndex);
+        vec2 rectUv = (sphericalLatLong.yx - extents.yx) * extents.wz;
+
+        vec2 clamped = clamp(rectUv, vec2(0.0), vec2(1.0));
+        vec2 distance = abs(rectUv - clamped) * extents.wz;
+        
+        if (minDistance.x > distance.x || minDistance.y > distance.y) {
+            minDistance = distance;
+            v_clippingPosition = rectUv;
+        }
+
+        float threshold = 0.01;
+        if (rectUv.x > threshold && rectUv.y > threshold && rectUv.x < 1.0 - threshold && rectUv.y < 1.0 - threshold) {
+            v_regionIndex = regionIndex;
+        }
+    }
+}

package/Source/Shaders/Model/ModelClippingPolygonsStageVS.js

@@ -0,0 +1,29 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "void modelClippingPolygonsStage(ProcessedAttributes attributes)\n\
+{\n\
+    vec2 sphericalLatLong = czm_approximateSphericalCoordinates(v_positionWC);\n\
+    sphericalLatLong.y = czm_branchFreeTernary(sphericalLatLong.y < czm_pi, sphericalLatLong.y, sphericalLatLong.y - czm_twoPi);\n\
+\n\
+    vec2 minDistance = vec2(czm_infinity);\n\
+    v_regionIndex = -1;\n\
+    v_clippingPosition = vec2(czm_infinity);\n\
+\n\
+    for (int regionIndex = 0; regionIndex < CLIPPING_POLYGON_REGIONS_LENGTH; regionIndex++) {\n\
+        vec4 extents = czm_unpackClippingExtents(model_clippingExtents, regionIndex);\n\
+        vec2 rectUv = (sphericalLatLong.yx - extents.yx) * extents.wz;\n\
+\n\
+        vec2 clamped = clamp(rectUv, vec2(0.0), vec2(1.0));\n\
+        vec2 distance = abs(rectUv - clamped) * extents.wz;\n\
+        \n\
+        if (minDistance.x > distance.x || minDistance.y > distance.y) {\n\
+            minDistance = distance;\n\
+            v_clippingPosition = rectUv;\n\
+        }\n\
+\n\
+        float threshold = 0.01;\n\
+        if (rectUv.x > threshold && rectUv.y > threshold && rectUv.x < 1.0 - threshold && rectUv.y < 1.0 - threshold) {\n\
+            v_regionIndex = regionIndex;\n\
+        }\n\
+    }\n\
+}\n\
+";