@cesium/engine 7.0.0 → 9.0.0

package/Source/Shaders/Voxels/IntersectBox.glsl

@@ -1,5 +1,5 @@
-// See IntersectionUtils.glsl for the definitions of Ray and NO_HIT
-// See convertUvToBox.glsl for the definition of convertShapeUvToUvSpace
+// See IntersectionUtils.glsl for the definitions of Ray, RayShapeIntersection,
+// NO_HIT, Intersections
 
 /* Box defines (set in Scene/VoxelBoxShape.js)
 #define BOX_INTERSECTION_INDEX ### // always 0
@@ -8,66 +8,40 @@
 uniform vec3 u_renderMinBounds;
 uniform vec3 u_renderMaxBounds;
 
-struct Box {
-    vec3 p0;
-    vec3 p1;
-};
-
-Box constructVoxelBox(in ivec4 octreeCoords, in vec3 tileUv)
-{
-    // Find the min/max cornerpoints of the voxel in tile coordinates
-    vec3 tileOrigin = vec3(octreeCoords.xyz);
-    vec3 numSamples = vec3(u_dimensions);
-    vec3 voxelSize = 1.0 / numSamples;
-    vec3 coordP0 = floor(tileUv * numSamples) * voxelSize + tileOrigin;
-    vec3 coordP1 = coordP0 + voxelSize;
-
-    // Transform to the UV coordinates of the scaled tileset
-    float tileSize = 1.0 / pow(2.0, float(octreeCoords.w));
-    vec3 p0 = convertShapeUvToUvSpace(coordP0 * tileSize);
-    vec3 p1 = convertShapeUvToUvSpace(coordP1 * tileSize);
-
-    return Box(p0, p1);
-}
-
-vec3 getBoxNormal(in Box box, in Ray ray, in float t)
-{
-    vec3 hitPoint = ray.pos + t * ray.dir;
-    vec3 lower = step(hitPoint, box.p0);
-    vec3 upper = step(box.p1, hitPoint);
-    return normalize(upper - lower);
-}
-
-// Find the distances along a ray at which the ray intersects an axis-aligned box
-// See https://tavianator.com/2011/ray_box.html
-RayShapeIntersection intersectBox(in Ray ray, in Box box)
+RayShapeIntersection intersectBox(in Ray ray, in vec3 minBound, in vec3 maxBound)
 {
     // Consider the box as the intersection of the space between 3 pairs of parallel planes
     // Compute the distance along the ray to each plane
-    vec3 t0 = (box.p0 - ray.pos) * ray.dInv;
-    vec3 t1 = (box.p1 - ray.pos) * ray.dInv;
+    vec3 t0 = (minBound - ray.pos) / ray.dir;
+    vec3 t1 = (maxBound - ray.pos) / ray.dir;
 
     // Identify candidate entries/exits based on distance from ray.pos
     vec3 entries = min(t0, t1);
     vec3 exits = max(t0, t1);
 
-    // The actual box intersection points are the furthest entry and the closest exit
-    float entryT = max(max(entries.x, entries.y), entries.z);
-    float exitT = min(min(exits.x, exits.y), exits.z);
+    vec3 directions = sign(ray.dir);
+
+    // The actual intersection points are the furthest entry and the closest exit
+    float lastEntry = maxComponent(entries);
+    bvec3 isLastEntry = equal(entries, vec3(lastEntry));
+    vec3 entryNormal = -1.0 * vec3(isLastEntry) * directions;
+    vec4 entry = vec4(entryNormal, lastEntry);
 
-    vec3 entryNormal = getBoxNormal(box, ray, entryT - RAY_SHIFT);
-    vec3 exitNormal = getBoxNormal(box, ray, exitT + RAY_SHIFT);
+    float firstExit = minComponent(exits);
+    bvec3 isFirstExit = equal(exits, vec3(firstExit));
+    vec3 exitNormal = vec3(isLastEntry) * directions;
+    vec4 exit = vec4(exitNormal, firstExit);
 
-    if (entryT > exitT) {
-        entryT = NO_HIT;
-        exitT = NO_HIT;
+    if (entry.w > exit.w) {
+        entry.w = NO_HIT;
+        exit.w = NO_HIT;
     }
 
-    return RayShapeIntersection(vec4(entryNormal, entryT), vec4(exitNormal, exitT));
+    return RayShapeIntersection(entry, exit);
 }
 
 void intersectShape(in Ray ray, inout Intersections ix)
 {
-    RayShapeIntersection intersection = intersectBox(ray, Box(u_renderMinBounds, u_renderMaxBounds));
+    RayShapeIntersection intersection = intersectBox(ray, u_renderMinBounds, u_renderMaxBounds);
     setShapeIntersection(ix, BOX_INTERSECTION_INDEX, intersection);
 }

package/Source/Shaders/Voxels/IntersectBox.js

@@ -1,6 +1,6 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "// See IntersectionUtils.glsl for the definitions of Ray and NO_HIT\n\
-// See convertUvToBox.glsl for the definition of convertShapeUvToUvSpace\n\
+export default "// See IntersectionUtils.glsl for the definitions of Ray, RayShapeIntersection,\n\
+// NO_HIT, Intersections\n\
 \n\
 /* Box defines (set in Scene/VoxelBoxShape.js)\n\
 #define BOX_INTERSECTION_INDEX ### // always 0\n\
@@ -9,67 +9,41 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray and NO_
 uniform vec3 u_renderMinBounds;\n\
 uniform vec3 u_renderMaxBounds;\n\
 \n\
-struct Box {\n\
-    vec3 p0;\n\
-    vec3 p1;\n\
-};\n\
-\n\
-Box constructVoxelBox(in ivec4 octreeCoords, in vec3 tileUv)\n\
-{\n\
-    // Find the min/max cornerpoints of the voxel in tile coordinates\n\
-    vec3 tileOrigin = vec3(octreeCoords.xyz);\n\
-    vec3 numSamples = vec3(u_dimensions);\n\
-    vec3 voxelSize = 1.0 / numSamples;\n\
-    vec3 coordP0 = floor(tileUv * numSamples) * voxelSize + tileOrigin;\n\
-    vec3 coordP1 = coordP0 + voxelSize;\n\
-\n\
-    // Transform to the UV coordinates of the scaled tileset\n\
-    float tileSize = 1.0 / pow(2.0, float(octreeCoords.w));\n\
-    vec3 p0 = convertShapeUvToUvSpace(coordP0 * tileSize);\n\
-    vec3 p1 = convertShapeUvToUvSpace(coordP1 * tileSize);\n\
-\n\
-    return Box(p0, p1);\n\
-}\n\
-\n\
-vec3 getBoxNormal(in Box box, in Ray ray, in float t)\n\
-{\n\
-    vec3 hitPoint = ray.pos + t * ray.dir;\n\
-    vec3 lower = step(hitPoint, box.p0);\n\
-    vec3 upper = step(box.p1, hitPoint);\n\
-    return normalize(upper - lower);\n\
-}\n\
-\n\
-// Find the distances along a ray at which the ray intersects an axis-aligned box\n\
-// See https://tavianator.com/2011/ray_box.html\n\
-RayShapeIntersection intersectBox(in Ray ray, in Box box)\n\
+RayShapeIntersection intersectBox(in Ray ray, in vec3 minBound, in vec3 maxBound)\n\
 {\n\
     // Consider the box as the intersection of the space between 3 pairs of parallel planes\n\
     // Compute the distance along the ray to each plane\n\
-    vec3 t0 = (box.p0 - ray.pos) * ray.dInv;\n\
-    vec3 t1 = (box.p1 - ray.pos) * ray.dInv;\n\
+    vec3 t0 = (minBound - ray.pos) / ray.dir;\n\
+    vec3 t1 = (maxBound - ray.pos) / ray.dir;\n\
 \n\
     // Identify candidate entries/exits based on distance from ray.pos\n\
     vec3 entries = min(t0, t1);\n\
     vec3 exits = max(t0, t1);\n\
 \n\
-    // The actual box intersection points are the furthest entry and the closest exit\n\
-    float entryT = max(max(entries.x, entries.y), entries.z);\n\
-    float exitT = min(min(exits.x, exits.y), exits.z);\n\
+    vec3 directions = sign(ray.dir);\n\
+\n\
+    // The actual intersection points are the furthest entry and the closest exit\n\
+    float lastEntry = maxComponent(entries);\n\
+    bvec3 isLastEntry = equal(entries, vec3(lastEntry));\n\
+    vec3 entryNormal = -1.0 * vec3(isLastEntry) * directions;\n\
+    vec4 entry = vec4(entryNormal, lastEntry);\n\
 \n\
-    vec3 entryNormal = getBoxNormal(box, ray, entryT - RAY_SHIFT);\n\
-    vec3 exitNormal = getBoxNormal(box, ray, exitT + RAY_SHIFT);\n\
+    float firstExit = minComponent(exits);\n\
+    bvec3 isFirstExit = equal(exits, vec3(firstExit));\n\
+    vec3 exitNormal = vec3(isLastEntry) * directions;\n\
+    vec4 exit = vec4(exitNormal, firstExit);\n\
 \n\
-    if (entryT > exitT) {\n\
-        entryT = NO_HIT;\n\
-        exitT = NO_HIT;\n\
+    if (entry.w > exit.w) {\n\
+        entry.w = NO_HIT;\n\
+        exit.w = NO_HIT;\n\
     }\n\
 \n\
-    return RayShapeIntersection(vec4(entryNormal, entryT), vec4(exitNormal, exitT));\n\
+    return RayShapeIntersection(entry, exit);\n\
 }\n\
 \n\
 void intersectShape(in Ray ray, inout Intersections ix)\n\
 {\n\
-    RayShapeIntersection intersection = intersectBox(ray, Box(u_renderMinBounds, u_renderMaxBounds));\n\
+    RayShapeIntersection intersection = intersectBox(ray, u_renderMinBounds, u_renderMaxBounds);\n\
     setShapeIntersection(ix, BOX_INTERSECTION_INDEX, intersection);\n\
 }\n\
 ";

package/Source/Shaders/Voxels/IntersectClippingPlanes.glsl

@@ -1,5 +1,5 @@
 // See IntersectionUtils.glsl for the definitions of Ray, Intersections, INF_HIT,
-// NO_HIT, setIntersectionPair
+// NO_HIT, setShapeIntersection
 
 /* Clipping plane defines (set in Scene/VoxelRenderResources.js)
 #define CLIPPING_PLANES_UNION

package/Source/Shaders/Voxels/IntersectClippingPlanes.js

@@ -1,6 +1,6 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "// See IntersectionUtils.glsl for the definitions of Ray, Intersections, INF_HIT,\n\
-// NO_HIT, setIntersectionPair\n\
+// NO_HIT, setShapeIntersection\n\
 \n\
 /* Clipping plane defines (set in Scene/VoxelRenderResources.js)\n\
 #define CLIPPING_PLANES_UNION\n\

package/Source/Shaders/Voxels/IntersectCylinder.glsl

@@ -1,229 +1,104 @@
-// See IntersectionUtils.glsl for the definitions of Ray, setIntersection,
-// setIntersectionPair
+// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT, Intersections,
+// RayShapeIntersection, setSurfaceIntersection, setShapeIntersection,
+// intersectIntersections
+// See IntersectLongitude.glsl for the definitions of intersectHalfPlane,
+// intersectFlippedWedge, intersectRegularWedge
 
 /* Cylinder defines (set in Scene/VoxelCylinderShape.js)
 #define CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MIN
-#define CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MAX
 #define CYLINDER_HAS_RENDER_BOUNDS_RADIUS_FLAT
-#define CYLINDER_HAS_RENDER_BOUNDS_HEIGHT
-#define CYLINDER_HAS_RENDER_BOUNDS_HEIGHT_FLAT
 #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
 */
 
 // Cylinder uniforms
