@cesium/engine 7.0.0 → 9.0.0

package/Source/Shaders/Voxels/IntersectEllipsoid.glsl

@@ -1,22 +1,19 @@
-// See IntersectionUtils.glsl for the definitions of Ray, Intersections,
-// setIntersection, setIntersectionPair, INF_HIT, NO_HIT
+// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT, INF_HIT, Intersections,
+// RayShapeIntersection, setSurfaceIntersection, setShapeIntersection
+// 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
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_EQUAL_HALF
 #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
@@ -27,205 +24,225 @@
 #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE)
     uniform vec2 u_ellipsoidRenderLongitudeMinMax;
 #endif
-#if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_OVER_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_UNDER_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_OVER_HALF)
-    uniform vec2 u_ellipsoidRenderLatitudeCosSqrHalfMinMax;
-#endif
-#if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX)
-    uniform float u_ellipsoidInverseOuterScaleUv;
-#endif
-#if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN)
-    uniform float u_ellipsoidInverseInnerScaleUv;
-#endif
-
-vec2 intersectZPlane(Ray ray)
-{
-    float o = ray.pos.z;
-    float d = ray.dir.z;
-    float t = -o / d;
-    float s = sign(o);
-
-    if (t >= 0.0 != s >= 0.0) return vec2(t, +INF_HIT);
-    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);
+uniform float u_eccentricitySquared;
+uniform vec2 u_ellipsoidRenderLatitudeSinMinMax;
+uniform vec2 u_clipMinMaxHeight;
 
-    float a = dot(o, planeNormal);
-    float b = dot(d, planeNormal);
-    float t = -a / b;
+RayShapeIntersection intersectZPlane(in Ray ray, in float z) {
+    float t = -ray.pos.z / ray.dir.z;
 
-    vec2 p = o + t * d;
-    bool outside = dot(p, planeDirection) < 0.0;
-    if (outside) return vec4(-INF_HIT, +INF_HIT, NO_HIT, NO_HIT);
+    bool startsOutside = sign(ray.pos.z) == sign(z);
+    bool entry = (t >= 0.0) != startsOutside;
 
-    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);
+    vec4 intersect = vec4(0.0, 0.0, z, t);
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);
 
-    if (t >= 0.0 != s >= 0.0) return vec2(t, +INF_HIT);
-    else return vec2(-INF_HIT, t);
+    if (entry) {
+        return RayShapeIntersection(intersect, farSide);
+    } else {
+        return RayShapeIntersection(-1.0 * farSide, intersect);
+    }
 }
 
-vec2 intersectRegularWedge(Ray ray, float minAngle, float maxAngle)
+RayShapeIntersection intersectHeight(in Ray ray, in float relativeHeight, 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);
+    // Scale the ray by the ellipsoid axes to make it a unit sphere
+    // Note: approximating ellipsoid + height as an ellipsoid
+    vec3 radiiCorrection = u_ellipsoidRadiiUv / (u_ellipsoidRadiiUv + relativeHeight);
+    vec3 position = ray.pos * radiiCorrection;
+    vec3 direction = ray.dir * radiiCorrection;
+
+    float a = dot(direction, direction); // ~ 1.0 (or maybe 4.0 if ray is scaled)
+    float b = dot(direction, position); // roughly inside [-1.0, 1.0] when zoomed in
+    float c = dot(position, position) - 1.0; // ~ 0.0 when zoomed in.
+    float determinant = b * b - a * c; // ~ b * b when zoomed in
+
+    if (determinant < 0.0) {
+        vec4 miss = vec4(normalize(direction), NO_HIT);
+        return RayShapeIntersection(miss, miss);
+    }
 
-    float t1 = -a1 / b1;
-    float t2 = -a2 / b2;
-    float s1 = sign(a1);
-    float s2 = sign(a2);
+    determinant = sqrt(determinant);
 
+    // Compute larger root using standard formula
+    float signB = b < 0.0 ? -1.0 : 1.0;
+    // The other root may suffer from subtractive cancellation in the standard formula.
+    // Compute it from the first root instead.
+    float t1 = (-b - signB * determinant) / a;
+    float t2 = c / (a * t1);
     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);
+    float directionScale = convex ? 1.0 : -1.0;
+    vec3 d1 = directionScale * normalize(position + tmin * direction);
+    vec3 d2 = directionScale * normalize(position + tmax * direction);
+
+    return RayShapeIntersection(vec4(d1, tmin), vec4(d2, tmax));
 }
 
