@cesium/engine 6.2.0 → 8.0.0

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\
 ";

package/Source/Shaders/Voxels/IntersectEllipsoid.glsl

@@ -1,13 +1,13 @@
 // See IntersectionUtils.glsl for the definitions of Ray, Intersections,
 // setIntersection, setIntersectionPair, INF_HIT, NO_HIT
+// See IntersectLongitude.glsl for the definitions of intersectHalfPlane,
+// intersectFlippedWedge, intersectRegularWedge
 
 /* Ellipsoid defines (set in Scene/VoxelEllipsoidShape.js)
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_UNDER_HALF
-#define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_EQUAL_HALF
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_OVER_HALF
-#define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_UNDER_HALF
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_EQUAL_HALF
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_OVER_HALF
@@ -16,7 +16,6 @@
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_OVER_HALF
 #define ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX
 #define ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN
-#define ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_FLAT
 #define ELLIPSOID_INTERSECTION_INDEX_LONGITUDE
 #define ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX
 #define ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN
@@ -48,78 +47,6 @@ vec2 intersectZPlane(Ray ray)
     else return vec2(-INF_HIT, t);
 }
 
-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);
-}
-
-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);
-
-    if (t >= 0.0 != s >= 0.0) return vec2(t, +INF_HIT);
-    else return vec2(-INF_HIT, t);
-}
-
-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 intersectUnitSphere(Ray ray)
 {
     vec3 o = ray.pos;
@@ -250,39 +177,32 @@ void intersectShape(in Ray ray, inout Intersections ix) {
     }
 
     // Inner ellipsoid
-    #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_FLAT)
-        // When the ellipsoid is perfectly thin it's necessary to sandwich the
-        // inner ellipsoid intersection inside the outer ellipsoid intersection.
-
-        // Without this special case,
-        // [outerMin, outerMax, innerMin, innerMax] will bubble sort to
-        // [outerMin, innerMin, outerMax, innerMax] which will cause the back
-        // side of the ellipsoid to be invisible because it will think the ray
-        // is still inside the inner (negative) ellipsoid after exiting the
-        // outer (positive) ellipsoid.
-
-        // With this special case,
-        // [outerMin, innerMin, innerMax, outerMax] will bubble sort to
-        // [outerMin, innerMin, innerMax, outerMax] which will work correctly.
-
-        // Note: If initializeIntersections() changes its sorting function
-        // from bubble sort to something else, this code may need to change.
-        setIntersection(ix, 0, outerIntersect.x, true, true);   // positive, enter
-        setIntersection(ix, 1, outerIntersect.x, false, true);  // negative, enter
-        setIntersection(ix, 2, outerIntersect.y, false, false); // negative, exit
-        setIntersection(ix, 3, outerIntersect.y, true, false);  // positive, exit
-    #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN)
+    #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN)
         Ray innerRay = Ray(ray.pos * u_ellipsoidInverseInnerScaleUv, ray.dir * u_ellipsoidInverseInnerScaleUv);
         vec2 innerIntersect = intersectUnitSphereUnnormalizedDirection(innerRay);
 
         if (innerIntersect == vec2(NO_HIT)) {
             setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MIN, innerIntersect);
         } else {
-            // When the ellipsoid is very large and thin it's possible for floating
-            // point math to cause the ray to intersect the inner ellipsoid before
-            // the outer ellipsoid. To prevent this from happening, clamp innerIntersect
-            // to outerIntersect and sandwhich the intersections like described above.
-            //
+            // When the ellipsoid is large and thin it's possible for floating point math
+            // to cause the ray to intersect the inner ellipsoid before the outer ellipsoid.
+            // To prevent this from happening, clamp innerIntersect to outerIntersect and
+            // sandwich the inner ellipsoid intersection inside the outer ellipsoid intersection.
+
+            // Without this special case,
+            // [outerMin, outerMax, innerMin, innerMax] will bubble sort to
+            // [outerMin, innerMin, outerMax, innerMax] which will cause the back
+            // side of the ellipsoid to be invisible because it will think the ray
+            // is still inside the inner (negative) ellipsoid after exiting the
+            // outer (positive) ellipsoid.
+
+            // With this special case,
+            // [outerMin, innerMin, innerMax, outerMax] will bubble sort to
+            // [outerMin, innerMin, innerMax, outerMax] which will work correctly.
+
+            // Note: If initializeIntersections() changes its sorting function
+            // from bubble sort to something else, this code may need to change.
+
             // In theory a similar fix is needed for cylinders, however it's more
             // complicated to implement because the inner shape is allowed to be
             // intersected first.
@@ -330,18 +250,17 @@ void intersectShape(in Ray ray, inout Intersections ix) {
 
     // Wedge
     #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO)
-        vec4 wedgeIntersect = intersectHalfPlane(ray, u_ellipsoidRenderLongitudeMinMax.x);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 0, wedgeIntersect.xy);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 1, wedgeIntersect.zw);
+        RayShapeIntersection wedgeIntersects[2];
+        intersectHalfPlane(ray, u_ellipsoidRenderLongitudeMinMax.x, wedgeIntersects);
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 0, wedgeIntersects[0]);
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 1, wedgeIntersects[1]);
     #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_UNDER_HALF)
-        vec2 wedgeIntersect = intersectRegularWedge(ray, u_ellipsoidRenderLongitudeMinMax.x, u_ellipsoidRenderLongitudeMinMax.y);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE, wedgeIntersect);
-    #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_EQUAL_HALF)
-        vec2 wedgeIntersect = intersectHalfSpace(ray, u_ellipsoidRenderLongitudeMinMax.x);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE, wedgeIntersect);
+        RayShapeIntersection wedgeIntersect = intersectRegularWedge(ray, u_ellipsoidRenderLongitudeMinMax);
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE, wedgeIntersect);
     #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_OVER_HALF)
-        vec4 wedgeIntersect = intersectFlippedWedge(ray, u_ellipsoidRenderLongitudeMinMax.x, u_ellipsoidRenderLongitudeMinMax.y);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 0, wedgeIntersect.xy);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 1, wedgeIntersect.zw);
+        RayShapeIntersection wedgeIntersects[2];
+        intersectFlippedWedge(ray, u_ellipsoidRenderLongitudeMinMax, wedgeIntersects);
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 0, wedgeIntersects[0]);
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 1, wedgeIntersects[1]);
     #endif
 }