@cesium/engine 8.0.0 → 9.1.0

package/Source/Shaders/Voxels/IntersectEllipsoid.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,\n\
-// setIntersection, setIntersectionPair, INF_HIT, NO_HIT\n\
+export default "// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT, INF_HIT, Intersections,\n\
+// RayShapeIntersection, setSurfaceIntersection, setShapeIntersection\n\
 // See IntersectLongitude.glsl for the definitions of intersectHalfPlane,\n\
 // intersectFlippedWedge, intersectRegularWedge\n\
 \n\
@@ -15,8 +15,6 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, Inters
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_EQUAL_HALF\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_OVER_HALF\n\
-#define ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX\n\
-#define ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN\n\
 #define ELLIPSOID_INTERSECTION_INDEX_LONGITUDE\n\
 #define ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX\n\
 #define ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN\n\
@@ -27,133 +25,225 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, Inters
 #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE)\n\
     uniform vec2 u_ellipsoidRenderLongitudeMinMax;\n\
 #endif\n\
-#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)\n\
-    uniform vec2 u_ellipsoidRenderLatitudeCosSqrHalfMinMax;\n\
-#endif\n\
-#if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX)\n\
-    uniform float u_ellipsoidInverseOuterScaleUv;\n\
-#endif\n\
-#if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN)\n\
-    uniform float u_ellipsoidInverseInnerScaleUv;\n\
-#endif\n\
+uniform float u_eccentricitySquared;\n\
+uniform vec2 u_ellipsoidRenderLatitudeSinMinMax;\n\
+uniform vec2 u_clipMinMaxHeight;\n\
 \n\
-vec2 intersectZPlane(Ray ray)\n\
-{\n\
-    float o = ray.pos.z;\n\
-    float d = ray.dir.z;\n\
-    float t = -o / d;\n\
-    float s = sign(o);\n\
+RayShapeIntersection intersectZPlane(in Ray ray, in float z) {\n\
+    float t = -ray.pos.z / ray.dir.z;\n\
 \n\
-    if (t >= 0.0 != s >= 0.0) return vec2(t, +INF_HIT);\n\
-    else return vec2(-INF_HIT, t);\n\
-}\n\
+    bool startsOutside = sign(ray.pos.z) == sign(z);\n\
+    bool entry = (t >= 0.0) != startsOutside;\n\
 \n\
-vec2 intersectUnitSphere(Ray ray)\n\
-{\n\
-    vec3 o = ray.pos;\n\
-    vec3 d = ray.dir;\n\
+    vec4 intersect = vec4(0.0, 0.0, z, t);\n\
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);\n\
 \n\
-    float b = dot(d, o);\n\
-    float c = dot(o, o) - 1.0;\n\
-    float det = b * b - c;\n\
+    if (entry) {\n\
+        return RayShapeIntersection(intersect, farSide);\n\
+    } else {\n\
+        return RayShapeIntersection(-1.0 * farSide, intersect);\n\
+    }\n\
+}\n\
 \n\