-vec2 intersectUnitSphere(Ray ray)
+/**
+ * Given a circular cone around the z-axis, with apex at the origin,
+ * find the parametric distance(s) along a ray where that ray intersects
+ * the cone.
+ * The cone opening angle is described by the squared cosine of
+ * its half-angle (the angle between the Z-axis and the surface)
+ */
+vec2 intersectDoubleEndedCone(in Ray ray, in float cosSqrHalfAngle)
 {
     vec3 o = ray.pos;
     vec3 d = ray.dir;
+    float sinSqrHalfAngle = 1.0 - cosSqrHalfAngle;
 
-    float b = dot(d, o);
-    float c = dot(o, o) - 1.0;
-    float det = b * b - c;
-
-    if (det < 0.0) {
-        return vec2(NO_HIT);
-    }
-
-    det = sqrt(det);
-    float t1 = -b - det;
-    float t2 = -b + det;
-    float tmin = min(t1, t2);
-    float tmax = max(t1, t2);
-
-    return vec2(tmin, tmax);
-}
+    float aSin = d.z * d.z * sinSqrHalfAngle;
+    float aCos = -dot(d.xy, d.xy) * cosSqrHalfAngle;
+    float a = aSin + aCos;
 
-vec2 intersectUnitSphereUnnormalizedDirection(Ray ray)
-{
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
+    float bSin = d.z * o.z * sinSqrHalfAngle;
+    float bCos = -dot(o.xy, d.xy) * cosSqrHalfAngle;
+    float b = bSin + bCos;
 
-    float a = dot(d, d);
-    float b = dot(d, o);
-    float c = dot(o, o) - 1.0;
-    float det = b * b - a * c;
+    float cSin = o.z * o.z * sinSqrHalfAngle;
+    float cCos = -dot(o.xy, o.xy) * cosSqrHalfAngle;
+    float c = cSin + cCos;
+    // determinant = b * b - a * c. But bSin * bSin = aSin * cSin.
+    // Avoid subtractive cancellation by expanding to eliminate these terms
+    float determinant = 2.0 * bSin * bCos + bCos * bCos - aSin * cCos - aCos * cSin - aCos * cCos;
 
-    if (det < 0.0) {
+    if (determinant < 0.0) {
         return vec2(NO_HIT);
+    } else if (a == 0.0) {
+        // Ray is parallel to cone surface
+        return (b == 0.0)
+            ? vec2(NO_HIT) // Ray is on cone surface
+            : vec2(-0.5 * c / b, NO_HIT);
     }
 
-    det = sqrt(det);
-    float t1 = (-b - det) / a;
-    float t2 = (-b + det) / a;
+    determinant = sqrt(determinant);
+
+    // Compute larger root using standard formula
+    float signB = b < 0.0 ? -1.0 : 1.0;
+    float t1 = (-b - signB * determinant) / a;
+    // The other root may suffer from subtractive cancellation in the standard formula.
+    // Compute it from the first root instead.
+    float t2 = c / (a * t1);
     float tmin = min(t1, t2);
     float tmax = max(t1, t2);
-
     return vec2(tmin, tmax);
 }
 
-vec2 intersectDoubleEndedCone(Ray ray, float cosSqrHalfAngle)
-{
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
-    float a = d.z * d.z - dot(d, d) * cosSqrHalfAngle;
-    float b = d.z * o.z - dot(o, d) * cosSqrHalfAngle;
-    float c = o.z * o.z - dot(o, o) * cosSqrHalfAngle;
-    float det = b * b - a * c;
-
-    if (det < 0.0) {
-        return vec2(NO_HIT);
-    }
+/**
+ * Given a point on a conical surface, find the surface normal at that point.
+ */
+vec3 getConeNormal(in vec3 p, in bool convex) {
+    // Start with radial component pointing toward z-axis
+    vec2 radial = -abs(p.z) * normalize(p.xy);
+    // Z component points toward opening of cone
+    float zSign = (p.z < 0.0) ? -1.0 : 1.0;
+    float z = length(p.xy) * zSign;
+    // Flip normal if shape is convex
+    float flip = (convex) ? -1.0 : 1.0;
+    return normalize(vec3(radial, z) * flip);
+}
 
-    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);
+/**
+ * Compute the shift between the ellipsoid origin and the apex of a cone of latitude
+ */
+float getLatitudeConeShift(in float sinLatitude) {
+    // Find prime vertical radius of curvature: 
+    // the distance along the ellipsoid normal to the intersection with the z-axis
+    float x2 = u_eccentricitySquared * sinLatitude * sinLatitude;
+    float primeVerticalRadius = inversesqrt(1.0 - x2);
+
+    // Compute a shift from the origin to the intersection of the cone with the z-axis
+    return primeVerticalRadius * u_eccentricitySquared * sinLatitude;
 }
 
-vec4 intersectFlippedCone(Ray ray, float cosSqrHalfAngle) {
+void intersectFlippedCone(in Ray ray, in float cosHalfAngle, out RayShapeIntersection intersections[2]) {
+    // Undo the scaling from ellipsoid to sphere
+    ray.pos = ray.pos * u_ellipsoidRadiiUv;
+    ray.dir = ray.dir * u_ellipsoidRadiiUv;
+    // Shift the ray to account for the latitude cone not being centered at the Earth center
+    ray.pos.z += getLatitudeConeShift(cosHalfAngle);
+
+    float cosSqrHalfAngle = cosHalfAngle * cosHalfAngle;
     vec2 intersect = intersectDoubleEndedCone(ray, cosSqrHalfAngle);
 
+    vec4 miss = vec4(normalize(ray.dir), NO_HIT);
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);
+
+    // Initialize output with no intersections
+    intersections[0].entry = -1.0 * farSide;
+    intersections[0].exit = farSide;
+    intersections[1].entry = miss;
+    intersections[1].exit = miss;
+
     if (intersect.x == NO_HIT) {
-        return vec4(-INF_HIT, +INF_HIT, NO_HIT, NO_HIT);
+        return;
     }
 
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
+    // Find the points of intersection
     float tmin = intersect.x;
     float tmax = intersect.y;
-    float zmin = o.z + tmin * d.z;
-    float zmax = o.z + tmax * d.z;
-
-    // One interval
-    if (zmin < 0.0 && zmax < 0.0) return vec4(-INF_HIT, +INF_HIT, NO_HIT, NO_HIT);
-    else if (zmin < 0.0) return vec4(-INF_HIT, tmax, NO_HIT, NO_HIT);
-    else if (zmax < 0.0) return vec4(tmin, +INF_HIT, NO_HIT, NO_HIT);
-    // Two intervals
-    else return vec4(-INF_HIT, tmin, tmax, +INF_HIT);
+    vec3 p0 = ray.pos + tmin * ray.dir;
+    vec3 p1 = ray.pos + tmax * ray.dir;
+
+    vec4 intersect0 = vec4(getConeNormal(p0, true), tmin);
+    vec4 intersect1 = vec4(getConeNormal(p1, true), tmax);
+
+    bool p0InShadowCone = sign(p0.z) != sign(cosHalfAngle);
+    bool p1InShadowCone = sign(p1.z) != sign(cosHalfAngle);
+
+    if (p0InShadowCone && p1InShadowCone) {
+        // no valid intersections
+    } else if (p0InShadowCone) {
+        intersections[0].exit = intersect1;
+    } else if (p1InShadowCone) {
+        intersections[0].entry = intersect0;
+    } else {
+        intersections[0].exit = intersect0;
+        intersections[1].entry = intersect1;
+        intersections[1].exit = farSide;
+    }
 }
 
-vec2 intersectRegularCone(Ray ray, float cosSqrHalfAngle) {
+RayShapeIntersection intersectRegularCone(in Ray ray, in float cosHalfAngle, in bool convex) {
+    // Undo the scaling from ellipsoid to sphere
+    ray.pos = ray.pos * u_ellipsoidRadiiUv;
+    ray.dir = ray.dir * u_ellipsoidRadiiUv;
+    // Shift the ray to account for the latitude cone not being centered at the Earth center
+    ray.pos.z += getLatitudeConeShift(cosHalfAngle);
+
+    float cosSqrHalfAngle = cosHalfAngle * cosHalfAngle;
     vec2 intersect = intersectDoubleEndedCone(ray, cosSqrHalfAngle);
 
+    vec4 miss = vec4(normalize(ray.dir), NO_HIT);
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);
+
     if (intersect.x == NO_HIT) {
-        return vec2(NO_HIT);
+        return RayShapeIntersection(miss, miss);
     }
 
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
+    // Find the points of intersection
     float tmin = intersect.x;
     float tmax = intersect.y;
-    float zmin = o.z + tmin * d.z;
-    float zmax = o.z + tmax * d.z;
-
-    if (zmin < 0.0 && zmax < 0.0) return vec2(NO_HIT);
-    else if (zmin < 0.0) return vec2(tmax, +INF_HIT);
-    else if (zmax < 0.0) return vec2(-INF_HIT, tmin);
-    else return vec2(tmin, tmax);
+    vec3 p0 = ray.pos + tmin * ray.dir;
+    vec3 p1 = ray.pos + tmax * ray.dir;
+
+    vec4 intersect0 = vec4(getConeNormal(p0, convex), tmin);
+    vec4 intersect1 = vec4(getConeNormal(p1, convex), tmax);
+
+    bool p0InShadowCone = sign(p0.z) != sign(cosHalfAngle);
+    bool p1InShadowCone = sign(p1.z) != sign(cosHalfAngle);
+
+    if (p0InShadowCone && p1InShadowCone) {
+        return RayShapeIntersection(miss, miss);
+    } else if (p0InShadowCone) {
+        return RayShapeIntersection(intersect1, farSide);
+    } else if (p1InShadowCone) {
+        return RayShapeIntersection(-1.0 * farSide, intersect0);
+    } else {
+        return RayShapeIntersection(intersect0, intersect1);
+    }
 }
 
 void intersectShape(in Ray ray, inout Intersections ix) {
@@ -234,25 +251,25 @@ void intersectShape(in Ray ray, inout Intersections ix) {
     ray.pos = ray.pos * 2.0 - 1.0;
     ray.dir *= 2.0;
 
-    #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX)
-        Ray outerRay = Ray(ray.pos * u_ellipsoidInverseOuterScaleUv, ray.dir * u_ellipsoidInverseOuterScaleUv);
-    #else
-        Ray outerRay = ray;
-    #endif
-
     // Outer ellipsoid
-    vec2 outerIntersect = intersectUnitSphereUnnormalizedDirection(outerRay);
-    setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MAX, outerIntersect);
+    RayShapeIntersection outerIntersect = intersectHeight(ray, u_clipMinMaxHeight.y, true);
+    setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MAX, outerIntersect);
 
     // Exit early if the outer ellipsoid was missed.
-    if (outerIntersect.x == NO_HIT) {
+    if (outerIntersect.entry.w == NO_HIT) {
         return;
     }
 
     // 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.
+    RayShapeIntersection innerIntersect = intersectHeight(ray, u_clipMinMaxHeight.x, false);
+
+    if (innerIntersect.entry.w == NO_HIT) {
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MIN, innerIntersect);
+    } else {
+        // 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
@@ -267,81 +284,55 @@ void intersectShape(in Ray ray, inout Intersections ix) {
 
         // 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)
-        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.
-            //
-            // 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.
-            innerIntersect.x = max(innerIntersect.x, outerIntersect.x);
-            innerIntersect.y = min(innerIntersect.y, outerIntersect.y);
-            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
-        }
-    #endif
-
-    // Flip the ray because the intersection function expects a cone growing towards +Z.
-    #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_EQUAL_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_UNDER_HALF)
-        Ray flippedRay = outerRay;
-        flippedRay.dir.z *= -1.0;
-        flippedRay.pos.z *= -1.0;
-    #endif
+        innerIntersect.entry.w = max(innerIntersect.entry.w, outerIntersect.entry.w);
+        innerIntersect.exit.w = min(innerIntersect.exit.w, outerIntersect.exit.w);
+        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
+    }
 
     // Bottom cone
     #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF)
-        vec2 bottomConeIntersection = intersectRegularCone(flippedRay, u_ellipsoidRenderLatitudeCosSqrHalfMinMax.x);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN, bottomConeIntersection);
+        RayShapeIntersection bottomConeIntersection = intersectRegularCone(ray, u_ellipsoidRenderLatitudeSinMinMax.x, false);
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN, bottomConeIntersection);
     #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_EQUAL_HALF)