-#if defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MAX) || defined(CYLINDER_HAS_RENDER_BOUNDS_HEIGHT)
-    uniform vec3 u_cylinderUvToRenderBoundsScale;
-    uniform vec3 u_cylinderUvToRenderBoundsTranslate;
-#endif
-#if defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MIN) && !defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_FLAT)
-    uniform float u_cylinderUvToRenderRadiusMin;
-#endif
+uniform vec2 u_cylinderRenderRadiusMinMax;
+uniform vec2 u_cylinderRenderHeightMinMax;
 #if defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE)
     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)
+/**
+ * Find the intersection of a ray with the volume defined by two planes of constant z
+ */
+RayShapeIntersection intersectHeightBounds(in Ray ray, in vec2 minMaxHeight, in bool convex)
 {
-    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 zPosition = ray.pos.z;
+    float zDirection = ray.dir.z;
 
-    float t1 = -a1 / b1;
-    float t2 = -a2 / b2;
-    float s1 = sign(a1);
-    float s2 = sign(a2);
+    float tmin = (minMaxHeight.x - zPosition) / zDirection;
+    float tmax = (minMaxHeight.y - zPosition) / zDirection;
 
-    float tmin = min(t1, t2);
-    float tmax = max(t1, t2);
-    float smin = tmin == t1 ? s1 : s2;
-    float smax = tmin == t1 ? s2 : s1;
+    // Normals point outside the volume
+    float signFlip = convex ? 1.0 : -1.0;
+    vec4 intersectMin = vec4(0.0, 0.0, -1.0 * signFlip, tmin);
+    vec4 intersectMax = vec4(0.0, 0.0, 1.0 * signFlip, tmax);
 
-    bool e = tmin >= 0.0;
-    bool f = tmax >= 0.0;
-    bool g = smin >= 0.0;
-    bool h = smax >= 0.0;
+    bool topEntry = zDirection < 0.0;
+    vec4 entry = topEntry ? intersectMax : intersectMin;
+    vec4 exit = topEntry ? intersectMin : intersectMax;
 
-    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);
+    return RayShapeIntersection(entry, exit);
 }
 