-    if (det < 0.0) {\n\
-        return vec2(NO_HIT);\n\
+RayShapeIntersection intersectHeight(in Ray ray, in float relativeHeight, in bool convex)\n\
+{\n\
+    // Scale the ray by the ellipsoid axes to make it a unit sphere\n\
+    // Note: approximating ellipsoid + height as an ellipsoid\n\
+    vec3 radiiCorrection = u_ellipsoidRadiiUv / (u_ellipsoidRadiiUv + relativeHeight);\n\
+    vec3 position = ray.pos * radiiCorrection;\n\
+    vec3 direction = ray.dir * radiiCorrection;\n\
+\n\
+    float a = dot(direction, direction); // ~ 1.0 (or maybe 4.0 if ray is scaled)\n\
+    float b = dot(direction, position); // roughly inside [-1.0, 1.0] when zoomed in\n\
+    float c = dot(position, position) - 1.0; // ~ 0.0 when zoomed in.\n\
+    float determinant = b * b - a * c; // ~ b * b when zoomed in\n\
+\n\
+    if (determinant < 0.0) {\n\
+        vec4 miss = vec4(normalize(direction), NO_HIT);\n\
+        return RayShapeIntersection(miss, miss);\n\
     }\n\
 \n\
-    det = sqrt(det);\n\
-    float t1 = -b - det;\n\
-    float t2 = -b + det;\n\
+    determinant = sqrt(determinant);\n\
+\n\
+    // Compute larger root using standard formula\n\
+    float signB = b < 0.0 ? -1.0 : 1.0;\n\
+    // The other root may suffer from subtractive cancellation in the standard formula.\n\
+    // Compute it from the first root instead.\n\
+    float t1 = (-b - signB * determinant) / a;\n\
+    float t2 = c / (a * t1);\n\
     float tmin = min(t1, t2);\n\
     float tmax = max(t1, t2);\n\
 \n\
-    return vec2(tmin, tmax);\n\
+    float directionScale = convex ? 1.0 : -1.0;\n\
+    vec3 d1 = directionScale * normalize(position + tmin * direction);\n\
+    vec3 d2 = directionScale * normalize(position + tmax * direction);\n\
+\n\
+    return RayShapeIntersection(vec4(d1, tmin), vec4(d2, tmax));\n\
 }\n\
 \n\
-vec2 intersectUnitSphereUnnormalizedDirection(Ray ray)\n\
+/**\n\
+ * Given a circular cone around the z-axis, with apex at the origin,\n\
+ * find the parametric distance(s) along a ray where that ray intersects\n\
+ * the cone.\n\
+ * The cone opening angle is described by the squared cosine of\n\
+ * its half-angle (the angle between the Z-axis and the surface)\n\
+ */\n\
+vec2 intersectDoubleEndedCone(in Ray ray, in float cosSqrHalfAngle)\n\
 {\n\
     vec3 o = ray.pos;\n\
     vec3 d = ray.dir;\n\
+    float sinSqrHalfAngle = 1.0 - cosSqrHalfAngle;\n\
+\n\
+    float aSin = d.z * d.z * sinSqrHalfAngle;\n\
+    float aCos = -dot(d.xy, d.xy) * cosSqrHalfAngle;\n\
+    float a = aSin + aCos;\n\
 \n\
-    float a = dot(d, d);\n\
-    float b = dot(d, o);\n\
-    float c = dot(o, o) - 1.0;\n\
-    float det = b * b - a * c;\n\
+    float bSin = d.z * o.z * sinSqrHalfAngle;\n\
+    float bCos = -dot(o.xy, d.xy) * cosSqrHalfAngle;\n\
+    float b = bSin + bCos;\n\
 \n\
-    if (det < 0.0) {\n\
+    float cSin = o.z * o.z * sinSqrHalfAngle;\n\
+    float cCos = -dot(o.xy, o.xy) * cosSqrHalfAngle;\n\
+    float c = cSin + cCos;\n\
+    // determinant = b * b - a * c. But bSin * bSin = aSin * cSin.\n\
+    // Avoid subtractive cancellation by expanding to eliminate these terms\n\
+    float determinant = 2.0 * bSin * bCos + bCos * bCos - aSin * cCos - aCos * cSin - aCos * cCos;\n\
+\n\
+    if (determinant < 0.0) {\n\
         return vec2(NO_HIT);\n\
+    } else if (a == 0.0) {\n\
+        // Ray is parallel to cone surface\n\
+        return (b == 0.0)\n\
+            ? vec2(NO_HIT) // Ray is on cone surface\n\
+            : vec2(-0.5 * c / b, NO_HIT);\n\
     }\n\
 \n\
-    det = sqrt(det);\n\
-    float t1 = (-b - det) / a;\n\
-    float t2 = (-b + det) / a;\n\
+    determinant = sqrt(determinant);\n\
+\n\
+    // Compute larger root using standard formula\n\
+    float signB = b < 0.0 ? -1.0 : 1.0;\n\
+    float t1 = (-b - signB * determinant) / a;\n\
+    // The other root may suffer from subtractive cancellation in the standard formula.\n\
+    // Compute it from the first root instead.\n\
+    float t2 = c / (a * t1);\n\
     float tmin = min(t1, t2);\n\
     float tmax = max(t1, t2);\n\
-\n\
     return vec2(tmin, tmax);\n\
 }\n\
 \n\
-vec2 intersectDoubleEndedCone(Ray ray, float cosSqrHalfAngle)\n\
-{\n\
-    vec3 o = ray.pos;\n\
-    vec3 d = ray.dir;\n\
-    float a = d.z * d.z - dot(d, d) * cosSqrHalfAngle;\n\
-    float b = d.z * o.z - dot(o, d) * cosSqrHalfAngle;\n\
-    float c = o.z * o.z - dot(o, o) * cosSqrHalfAngle;\n\
-    float det = b * b - a * c;\n\
-\n\
-    if (det < 0.0) {\n\
-        return vec2(NO_HIT);\n\
-    }\n\
+/**\n\
+ * Given a point on a conical surface, find the surface normal at that point.\n\
+ */\n\
+vec3 getConeNormal(in vec3 p, in bool convex) {\n\
+    // Start with radial component pointing toward z-axis\n\
+    vec2 radial = -abs(p.z) * normalize(p.xy);\n\
+    // Z component points toward opening of cone\n\
+    float zSign = (p.z < 0.0) ? -1.0 : 1.0;\n\
+    float z = length(p.xy) * zSign;\n\
+    // Flip normal if shape is convex\n\
+    float flip = (convex) ? -1.0 : 1.0;\n\
+    return normalize(vec3(radial, z) * flip);\n\
+}\n\
 \n\
-    det = sqrt(det);\n\
-    float t1 = (-b - det) / a;\n\
-    float t2 = (-b + det) / a;\n\
-    float tmin = min(t1, t2);\n\
-    float tmax = max(t1, t2);\n\
-    return vec2(tmin, tmax);\n\
+/**\n\
+ * Compute the shift between the ellipsoid origin and the apex of a cone of latitude\n\
+ */\n\
+float getLatitudeConeShift(in float sinLatitude) {\n\
+    // Find prime vertical radius of curvature: \n\
+    // the distance along the ellipsoid normal to the intersection with the z-axis\n\
+    float x2 = u_eccentricitySquared * sinLatitude * sinLatitude;\n\
+    float primeVerticalRadius = inversesqrt(1.0 - x2);\n\
+\n\
+    // Compute a shift from the origin to the intersection of the cone with the z-axis\n\
+    return primeVerticalRadius * u_eccentricitySquared * sinLatitude;\n\
 }\n\
 \n\
-vec4 intersectFlippedCone(Ray ray, float cosSqrHalfAngle) {\n\
+void intersectFlippedCone(in Ray ray, in float cosHalfAngle, out RayShapeIntersection intersections[2]) {\n\
+    // Undo the scaling from ellipsoid to sphere\n\
+    ray.pos = ray.pos * u_ellipsoidRadiiUv;\n\
+    ray.dir = ray.dir * u_ellipsoidRadiiUv;\n\
+    // Shift the ray to account for the latitude cone not being centered at the Earth center\n\
+    ray.pos.z += getLatitudeConeShift(cosHalfAngle);\n\
+\n\
+    float cosSqrHalfAngle = cosHalfAngle * cosHalfAngle;\n\
     vec2 intersect = intersectDoubleEndedCone(ray, cosSqrHalfAngle);\n\
+\n\
+    vec4 miss = vec4(normalize(ray.dir), NO_HIT);\n\
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);\n\
+\n\
+    // Initialize output with no intersections\n\
+    intersections[0].entry = -1.0 * farSide;\n\
+    intersections[0].exit = farSide;\n\
+    intersections[1].entry = miss;\n\
+    intersections[1].exit = miss;\n\
 \n\
     if (intersect.x == NO_HIT) {\n\
-        return vec4(-INF_HIT, +INF_HIT, NO_HIT, NO_HIT);\n\
+        return;\n\
     }\n\
 \n\
-    vec3 o = ray.pos;\n\
-    vec3 d = ray.dir;\n\
+    // Find the points of intersection\n\
     float tmin = intersect.x;\n\
     float tmax = intersect.y;\n\
-    float zmin = o.z + tmin * d.z;\n\
-    float zmax = o.z + tmax * d.z;\n\
-\n\
-    // One interval\n\
-    if (zmin < 0.0 && zmax < 0.0) return vec4(-INF_HIT, +INF_HIT, NO_HIT, NO_HIT);\n\
-    else if (zmin < 0.0) return vec4(-INF_HIT, tmax, NO_HIT, NO_HIT);\n\
-    else if (zmax < 0.0) return vec4(tmin, +INF_HIT, NO_HIT, NO_HIT);\n\
-    // Two intervals\n\
-    else return vec4(-INF_HIT, tmin, tmax, +INF_HIT);\n\
+    vec3 p0 = ray.pos + tmin * ray.dir;\n\
+    vec3 p1 = ray.pos + tmax * ray.dir;\n\
+\n\
+    vec4 intersect0 = vec4(getConeNormal(p0, true), tmin);\n\
+    vec4 intersect1 = vec4(getConeNormal(p1, true), tmax);\n\
+\n\
+    bool p0InShadowCone = sign(p0.z) != sign(cosHalfAngle);\n\
+    bool p1InShadowCone = sign(p1.z) != sign(cosHalfAngle);\n\
+\n\
+    if (p0InShadowCone && p1InShadowCone) {\n\
+        // no valid intersections\n\
+    } else if (p0InShadowCone) {\n\
+        intersections[0].exit = intersect1;\n\
+    } else if (p1InShadowCone) {\n\
+        intersections[0].entry = intersect0;\n\
+    } else {\n\
+        intersections[0].exit = intersect0;\n\
+        intersections[1].entry = intersect1;\n\
+        intersections[1].exit = farSide;\n\
+    }\n\
 }\n\
 \n\
-vec2 intersectRegularCone(Ray ray, float cosSqrHalfAngle) {\n\
+RayShapeIntersection intersectRegularCone(in Ray ray, in float cosHalfAngle, in bool convex) {\n\
+    // Undo the scaling from ellipsoid to sphere\n\
+    ray.pos = ray.pos * u_ellipsoidRadiiUv;\n\
+    ray.dir = ray.dir * u_ellipsoidRadiiUv;\n\
+    // Shift the ray to account for the latitude cone not being centered at the Earth center\n\
+    ray.pos.z += getLatitudeConeShift(cosHalfAngle);\n\
+\n\
+    float cosSqrHalfAngle = cosHalfAngle * cosHalfAngle;\n\
     vec2 intersect = intersectDoubleEndedCone(ray, cosSqrHalfAngle);\n\
+\n\
+    vec4 miss = vec4(normalize(ray.dir), NO_HIT);\n\
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);\n\
 \n\
     if (intersect.x == NO_HIT) {\n\
-        return vec2(NO_HIT);\n\
+        return RayShapeIntersection(miss, miss);\n\
     }\n\
 \n\
-    vec3 o = ray.pos;\n\
-    vec3 d = ray.dir;\n\
+    // Find the points of intersection\n\
     float tmin = intersect.x;\n\
     float tmax = intersect.y;\n\
-    float zmin = o.z + tmin * d.z;\n\
-    float zmax = o.z + tmax * d.z;\n\
-\n\
-    if (zmin < 0.0 && zmax < 0.0) return vec2(NO_HIT);\n\
-    else if (zmin < 0.0) return vec2(tmax, +INF_HIT);\n\
-    else if (zmax < 0.0) return vec2(-INF_HIT, tmin);\n\
-    else return vec2(tmin, tmax);\n\
+    vec3 p0 = ray.pos + tmin * ray.dir;\n\
+    vec3 p1 = ray.pos + tmax * ray.dir;\n\
+\n\
+    vec4 intersect0 = vec4(getConeNormal(p0, convex), tmin);\n\
+    vec4 intersect1 = vec4(getConeNormal(p1, convex), tmax);\n\
+\n\
+    bool p0InShadowCone = sign(p0.z) != sign(cosHalfAngle);\n\
+    bool p1InShadowCone = sign(p1.z) != sign(cosHalfAngle);\n\
+\n\
+    if (p0InShadowCone && p1InShadowCone) {\n\
+        return RayShapeIntersection(miss, miss);\n\
+    } else if (p0InShadowCone) {\n\
+        return RayShapeIntersection(intersect1, farSide);\n\
+    } else if (p1InShadowCone) {\n\
+        return RayShapeIntersection(-1.0 * farSide, intersect0);\n\
+    } else {\n\
+        return RayShapeIntersection(intersect0, intersect1);\n\
+    }\n\
 }\n\
 \n\
 void intersectShape(in Ray ray, inout Intersections ix) {\n\
@@ -161,92 +251,74 @@ void intersectShape(in Ray ray, inout Intersections ix) {\n\
     // Direction is scaled as well to be in sync with position.\n\
     ray.pos = ray.pos * 2.0 - 1.0;\n\
     ray.dir *= 2.0;\n\
-\n\
-    #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX)\n\
-        Ray outerRay = Ray(ray.pos * u_ellipsoidInverseOuterScaleUv, ray.dir * u_ellipsoidInverseOuterScaleUv);\n\
-    #else\n\
-        Ray outerRay = ray;\n\
-    #endif\n\
 \n\
     // Outer ellipsoid\n\
-    vec2 outerIntersect = intersectUnitSphereUnnormalizedDirection(outerRay);\n\
-    setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MAX, outerIntersect);\n\
+    RayShapeIntersection outerIntersect = intersectHeight(ray, u_clipMinMaxHeight.y, true);\n\
+    setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MAX, outerIntersect);\n\
 \n\
     // Exit early if the outer ellipsoid was missed.\n\
-    if (outerIntersect.x == NO_HIT) {\n\
+    if (outerIntersect.entry.w == NO_HIT) {\n\
         return;\n\
     }\n\
 \n\
     // Inner ellipsoid\n\
-    #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN)\n\
-        Ray innerRay = Ray(ray.pos * u_ellipsoidInverseInnerScaleUv, ray.dir * u_ellipsoidInverseInnerScaleUv);\n\
-        vec2 innerIntersect = intersectUnitSphereUnnormalizedDirection(innerRay);\n\
-\n\
-        if (innerIntersect == vec2(NO_HIT)) {\n\
-            setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MIN, innerIntersect);\n\
-        } else {\n\
-            // When the ellipsoid is large and thin it's possible for floating point math\n\
-            // to cause the ray to intersect the inner ellipsoid before the outer ellipsoid.\n\
-            // To prevent this from happening, clamp innerIntersect to outerIntersect and\n\
-            // sandwich the inner ellipsoid intersection inside the outer ellipsoid intersection.\n\
-\n\
-            // Without this special case,\n\
-            // [outerMin, outerMax, innerMin, innerMax] will bubble sort to\n\
-            // [outerMin, innerMin, outerMax, innerMax] which will cause the back\n\
-            // side of the ellipsoid to be invisible because it will think the ray\n\
-            // is still inside the inner (negative) ellipsoid after exiting the\n\
-            // outer (positive) ellipsoid.\n\
-\n\
-            // With this special case,\n\
-            // [outerMin, innerMin, innerMax, outerMax] will bubble sort to\n\
-            // [outerMin, innerMin, innerMax, outerMax] which will work correctly.\n\
-\n\
-            // Note: If initializeIntersections() changes its sorting function\n\
-            // from bubble sort to something else, this code may need to change.\n\
-\n\
-            // In theory a similar fix is needed for cylinders, however it's more\n\
-            // complicated to implement because the inner shape is allowed to be\n\
-            // intersected first.\n\
-            innerIntersect.x = max(innerIntersect.x, outerIntersect.x);\n\
-            innerIntersect.y = min(innerIntersect.y, outerIntersect.y);\n\
-            setIntersection(ix, 0, outerIntersect.x, true, true);   // positive, enter\n\
-            setIntersection(ix, 1, innerIntersect.x, false, true);  // negative, enter\n\
-            setIntersection(ix, 2, innerIntersect.y, false, false); // negative, exit\n\
-            setIntersection(ix, 3, outerIntersect.y, true, false);  // positive, exit\n\
-        }\n\
-    #endif\n\
-\n\
-    // Flip the ray because the intersection function expects a cone growing towards +Z.\n\
-    #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)\n\
-        Ray flippedRay = outerRay;\n\
-        flippedRay.dir.z *= -1.0;\n\
-        flippedRay.pos.z *= -1.0;\n\
-    #endif\n\
+    RayShapeIntersection innerIntersect = intersectHeight(ray, u_clipMinMaxHeight.x, false);\n\
+\n\
+    if (innerIntersect.entry.w == NO_HIT) {\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MIN, innerIntersect);\n\
+    } else {\n\
+        // When the ellipsoid is large and thin it's possible for floating point math\n\
+        // to cause the ray to intersect the inner ellipsoid before the outer ellipsoid. \n\
+        // To prevent this from happening, clamp innerIntersect to outerIntersect and\n\
+        // sandwich the inner ellipsoid intersection inside the outer ellipsoid intersection.\n\
+\n\
+        // Without this special case,\n\
+        // [outerMin, outerMax, innerMin, innerMax] will bubble sort to\n\
+        // [outerMin, innerMin, outerMax, innerMax] which will cause the back\n\
+        // side of the ellipsoid to be invisible because it will think the ray\n\
+        // is still inside the inner (negative) ellipsoid after exiting the\n\
+        // outer (positive) ellipsoid.\n\
+\n\
+        // With this special case,\n\
+        // [outerMin, innerMin, innerMax, outerMax] will bubble sort to\n\
+        // [outerMin, innerMin, innerMax, outerMax] which will work correctly.\n\
+\n\
+        // Note: If initializeIntersections() changes its sorting function\n\
+        // from bubble sort to something else, this code may need to change.\n\
+        innerIntersect.entry.w = max(innerIntersect.entry.w, outerIntersect.entry.w);\n\
+        innerIntersect.exit.w = min(innerIntersect.exit.w, outerIntersect.exit.w);\n\
+        setSurfaceIntersection(ix, 0, outerIntersect.entry, true, true);  // positive, enter\n\
+        setSurfaceIntersection(ix, 1, innerIntersect.entry, false, true); // negative, enter\n\
+        setSurfaceIntersection(ix, 2, innerIntersect.exit, false, false); // negative, exit\n\
+        setSurfaceIntersection(ix, 3, outerIntersect.exit, true, false);  // positive, exit\n\
+    }\n\
 \n\
     // Bottom cone\n\
     #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF)\n\
-        vec2 bottomConeIntersection = intersectRegularCone(flippedRay, u_ellipsoidRenderLatitudeCosSqrHalfMinMax.x);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN, bottomConeIntersection);\n\
+        RayShapeIntersection bottomConeIntersection = intersectRegularCone(ray, u_ellipsoidRenderLatitudeSinMinMax.x, false);\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN, bottomConeIntersection);\n\
     #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_EQUAL_HALF)\n\