-        vec2 bottomConeIntersection = intersectZPlane(flippedRay);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN, bottomConeIntersection);
+        RayShapeIntersection bottomConeIntersection = intersectZPlane(ray, -1.0);
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN, bottomConeIntersection);
     #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_OVER_HALF)
-        vec4 bottomConeIntersection = intersectFlippedCone(ray, u_ellipsoidRenderLatitudeCosSqrHalfMinMax.x);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN + 0, bottomConeIntersection.xy);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN + 1, bottomConeIntersection.zw);
+        RayShapeIntersection bottomConeIntersections[2];
+        intersectFlippedCone(ray, u_ellipsoidRenderLatitudeSinMinMax.x, bottomConeIntersections);
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN + 0, bottomConeIntersections[0]);
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN + 1, bottomConeIntersections[1]);
     #endif
 
     // Top cone
     #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_UNDER_HALF)
-        vec4 topConeIntersection = intersectFlippedCone(flippedRay, u_ellipsoidRenderLatitudeCosSqrHalfMinMax.y);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX + 0, topConeIntersection.xy);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX + 1, topConeIntersection.zw);
+        RayShapeIntersection topConeIntersections[2];
+        intersectFlippedCone(ray, u_ellipsoidRenderLatitudeSinMinMax.y, topConeIntersections);
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX + 0, topConeIntersections[0]);
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX + 1, topConeIntersections[1]);
     #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_EQUAL_HALF)
-        vec2 topConeIntersection = intersectZPlane(ray);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX, topConeIntersection);
+        RayShapeIntersection topConeIntersection = intersectZPlane(ray, 1.0);
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX, topConeIntersection);
     #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_OVER_HALF)
-        vec2 topConeIntersection = intersectRegularCone(ray, u_ellipsoidRenderLatitudeCosSqrHalfMinMax.y);
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX, topConeIntersection);
+        RayShapeIntersection topConeIntersection = intersectRegularCone(ray, u_ellipsoidRenderLatitudeSinMinMax.y, false);
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX, topConeIntersection);
     #endif
 
     // 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
 }