-vec4 intersectFlippedWedge(Ray ray, float minAngle, float maxAngle)
+/**
+ * Find the intersection of a ray with a right cylindrical surface of a given radius
+ * about the z-axis.
+ */
+RayShapeIntersection intersectCylinder(in Ray ray, in float radius, in bool convex)
 {
-    vec2 planeIntersectMin = intersectHalfSpace(ray, minAngle);
-    vec2 planeIntersectMax = intersectHalfSpace(ray, maxAngle + czm_pi);
-    return vec4(planeIntersectMin, planeIntersectMax);
-}
+    vec2 position = ray.pos.xy;
+    vec2 direction = ray.dir.xy;
 
-vec2 intersectUnitCylinder(Ray ray)
-{
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
+    float a = dot(direction, direction);
+    float b = dot(position, direction);
+    float c = dot(position, position) - radius * radius;
+    float determinant = b * b - a * c;
 
-    float a = dot(d.xy, d.xy);
-    float b = dot(o.xy, d.xy);
-    float c = dot(o.xy, o.xy) - 1.0;
-    float det = b * b - a * c;
-
-    if (det < 0.0) {
-        return vec2(NO_HIT);
-    }
-
-    det = sqrt(det);
-    float ta = (-b - det) / a;
-    float tb = (-b + det) / a;
-    float t1 = min(ta, tb);
-    float t2 = max(ta, tb);
-
-    float z1 = o.z + t1 * d.z;
-    float z2 = o.z + t2 * d.z;
-
-    if (abs(z1) >= 1.0)
-    {
-        float tCap = (sign(z1) - o.z) / d.z;
-        t1 = abs(b + a * tCap) < det ? tCap : NO_HIT;
+    if (determinant < 0.0) {
+        vec4 miss = vec4(normalize(ray.dir), NO_HIT);
+        return RayShapeIntersection(miss, miss);
     }
 
-    if (abs(z2) >= 1.0)
-    {
-        float tCap = (sign(z2) - o.z) / d.z;
-        t2 = abs(b + a * tCap) < det ? tCap : NO_HIT;
-    }
+    determinant = sqrt(determinant);
+    float t1 = (-b - determinant) / a;
+    float t2 = (-b + determinant) / a;
+    float signFlip = convex ? 1.0 : -1.0;
+    vec4 intersect1 = vec4(normalize(position + t1 * direction) * signFlip, 0.0, t1);
+    vec4 intersect2 = vec4(normalize(position + t2 * direction) * signFlip, 0.0, t2);
 
-    return vec2(t1, t2);
+    return RayShapeIntersection(intersect1, intersect2);
 }
 
-vec2 intersectUnitCircle(Ray ray) {
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
-
-    float t = -o.z / d.z;
-    vec2 zPlanePos = o.xy + d.xy * t;
-    float distSqr = dot(zPlanePos, zPlanePos);
-
-    if (distSqr > 1.0) {
-        return vec2(NO_HIT);
-    }
-
-    return vec2(t, t);
-}
-
-vec2 intersectInfiniteUnitCylinder(Ray ray)
+/**
+ * Find the intersection of a ray with a right cylindrical solid of given
+ * radius and height bounds. NOTE: The shape is assumed to be convex.
+ */
+RayShapeIntersection intersectBoundedCylinder(in Ray ray, in float radius, in vec2 minMaxHeight)
 {
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
-
-    float a = dot(d.xy, d.xy);
-    float b = dot(o.xy, d.xy);
-    float c = dot(o.xy, o.xy) - 1.0;
-    float det = b * b - a * c;
-
-    if (det < 0.0) {
-        return vec2(NO_HIT);
-    }
-
-    det = sqrt(det);
-    float t1 = (-b - det) / a;
-    float t2 = (-b + det) / a;
-    float tmin = min(t1, t2);
-    float tmax = max(t1, t2);
-
-    return vec2(tmin, tmax);
+    RayShapeIntersection cylinderIntersection = intersectCylinder(ray, radius, true);
+    RayShapeIntersection heightBoundsIntersection = intersectHeightBounds(ray, minMaxHeight, true);
+    return intersectIntersections(ray, cylinderIntersection, heightBoundsIntersection);
 }
 
 void intersectShape(Ray ray, inout Intersections ix)
 {
-    #if defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MAX) || defined(CYLINDER_HAS_RENDER_BOUNDS_HEIGHT)
-        ray.pos = ray.pos * u_cylinderUvToRenderBoundsScale + u_cylinderUvToRenderBoundsTranslate;
-        ray.dir *= u_cylinderUvToRenderBoundsScale;
-    #else
-        // Position is converted from [0,1] to [-1,+1] because shape intersections assume unit space is [-1,+1].
-        // Direction is scaled as well to be in sync with position.
-        ray.pos = ray.pos * 2.0 - 1.0;
-        ray.dir *= 2.0;
-    #endif
+    // Position is converted from [0,1] to [-1,+1] because shape intersections assume unit space is [-1,+1].
+    // Direction is scaled as well to be in sync with position.
+    ray.pos = ray.pos * 2.0 - 1.0;
+    ray.dir *= 2.0;
 
-    #if defined(CYLINDER_HAS_RENDER_BOUNDS_HEIGHT_FLAT)
-        vec2 outerIntersect = intersectUnitCircle(ray);
-    #else
-        vec2 outerIntersect = intersectUnitCylinder(ray);
-    #endif
+    RayShapeIntersection outerIntersect = intersectBoundedCylinder(ray, u_cylinderRenderRadiusMinMax.y, u_cylinderRenderHeightMinMax);
 
-    setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MAX, outerIntersect);
+    setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MAX, outerIntersect);
 