-        vec2 bottomConeIntersection = intersectZPlane(flippedRay);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN, bottomConeIntersection);\n\
+        RayShapeIntersection bottomConeIntersection = intersectZPlane(ray, -1.0);\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN, bottomConeIntersection);\n\
     #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_OVER_HALF)\n\
-        vec4 bottomConeIntersection = intersectFlippedCone(ray, u_ellipsoidRenderLatitudeCosSqrHalfMinMax.x);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN + 0, bottomConeIntersection.xy);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN + 1, bottomConeIntersection.zw);\n\
+        RayShapeIntersection bottomConeIntersections[2];\n\
+        intersectFlippedCone(ray, u_ellipsoidRenderLatitudeSinMinMax.x, bottomConeIntersections);\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN + 0, bottomConeIntersections[0]);\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN + 1, bottomConeIntersections[1]);\n\
     #endif\n\
 \n\
     // Top cone\n\
     #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_UNDER_HALF)\n\
-        vec4 topConeIntersection = intersectFlippedCone(flippedRay, u_ellipsoidRenderLatitudeCosSqrHalfMinMax.y);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX + 0, topConeIntersection.xy);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX + 1, topConeIntersection.zw);\n\
+        RayShapeIntersection topConeIntersections[2];\n\
+        intersectFlippedCone(ray, u_ellipsoidRenderLatitudeSinMinMax.y, topConeIntersections);\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX + 0, topConeIntersections[0]);\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX + 1, topConeIntersections[1]);\n\
     #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_EQUAL_HALF)\n\
