@cesium/engine 7.0.0 → 8.0.0

package/Source/Scene/VoxelRenderResources.js

@@ -8,6 +8,7 @@ import VoxelVS from "../Shaders/Voxels/VoxelVS.js";
 import IntersectionUtils from "../Shaders/Voxels/IntersectionUtils.js";
 import IntersectDepth from "../Shaders/Voxels/IntersectDepth.js";
 import IntersectClippingPlanes from "../Shaders/Voxels/IntersectClippingPlanes.js";
+import IntersectLongitude from "../Shaders/Voxels/IntersectLongitude.js";
 import IntersectBox from "../Shaders/Voxels/IntersectBox.js";
 import IntersectCylinder from "../Shaders/Voxels/IntersectCylinder.js";
 import IntersectEllipsoid from "../Shaders/Voxels/IntersectEllipsoid.js";
@@ -131,12 +132,14 @@ function VoxelRenderResources(primitive) {
     ]);
   } else if (shapeType === "CYLINDER") {
     shaderBuilder.addFragmentLines([
+      IntersectLongitude,
       IntersectCylinder,
       Intersection,
       convertUvToCylinder,
     ]);
   } else if (shapeType === "ELLIPSOID") {
     shaderBuilder.addFragmentLines([
+      IntersectLongitude,
       IntersectEllipsoid,
       Intersection,
       convertUvToEllipsoid,

package/Source/Scene/VoxelShape.js

@@ -117,6 +117,19 @@ VoxelShape.prototype.update = DeveloperError.throwInstantiationError;
 VoxelShape.prototype.computeOrientedBoundingBoxForTile =
   DeveloperError.throwInstantiationError;
 
+/**
+ * Computes an oriented bounding box for a specified sample within a specified tile.
+ * The update function must be called before calling this function.
+ *
+ * @param {SpatialNode} spatialNode The spatial node containing the sample
+ * @param {Cartesian3} tileDimensions The size of the tile in number of samples, before padding
+ * @param {Cartesian3} tileUv The sample coordinate within the tile
+ * @param {OrientedBoundingBox} result The oriented bounding box that will be set to enclose the specified sample
+ * @returns {OrientedBoundingBox} The oriented bounding box.
+ */
+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.

package/Source/Scene/VoxelTraversal.js

@@ -49,16 +49,14 @@ function VoxelTraversal(
    */
   this._primitive = primitive;
 
-  const length = types.length;
-
   /**
    * @type {Megatexture[]}
    * @readonly
    */
-  this.megatextures = new Array(length);
+  this.megatextures = new Array(types.length);
 
   // TODO make sure to split the maximumTextureMemoryByteLength across all the megatextures
-  for (let i = 0; i < length; i++) {
+  for (let i = 0; i < types.length; i++) {
     const type = types[i];
     const componentCount = MetadataType.getComponentCount(type);
     const componentType = componentTypes[i];
@@ -218,6 +216,18 @@ function VoxelTraversal(
   this.leafNodeTexelSizeUv = new Cartesian2();
 }
 
+/**
+ * Finds a keyframe node in the traversal
+ *
+ * @param {number} megatextureIndex
+ * @returns {KeyframeNode}
+ */
+VoxelTraversal.prototype.findKeyframeNode = function (megatextureIndex) {
+  return this._keyframeNodesInMegatexture.find(function (keyframeNode) {
+    return keyframeNode.megatextureIndex === megatextureIndex;
+  });
+};
+
 function binaryTreeWeightingRecursive(arr, start, end, depth) {
   if (start > end) {
     return;
@@ -382,10 +392,7 @@ VoxelTraversal.prototype.destroy = function () {
  * @private
  */
 function recomputeBoundingVolumesRecursive(that, node) {
-  const primitive = that._primitive;
-  const shape = primitive._shape;
-  const dimensions = primitive._provider.dimensions;
-  node.computeBoundingVolumes(shape, dimensions);
+  node.computeBoundingVolumes(that._primitive._shape);
   if (defined(node.children)) {
     for (let i = 0; i < 8; i++) {
       const child = node.children[i];
@@ -410,12 +417,11 @@ function requestData(that, keyframeNode) {
     return;
   }
 
-  const primitive = that._primitive;
-  const provider = primitive._provider;
+  const provider = that._primitive._provider;
 
   function postRequestSuccess(result) {
     that._simultaneousRequestCount--;
-    const length = primitive._provider.types.length;
+    const length = provider.types.length;
 
     if (!defined(result)) {
       keyframeNode.state = KeyframeNode.LoadState.UNAVAILABLE;
@@ -434,7 +440,7 @@ function requestData(that, keyframeNode) {
         const data = result[i];
         const expectedLength = tileVoxelCount * channelCount;
         if (data.length === expectedLength) {
-          keyframeNode.metadatas[i] = data;
+          keyframeNode.metadata[i] = data;
           // State is received only when all metadata requests have been received
           keyframeNode.state = KeyframeNode.LoadState.RECEIVED;
         } else {
@@ -492,42 +498,22 @@ function loadAndUnload(that, frameState) {
   const frameNumber = that._frameNumber;
   const primitive = that._primitive;
   const shape = primitive._shape;
-  const { dimensions } = primitive;
   const targetScreenSpaceError = primitive.screenSpaceError;
   const priorityQueue = that._priorityQueue;
-  const keyframeLocation = that._keyframeLocation;
   const keyframeCount = that._keyframeCount;
-  const rootNode = that.rootNode;
+
+  const previousKeyframe = CesiumMath.clamp(
+    Math.floor(that._keyframeLocation),
+    0,
+    keyframeCount - 2
+  );
+  const nextKeyframe = previousKeyframe + 1;
 
   const { camera, context, pixelRatio } = frameState;
   const { positionWC, frustum } = camera;
   const screenHeight = context.drawingBufferHeight / pixelRatio;
   const screenSpaceErrorMultiplier = screenHeight / frustum.sseDenominator;
 
-  function keyframePriority(previousKeyframe, keyframe, nextKeyframe) {
-    const keyframeDifference = Math.min(
-      Math.abs(keyframe - previousKeyframe),
-      Math.abs(keyframe - nextKeyframe)
-    );
-    const maxKeyframeDifference = Math.max(
-      previousKeyframe,
-      keyframeCount - nextKeyframe - 1,
-      1
-    );
-    const keyframeFactor = Math.pow(
-      1.0 - keyframeDifference / maxKeyframeDifference,
-      4.0
-    );
-    const binaryTreeFactor = Math.exp(
-      -that._binaryTreeKeyframeWeighting[keyframe]
-    );
-    return CesiumMath.lerp(
-      binaryTreeFactor,
-      keyframeFactor,
-      0.15 + 0.85 * keyframeFactor
-    );
-  }
-
   /**
    * @ignore
    * @param {SpatialNode} spatialNode
@@ -545,13 +531,6 @@ function loadAndUnload(that, frameState) {
     }
     spatialNode.visitedFrameNumber = frameNumber;
 
-    const previousKeyframe = CesiumMath.clamp(
-      Math.floor(keyframeLocation),
-      0,
-      keyframeCount - 2
-    );
-    const nextKeyframe = previousKeyframe + 1;
-
     // Create keyframe nodes at the playhead.
     // If they already exist, nothing will be created.
     if (keyframeCount === 1) {
@@ -561,16 +540,21 @@ function loadAndUnload(that, frameState) {
         spatialNode.createKeyframeNode(k);
       }
     }
-    const ssePriority = mapInfiniteRangeToZeroOne(spatialNode.screenSpaceError);
+    const { screenSpaceError, keyframeNodes } = spatialNode;
+    const ssePriority = mapInfiniteRangeToZeroOne(screenSpaceError);
 
     let hasLoadedKeyframe = false;
-    const keyframeNodes = spatialNode.keyframeNodes;
     for (let i = 0; i < keyframeNodes.length; i++) {
       const keyframeNode = keyframeNodes[i];
 
       keyframeNode.priority =
         10.0 * ssePriority +
-        keyframePriority(previousKeyframe, keyframeNode.keyframe, nextKeyframe);
+        keyframePriority(
+          previousKeyframe,
+          keyframeNode.keyframe,
+          nextKeyframe,
+          that
+        );
 
       if (
         keyframeNode.state !== KeyframeNode.LoadState.UNAVAILABLE &&
@@ -584,16 +568,14 @@ function loadAndUnload(that, frameState) {
       }
     }
 
-    const meetsScreenSpaceError =
-      spatialNode.screenSpaceError < targetScreenSpaceError;
-    if (meetsScreenSpaceError || !hasLoadedKeyframe) {
+    if (screenSpaceError < targetScreenSpaceError || !hasLoadedKeyframe) {
       // Free up memory
       spatialNode.children = undefined;
       return;
     }
 
     if (!defined(spatialNode.children)) {
-      spatialNode.constructChildNodes(shape, dimensions);
+      spatialNode.constructChildNodes(shape);
     }
     for (let childIndex = 0; childIndex < 8; childIndex++) {
       const child = spatialNode.children[childIndex];
@@ -601,9 +583,11 @@ function loadAndUnload(that, frameState) {
     }
   }
 
+  // Add all the nodes to the queue, to sort them by priority.
   priorityQueue.reset();
-  addToQueueRecursive(rootNode, CullingVolume.MASK_INDETERMINATE);
+  addToQueueRecursive(that.rootNode, CullingVolume.MASK_INDETERMINATE);
 
+  // Move the nodes from the queue to array of high priority nodes.
   const highPriorityKeyframeNodes = that._highPriorityKeyframeNodes;
   let highPriorityKeyframeNodeCount = 0;
   let highPriorityKeyframeNode;
@@ -616,6 +600,8 @@ function loadAndUnload(that, frameState) {
     highPriorityKeyframeNodeCount++;
   }
 
+  // Sort the list of keyframe nodes in the megatexture by priority, so
+  // we can remove the lowest priority nodes if we need space.
   const keyframeNodesInMegatexture = that._keyframeNodesInMegatexture;
   // TODO: some of the megatexture state should be stored once, not duplicate for each megatexture
   const megatexture = that.megatextures[0];
@@ -628,6 +614,8 @@ function loadAndUnload(that, frameState) {
     return b.highPriorityFrameNumber - a.highPriorityFrameNumber;
   });
 
+  // Add the high priority nodes to the megatexture,
+  // removing existing lower-priority nodes if necessary.
   let destroyedCount = 0;
   let addedCount = 0;
 
@@ -675,6 +663,40 @@ function loadAndUnload(that, frameState) {
   }
 }
 
+/**
+ * Compute a priority for a keyframe node.
+ *
+ * @private
+ * @param {number} previousKeyframe
+ * @param {number} keyframe
+ * @param {number} nextKeyframe
+ * @param {VoxelTraversal} traversal
+ * @returns {number} The computed priority
+ */
+function keyframePriority(previousKeyframe, keyframe, nextKeyframe, traversal) {
+  const keyframeDifference = Math.min(
+    Math.abs(keyframe - previousKeyframe),
+    Math.abs(keyframe - nextKeyframe)
+  );
+  const maxKeyframeDifference = Math.max(
+    previousKeyframe,
+    traversal._keyframeCount - nextKeyframe - 1,
+    1
+  );
+  const keyframeFactor = Math.pow(
+    1.0 - keyframeDifference / maxKeyframeDifference,
+    4.0
+  );
+  const binaryTreeFactor = Math.exp(
+    -traversal._binaryTreeKeyframeWeighting[keyframe]
+  );
+  return CesiumMath.lerp(
+    binaryTreeFactor,
+    keyframeFactor,
+    0.15 + 0.85 * keyframeFactor
+  );
+}
+
 /**
  * @function
  *

package/Source/Scene/buildVoxelDrawCommands.js

@@ -58,8 +58,17 @@ function buildVoxelDrawCommands(primitive, context) {
   // Compile shaders
   const shaderBuilderPick = shaderBuilder.clone();
   shaderBuilderPick.addDefine("PICKING", undefined, ShaderDestination.FRAGMENT);
+  const shaderBuilderPickVoxel = shaderBuilder.clone();
+  shaderBuilderPickVoxel.addDefine(
+    "PICKING_VOXEL",
+    undefined,
+    ShaderDestination.FRAGMENT
+  );
   const shaderProgram = shaderBuilder.buildShaderProgram(context);
   const shaderProgramPick = shaderBuilderPick.buildShaderProgram(context);
+  const shaderProgramPickVoxel = shaderBuilderPickVoxel.buildShaderProgram(
+    context
+  );
   const renderState = RenderState.fromCache({
     cull: {
       enabled: true,
@@ -98,6 +107,14 @@ function buildVoxelDrawCommands(primitive, context) {
   drawCommandPick.shaderProgram = shaderProgramPick;
   drawCommandPick.pickOnly = true;
 
+  // Create the pick voxels draw command
+  const drawCommandPickVoxel = DrawCommand.shallowClone(
+    drawCommand,
+    new DrawCommand()
+  );
+  drawCommandPickVoxel.shaderProgram = shaderProgramPickVoxel;
+  drawCommandPickVoxel.pickOnly = true;
+
   // Delete the old shader programs
   if (defined(primitive._drawCommand)) {
     const command = primitive._drawCommand;
@@ -109,9 +126,15 @@ function buildVoxelDrawCommands(primitive, context) {
     command.shaderProgram =
       command.shaderProgram && command.shaderProgram.destroy();
   }
+  if (defined(primitive._drawCommandPickVoxel)) {
+    const command = primitive._drawCommandPickVoxel;
+    command.shaderProgram =
+      command.shaderProgram && command.shaderProgram.destroy();
+  }
 
   primitive._drawCommand = drawCommand;
   primitive._drawCommandPick = drawCommandPick;
+  primitive._drawCommandPickVoxel = drawCommandPickVoxel;
 }
 
 export default buildVoxelDrawCommands;

package/Source/Scene/createGooglePhotorealistic3DTileset.js

@@ -46,6 +46,7 @@ async function createGooglePhotorealistic3DTileset(key, options) {
     options.maximumCacheOverflowBytes,
     1024 * 1024 * 1024
   );
+  options.enableCollision = defaultValue(options.enableCollision, true);
 
   key = defaultValue(key, GoogleMaps.defaultApiKey);
   if (!defined(key)) {

package/Source/Scene/processVoxelProperties.js

@@ -153,6 +153,8 @@ function processVoxelProperties(renderResources, primitive) {
   shaderBuilder.addStructField(voxelStructId, "vec3", "viewDirWorld");
   shaderBuilder.addStructField(voxelStructId, "vec3", "surfaceNormal");
   shaderBuilder.addStructField(voxelStructId, "float", "travelDistance");
+  shaderBuilder.addStructField(voxelStructId, "int", "tileIndex");
+  shaderBuilder.addStructField(voxelStructId, "int", "sampleIndex");
 
   // FragmentInput struct
   const fragmentInputStructId = "FragmentInput";

package/Source/Shaders/Voxels/IntersectCylinder.glsl

@@ -1,5 +1,7 @@
-// See IntersectionUtils.glsl for the definitions of Ray, setIntersection,
-// setIntersectionPair
+// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT,
+// setIntersection, setIntersectionPair, setShapeIntersection
+// See IntersectLongitude.glsl for the definitions of intersectHalfPlane,
+// intersectFlippedWedge, intersectRegularWedge
 
 /* Cylinder defines (set in Scene/VoxelCylinderShape.js)
 #define CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MIN
@@ -10,19 +12,8 @@
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_UNDER_HALF
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_OVER_HALF
-#define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_HALF
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_ZERO
 
-#define CYLINDER_HAS_SHAPE_BOUNDS_RADIUS
-#define CYLINDER_HAS_SHAPE_BOUNDS_RADIUS_FLAT
-#define CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT
-#define CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT_FLAT
-#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE
-#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_RANGE_EQUAL_ZERO
-#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY
-#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY
-#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED
-
 #define CYLINDER_INTERSECTION_INDEX_RADIUS_MAX
 #define CYLINDER_INTERSECTION_INDEX_RADIUS_MIN
 #define CYLINDER_INTERSECTION_INDEX_ANGLE
@@ -40,93 +31,6 @@
     uniform vec2 u_cylinderRenderAngleMinMax;
 #endif
 
-vec4 intersectHalfPlane(Ray ray, float angle) {
-    vec2 o = ray.pos.xy;
-    vec2 d = ray.dir.xy;
-    vec2 planeDirection = vec2(cos(angle), sin(angle));
-    vec2 planeNormal = vec2(planeDirection.y, -planeDirection.x);
-
-    float a = dot(o, planeNormal);
-    float b = dot(d, planeNormal);
-    float t = -a / b;
-
-    vec2 p = o + t * d;
-    bool outside = dot(p, planeDirection) < 0.0;
-    if (outside) return vec4(-INF_HIT, +INF_HIT, NO_HIT, NO_HIT);
-
-    return vec4(-INF_HIT, t, t, +INF_HIT);
-}
-
-#define POSITIVE_HIT vec2(t, +INF_HIT);
-#define NEGATIVE_HIT vec2(-INF_HIT, t);
-
-vec2 intersectHalfSpace(Ray ray, float angle)
-{
-    vec2 o = ray.pos.xy;
-    vec2 d = ray.dir.xy;
-    vec2 n = vec2(sin(angle), -cos(angle));
-
-    float a = dot(o, n);
-    float b = dot(d, n);
-    float t = -a / b;
-    float s = sign(a);
-
-    // Half space cuts right through the camera, pick the side to intersect
-    if (a == 0.0) {
-        if (b >= 0.0) {
-            return POSITIVE_HIT;
-        } else {
-            return NEGATIVE_HIT;
-        }
-    }
-
-    if (t >= 0.0 != s >= 0.0) {
-        return POSITIVE_HIT;
-    } else {
-        return NEGATIVE_HIT;
-    }
-}
-
-vec2 intersectRegularWedge(Ray ray, float minAngle, float maxAngle)
-{
-    vec2 o = ray.pos.xy;
-    vec2 d = ray.dir.xy;
-    vec2 n1 = vec2(sin(minAngle), -cos(minAngle));
-    vec2 n2 = vec2(-sin(maxAngle), cos(maxAngle));
-
-    float a1 = dot(o, n1);
-    float a2 = dot(o, n2);
-    float b1 = dot(d, n1);
-    float b2 = dot(d, n2);
-
-    float t1 = -a1 / b1;
-    float t2 = -a2 / b2;
-    float s1 = sign(a1);
-    float s2 = sign(a2);
-
-    float tmin = min(t1, t2);
-    float tmax = max(t1, t2);
-    float smin = tmin == t1 ? s1 : s2;
-    float smax = tmin == t1 ? s2 : s1;
-
-    bool e = tmin >= 0.0;
-    bool f = tmax >= 0.0;
-    bool g = smin >= 0.0;
-    bool h = smax >= 0.0;
-
-    if (e != g && f == h) return vec2(tmin, tmax);
-    else if (e == g && f == h) return vec2(-INF_HIT, tmin);
-    else if (e != g && f != h) return vec2(tmax, +INF_HIT);
-    else return vec2(NO_HIT);
-}
-
-vec4 intersectFlippedWedge(Ray ray, float minAngle, float maxAngle)
-{
-    vec2 planeIntersectMin = intersectHalfSpace(ray, minAngle);
-    vec2 planeIntersectMax = intersectHalfSpace(ray, maxAngle + czm_pi);
-    return vec4(planeIntersectMin, planeIntersectMax);
-}
-
 vec2 intersectUnitCylinder(Ray ray)
 {
     vec3 o = ray.pos;
@@ -256,18 +160,17 @@ void intersectShape(Ray ray, inout Intersections ix)
     #endif
 
     #if defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_UNDER_HALF)
-        vec2 wedgeIntersect = intersectRegularWedge(ray, u_cylinderRenderAngleMinMax.x, u_cylinderRenderAngleMinMax.y);
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_ANGLE, wedgeIntersect);
+        RayShapeIntersection wedgeIntersect = intersectRegularWedge(ray, u_cylinderRenderAngleMinMax);
+        setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_ANGLE, wedgeIntersect);
     #elif defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_OVER_HALF)
-        vec4 wedgeIntersect = intersectFlippedWedge(ray, u_cylinderRenderAngleMinMax.x, u_cylinderRenderAngleMinMax.y);
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 0, wedgeIntersect.xy);
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 1, wedgeIntersect.zw);
-    #elif defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_HALF)
-        vec2 wedgeIntersect = intersectHalfSpace(ray, u_cylinderRenderAngleMinMax.x);
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_ANGLE, wedgeIntersect);
+        RayShapeIntersection wedgeIntersects[2];
+        intersectFlippedWedge(ray, u_cylinderRenderAngleMinMax, wedgeIntersects);
+        setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 0, wedgeIntersects[0]);
+        setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 1, wedgeIntersects[1]);
     #elif defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_ZERO)
-        vec4 wedgeIntersect = intersectHalfPlane(ray, u_cylinderRenderAngleMinMax.x);
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 0, wedgeIntersect.xy);
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 1, wedgeIntersect.zw);
+        RayShapeIntersection wedgeIntersects[2];
+        intersectHalfPlane(ray, u_cylinderRenderAngleMinMax.x, wedgeIntersects);
+        setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 0, wedgeIntersects[0]);
+        setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 1, wedgeIntersects[1]);
     #endif
 }

package/Source/Shaders/Voxels/IntersectCylinder.js

@@ -1,6 +1,8 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "// See IntersectionUtils.glsl for the definitions of Ray, setIntersection,\n\
-// setIntersectionPair\n\
+export default "// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT,\n\
+// setIntersection, setIntersectionPair, setShapeIntersection\n\
+// See IntersectLongitude.glsl for the definitions of intersectHalfPlane,\n\
+// intersectFlippedWedge, intersectRegularWedge\n\
 \n\
 /* Cylinder defines (set in Scene/VoxelCylinderShape.js)\n\
 #define CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MIN\n\
@@ -11,19 +13,8 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, setInt
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE\n\
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_UNDER_HALF\n\
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_OVER_HALF\n\
-#define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_HALF\n\
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_ZERO\n\
 \n\
-#define CYLINDER_HAS_SHAPE_BOUNDS_RADIUS\n\
-#define CYLINDER_HAS_SHAPE_BOUNDS_RADIUS_FLAT\n\
-#define CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT\n\
-#define CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT_FLAT\n\
-#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE\n\
-#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_RANGE_EQUAL_ZERO\n\
-#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY\n\
-#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY\n\
-#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED\n\
-\n\
 #define CYLINDER_INTERSECTION_INDEX_RADIUS_MAX\n\
 #define CYLINDER_INTERSECTION_INDEX_RADIUS_MIN\n\
 #define CYLINDER_INTERSECTION_INDEX_ANGLE\n\
@@ -41,93 +32,6 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, setInt
     uniform vec2 u_cylinderRenderAngleMinMax;\n\
 #endif\n\
 \n\
-vec4 intersectHalfPlane(Ray ray, float angle) {\n\
-    vec2 o = ray.pos.xy;\n\
-    vec2 d = ray.dir.xy;\n\
-    vec2 planeDirection = vec2(cos(angle), sin(angle));\n\
-    vec2 planeNormal = vec2(planeDirection.y, -planeDirection.x);\n\
-\n\
-    float a = dot(o, planeNormal);\n\
-    float b = dot(d, planeNormal);\n\
-    float t = -a / b;\n\
-\n\
-    vec2 p = o + t * d;\n\
-    bool outside = dot(p, planeDirection) < 0.0;\n\
-    if (outside) return vec4(-INF_HIT, +INF_HIT, NO_HIT, NO_HIT);\n\
-\n\
-    return vec4(-INF_HIT, t, t, +INF_HIT);\n\
-}\n\
-\n\
-#define POSITIVE_HIT vec2(t, +INF_HIT);\n\
-#define NEGATIVE_HIT vec2(-INF_HIT, t);\n\
-\n\
-vec2 intersectHalfSpace(Ray ray, float angle)\n\
-{\n\
-    vec2 o = ray.pos.xy;\n\
-    vec2 d = ray.dir.xy;\n\
-    vec2 n = vec2(sin(angle), -cos(angle));\n\
-\n\
-    float a = dot(o, n);\n\
-    float b = dot(d, n);\n\
-    float t = -a / b;\n\
-    float s = sign(a);\n\
-\n\
-    // Half space cuts right through the camera, pick the side to intersect\n\
-    if (a == 0.0) {\n\
-        if (b >= 0.0) {\n\
-            return POSITIVE_HIT;\n\
-        } else {\n\
-            return NEGATIVE_HIT;\n\
-        }\n\
-    }\n\
-\n\
-    if (t >= 0.0 != s >= 0.0) {\n\
-        return POSITIVE_HIT;\n\
-    } else {\n\
-        return NEGATIVE_HIT;\n\
-    }\n\
-}\n\
-\n\
-vec2 intersectRegularWedge(Ray ray, float minAngle, float maxAngle)\n\
-{\n\
-    vec2 o = ray.pos.xy;\n\
-    vec2 d = ray.dir.xy;\n\
-    vec2 n1 = vec2(sin(minAngle), -cos(minAngle));\n\
-    vec2 n2 = vec2(-sin(maxAngle), cos(maxAngle));\n\
-\n\
-    float a1 = dot(o, n1);\n\
-    float a2 = dot(o, n2);\n\
-    float b1 = dot(d, n1);\n\
-    float b2 = dot(d, n2);\n\
-\n\
-    float t1 = -a1 / b1;\n\
-    float t2 = -a2 / b2;\n\
-    float s1 = sign(a1);\n\
-    float s2 = sign(a2);\n\
-\n\
-    float tmin = min(t1, t2);\n\
-    float tmax = max(t1, t2);\n\
-    float smin = tmin == t1 ? s1 : s2;\n\
-    float smax = tmin == t1 ? s2 : s1;\n\
-\n\
-    bool e = tmin >= 0.0;\n\
-    bool f = tmax >= 0.0;\n\
-    bool g = smin >= 0.0;\n\
-    bool h = smax >= 0.0;\n\
-\n\
-    if (e != g && f == h) return vec2(tmin, tmax);\n\
-    else if (e == g && f == h) return vec2(-INF_HIT, tmin);\n\
-    else if (e != g && f != h) return vec2(tmax, +INF_HIT);\n\
-    else return vec2(NO_HIT);\n\
-}\n\
-\n\
-vec4 intersectFlippedWedge(Ray ray, float minAngle, float maxAngle)\n\
-{\n\
-    vec2 planeIntersectMin = intersectHalfSpace(ray, minAngle);\n\
-    vec2 planeIntersectMax = intersectHalfSpace(ray, maxAngle + czm_pi);\n\
-    return vec4(planeIntersectMin, planeIntersectMax);\n\
-}\n\
-\n\
 vec2 intersectUnitCylinder(Ray ray)\n\
 {\n\
     vec3 o = ray.pos;\n\
@@ -257,19 +161,18 @@ void intersectShape(Ray ray, inout Intersections ix)\n\
     #endif\n\
 \n\
     #if defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_UNDER_HALF)\n\
-        vec2 wedgeIntersect = intersectRegularWedge(ray, u_cylinderRenderAngleMinMax.x, u_cylinderRenderAngleMinMax.y);\n\
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_ANGLE, wedgeIntersect);\n\
+        RayShapeIntersection wedgeIntersect = intersectRegularWedge(ray, u_cylinderRenderAngleMinMax);\n\
+        setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_ANGLE, wedgeIntersect);\n\
     #elif defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_OVER_HALF)\n\
-        vec4 wedgeIntersect = intersectFlippedWedge(ray, u_cylinderRenderAngleMinMax.x, u_cylinderRenderAngleMinMax.y);\n\
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 0, wedgeIntersect.xy);\n\
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 1, wedgeIntersect.zw);\n\
-    #elif defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_HALF)\n\
-        vec2 wedgeIntersect = intersectHalfSpace(ray, u_cylinderRenderAngleMinMax.x);\n\
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_ANGLE, wedgeIntersect);\n\
+        RayShapeIntersection wedgeIntersects[2];\n\
+        intersectFlippedWedge(ray, u_cylinderRenderAngleMinMax, wedgeIntersects);\n\
+        setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 0, wedgeIntersects[0]);\n\
+        setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 1, wedgeIntersects[1]);\n\
     #elif defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_ZERO)\n\
-        vec4 wedgeIntersect = intersectHalfPlane(ray, u_cylinderRenderAngleMinMax.x);\n\
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 0, wedgeIntersect.xy);\n\
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 1, wedgeIntersect.zw);\n\
+        RayShapeIntersection wedgeIntersects[2];\n\
+        intersectHalfPlane(ray, u_cylinderRenderAngleMinMax.x, wedgeIntersects);\n\
+        setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 0, wedgeIntersects[0]);\n\
+        setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_ANGLE + 1, wedgeIntersects[1]);\n\
     #endif\n\
 }\n\
 ";