-    if (outerIntersect.x == NO_HIT) {
+    if (outerIntersect.entry.w == NO_HIT) {
         return;
     }
 
@@ -244,30 +119,28 @@ void intersectShape(Ray ray, inout Intersections ix)
 
         // Note: If initializeIntersections() changes its sorting function
         // from bubble sort to something else, this code may need to change.
-        vec2 innerIntersect = intersectInfiniteUnitCylinder(ray);
-        setIntersection(ix, 0, outerIntersect.x, true, true);   // positive, enter
-        setIntersection(ix, 1, innerIntersect.x, false, true);  // negative, enter
-        setIntersection(ix, 2, innerIntersect.y, false, false); // negative, exit
-        setIntersection(ix, 3, outerIntersect.y, true, false);  // positive, exit
+        RayShapeIntersection innerIntersect = intersectCylinder(ray, 1.0, false);
+        setSurfaceIntersection(ix, 0, outerIntersect.entry, true, true);  // positive, enter
+        setSurfaceIntersection(ix, 1, innerIntersect.entry, false, true); // negative, enter
+        setSurfaceIntersection(ix, 2, innerIntersect.exit, false, false); // negative, exit
+        setSurfaceIntersection(ix, 3, outerIntersect.exit, true, false);  // positive, exit
     #elif defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MIN)
-        Ray innerRay = Ray(ray.pos * u_cylinderUvToRenderRadiusMin, ray.dir * u_cylinderUvToRenderRadiusMin);
-        vec2 innerIntersect = intersectInfiniteUnitCylinder(innerRay);
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MIN, innerIntersect);
+        RayShapeIntersection innerIntersect = intersectCylinder(ray, u_cylinderRenderRadiusMinMax.x, false);
+        setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MIN, innerIntersect);
     #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
 }