-        vec2 topConeIntersection = intersectZPlane(ray);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX, topConeIntersection);\n\
+        RayShapeIntersection topConeIntersection = intersectZPlane(ray, 1.0);\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX, topConeIntersection);\n\
     #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_OVER_HALF)\n\
-        vec2 topConeIntersection = intersectRegularCone(ray, u_ellipsoidRenderLatitudeCosSqrHalfMinMax.y);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX, topConeIntersection);\n\
+        RayShapeIntersection topConeIntersection = intersectRegularCone(ray, u_ellipsoidRenderLatitudeSinMinMax.y, false);\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX, topConeIntersection);\n\
     #endif\n\
 \n\
     // Wedge\n\

package/Source/Shaders/Voxels/IntersectionUtils.glsl

@@ -4,22 +4,44 @@
 
 #define NO_HIT (-czm_infinity)
 #define INF_HIT (czm_infinity * 0.5)
-#define RAY_SHIFT (0.000003163)
-#define RAY_SCALE (1.003163)
-
-struct Ray {
-    vec3 pos;
-    vec3 dir;
-#if defined(SHAPE_BOX)
-    vec3 dInv;
-#endif
-};
 
 struct RayShapeIntersection {
     vec4 entry;
     vec4 exit;
 };
 
+vec4 intersectionMin(in vec4 intersect0, in vec4 intersect1)
+{
+    if (intersect0.w == NO_HIT) {
+        return intersect1;
+    } else if (intersect1.w == NO_HIT) {
+        return intersect0;
+    }
+    return (intersect0.w <= intersect1.w) ? intersect0 : intersect1;
+}
+
+vec4 intersectionMax(in vec4 intersect0, in vec4 intersect1)
+{
+    return (intersect0.w >= intersect1.w) ? intersect0 : intersect1;
+}
+
+RayShapeIntersection intersectIntersections(in Ray ray, in RayShapeIntersection intersect0, in RayShapeIntersection intersect1)
+{
+    bool missed = (intersect0.entry.w == NO_HIT) ||
+        (intersect1.entry.w == NO_HIT) ||
+        (intersect0.exit.w < intersect1.entry.w) ||
+        (intersect0.entry.w > intersect1.exit.w);
+    if (missed) {
+        vec4 miss = vec4(normalize(ray.dir), NO_HIT);
+        return RayShapeIntersection(miss, miss);
+    }
+
+    vec4 entry = intersectionMax(intersect0.entry, intersect1.entry);
+    vec4 exit = intersectionMin(intersect0.exit, intersect1.exit);
+
+    return RayShapeIntersection(entry, exit);
+}
+
 struct Intersections {
     // Don't access these member variables directly - call the functions instead.
 
@@ -57,7 +79,7 @@ vec4 encodeIntersectionType(vec4 intersection, int index, bool entry)
 // Use defines instead of real functions because WebGL1 cannot access array with non-constant index.
 #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*bool*/ enter) (ix).intersections[(index)] = vec4(0.0, float(!positive) * 2.0 + float(!enter) + 1.0, 0.0, (t))
 #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec4(0.0, float((index) > 0) * 2.0 + 1.0, 0.0, (entryExit).x); (ix).intersections[(index) * 2 + 1] = vec4(0.0, float((index) > 0) * 2.0 + 2.0, 0.0, (entryExit).y)
-#define setSurfaceIntersection(/*inout Intersections*/ ix, /*int*/ index, /*vec4*/ intersection) (ix).intersections[(index)] = intersection;
+#define setSurfaceIntersection(/*inout Intersections*/ ix, /*int*/ index, /*vec4*/ intersection, /*bool*/ positive, /*bool*/ enter) (ix).intersections[(index)] = encodeIntersectionType((intersection), int(!positive), (enter))
 #define setShapeIntersection(/*inout Intersections*/ ix, /*int*/ index, /*RayShapeIntersection*/ intersection) (ix).intersections[(index) * 2 + 0] = encodeIntersectionType((intersection).entry, (index), true); (ix).intersections[(index) * 2 + 1] = encodeIntersectionType((intersection).exit, (index), false)
 
 #if (INTERSECTION_COUNT > 1)

package/Source/Shaders/Voxels/IntersectionUtils.js

@@ -5,22 +5,44 @@ export default "/* Intersection defines\n\
 \n\
 #define NO_HIT (-czm_infinity)\n\
 #define INF_HIT (czm_infinity * 0.5)\n\
-#define RAY_SHIFT (0.000003163)\n\
-#define RAY_SCALE (1.003163)\n\
-\n\
-struct Ray {\n\
-    vec3 pos;\n\
-    vec3 dir;\n\
-#if defined(SHAPE_BOX)\n\
-    vec3 dInv;\n\
-#endif\n\
-};\n\
 \n\
 struct RayShapeIntersection {\n\
     vec4 entry;\n\
     vec4 exit;\n\
 };\n\
 \n\
+vec4 intersectionMin(in vec4 intersect0, in vec4 intersect1)\n\
+{\n\
+    if (intersect0.w == NO_HIT) {\n\
+        return intersect1;\n\
+    } else if (intersect1.w == NO_HIT) {\n\
+        return intersect0;\n\
+    }\n\
+    return (intersect0.w <= intersect1.w) ? intersect0 : intersect1;\n\
+}\n\
+\n\
+vec4 intersectionMax(in vec4 intersect0, in vec4 intersect1)\n\
+{\n\
+    return (intersect0.w >= intersect1.w) ? intersect0 : intersect1;\n\
+}\n\
+\n\
+RayShapeIntersection intersectIntersections(in Ray ray, in RayShapeIntersection intersect0, in RayShapeIntersection intersect1)\n\
+{\n\
+    bool missed = (intersect0.entry.w == NO_HIT) ||\n\
+        (intersect1.entry.w == NO_HIT) ||\n\
+        (intersect0.exit.w < intersect1.entry.w) ||\n\
+        (intersect0.entry.w > intersect1.exit.w);\n\
+    if (missed) {\n\
+        vec4 miss = vec4(normalize(ray.dir), NO_HIT);\n\
+        return RayShapeIntersection(miss, miss);\n\
+    }\n\
+\n\
+    vec4 entry = intersectionMax(intersect0.entry, intersect1.entry);\n\
+    vec4 exit = intersectionMin(intersect0.exit, intersect1.exit);\n\
+\n\
+    return RayShapeIntersection(entry, exit);\n\
+}\n\
+\n\
 struct Intersections {\n\
     // Don't access these member variables directly - call the functions instead.\n\
 \n\
@@ -58,7 +80,7 @@ vec4 encodeIntersectionType(vec4 intersection, int index, bool entry)\n\
 // Use defines instead of real functions because WebGL1 cannot access array with non-constant index.\n\
 #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*bool*/ enter) (ix).intersections[(index)] = vec4(0.0, float(!positive) * 2.0 + float(!enter) + 1.0, 0.0, (t))\n\
 #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec4(0.0, float((index) > 0) * 2.0 + 1.0, 0.0, (entryExit).x); (ix).intersections[(index) * 2 + 1] = vec4(0.0, float((index) > 0) * 2.0 + 2.0, 0.0, (entryExit).y)\n\
-#define setSurfaceIntersection(/*inout Intersections*/ ix, /*int*/ index, /*vec4*/ intersection) (ix).intersections[(index)] = intersection;\n\
+#define setSurfaceIntersection(/*inout Intersections*/ ix, /*int*/ index, /*vec4*/ intersection, /*bool*/ positive, /*bool*/ enter) (ix).intersections[(index)] = encodeIntersectionType((intersection), int(!positive), (enter))\n\
 #define setShapeIntersection(/*inout Intersections*/ ix, /*int*/ index, /*RayShapeIntersection*/ intersection) (ix).intersections[(index) * 2 + 0] = encodeIntersectionType((intersection).entry, (index), true); (ix).intersections[(index) * 2 + 1] = encodeIntersectionType((intersection).exit, (index), false)\n\
 \n\
 #if (INTERSECTION_COUNT > 1)\n\

package/Source/Shaders/Voxels/Megatexture.glsl

@@ -71,9 +71,8 @@ vec2 index1DTo2DTexcoord(int index, ivec2 dimensions, vec2 uvScale)
 */
 
 Properties getPropertiesFromMegatexture(in SampleData sampleData) {
-    vec3 tileUv = clamp(sampleData.tileUv, vec3(0.0), vec3(1.0)); // TODO is the clamp necessary?
     int tileIndex = sampleData.megatextureIndex;
-    vec3 voxelCoord = tileUv * vec3(u_dimensions);
+    vec3 voxelCoord = sampleData.tileUv * vec3(u_dimensions);
     ivec3 voxelDimensions = u_dimensions;
 
     #if defined(PADDING)

package/Source/Shaders/Voxels/Megatexture.js

@@ -72,9 +72,8 @@ vec2 index1DTo2DTexcoord(int index, ivec2 dimensions, vec2 uvScale)\n\
 */\n\
 \n\
 Properties getPropertiesFromMegatexture(in SampleData sampleData) {\n\
-    vec3 tileUv = clamp(sampleData.tileUv, vec3(0.0), vec3(1.0)); // TODO is the clamp necessary?\n\
     int tileIndex = sampleData.megatextureIndex;\n\
-    vec3 voxelCoord = tileUv * vec3(u_dimensions);\n\
+    vec3 voxelCoord = sampleData.tileUv * vec3(u_dimensions);\n\
     ivec3 voxelDimensions = u_dimensions;\n\
 \n\
     #if defined(PADDING)\n\