@cesium/engine 7.0.0 → 8.0.0

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
 }

package/Source/Shaders/Voxels/IntersectEllipsoid.js

@@ -1,14 +1,14 @@
 //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\
+// See IntersectLongitude.glsl for the definitions of intersectHalfPlane,\n\
+// intersectFlippedWedge, intersectRegularWedge\n\
 \n\
 /* Ellipsoid defines (set in Scene/VoxelEllipsoidShape.js)\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_UNDER_HALF\n\
-#define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_EQUAL_HALF\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_OVER_HALF\n\
-#define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_UNDER_HALF\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_EQUAL_HALF\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_OVER_HALF\n\
@@ -17,7 +17,6 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, Inters
 #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_HAS_RENDER_BOUNDS_HEIGHT_FLAT\n\
 #define ELLIPSOID_INTERSECTION_INDEX_LONGITUDE\n\
 #define ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX\n\
 #define ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN\n\
@@ -49,78 +48,6 @@ vec2 intersectZPlane(Ray ray)\n\
     else return vec2(-INF_HIT, t);\n\
 }\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\
-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\
-    if (t >= 0.0 != s >= 0.0) return vec2(t, +INF_HIT);\n\
-    else return vec2(-INF_HIT, t);\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 intersectUnitSphere(Ray ray)\n\
 {\n\
     vec3 o = ray.pos;\n\
@@ -251,39 +178,32 @@ void intersectShape(in Ray ray, inout Intersections ix) {\n\
     }\n\
 \n\
     // Inner ellipsoid\n\
-    #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_FLAT)\n\
-        // When the ellipsoid is perfectly thin it's necessary to sandwich the\n\
-        // 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\
-        setIntersection(ix, 0, outerIntersect.x, true, true);   // positive, enter\n\
-        setIntersection(ix, 1, outerIntersect.x, false, true);  // negative, enter\n\
-        setIntersection(ix, 2, outerIntersect.y, false, false); // negative, exit\n\
-        setIntersection(ix, 3, outerIntersect.y, true, false);  // positive, exit\n\
-    #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN)\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 very large and thin it's possible for floating\n\
-            // point math to cause the ray to intersect the inner ellipsoid before\n\
-            // the outer ellipsoid. To prevent this from happening, clamp innerIntersect\n\
-            // to outerIntersect and sandwhich the intersections like described above.\n\
-            //\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\
@@ -331,19 +251,18 @@ void intersectShape(in Ray ray, inout Intersections ix) {\n\
 \n\
     // Wedge\n\
     #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO)\n\
-        vec4 wedgeIntersect = intersectHalfPlane(ray, u_ellipsoidRenderLongitudeMinMax.x);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 0, wedgeIntersect.xy);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 1, wedgeIntersect.zw);\n\
+        RayShapeIntersection wedgeIntersects[2];\n\
+        intersectHalfPlane(ray, u_ellipsoidRenderLongitudeMinMax.x, wedgeIntersects);\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 0, wedgeIntersects[0]);\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 1, wedgeIntersects[1]);\n\
     #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_UNDER_HALF)\n\
-        vec2 wedgeIntersect = intersectRegularWedge(ray, u_ellipsoidRenderLongitudeMinMax.x, u_ellipsoidRenderLongitudeMinMax.y);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE, wedgeIntersect);\n\
-    #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_EQUAL_HALF)\n\
-        vec2 wedgeIntersect = intersectHalfSpace(ray, u_ellipsoidRenderLongitudeMinMax.x);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE, wedgeIntersect);\n\
+        RayShapeIntersection wedgeIntersect = intersectRegularWedge(ray, u_ellipsoidRenderLongitudeMinMax);\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE, wedgeIntersect);\n\
     #elif defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_OVER_HALF)\n\
-        vec4 wedgeIntersect = intersectFlippedWedge(ray, u_ellipsoidRenderLongitudeMinMax.x, u_ellipsoidRenderLongitudeMinMax.y);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 0, wedgeIntersect.xy);\n\
-        setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 1, wedgeIntersect.zw);\n\
+        RayShapeIntersection wedgeIntersects[2];\n\
+        intersectFlippedWedge(ray, u_ellipsoidRenderLongitudeMinMax, wedgeIntersects);\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 0, wedgeIntersects[0]);\n\
+        setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_LONGITUDE + 1, wedgeIntersects[1]);\n\
     #endif\n\
 }\n\
 ";

package/Source/Shaders/Voxels/IntersectLongitude.glsl

@@ -0,0 +1,102 @@
+// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT, INF_HIT,
+// RayShapeIntersection
+
+vec4 intersectLongitude(in Ray ray, in float angle, in bool positiveNormal) {
+    float normalSign = positiveNormal ? 1.0 : -1.0;
+    vec2 planeNormal = vec2(-sin(angle), cos(angle)) * normalSign;
+
+    vec2 position = ray.pos.xy;
+    vec2 direction = ray.dir.xy;
+    float approachRate = dot(direction, planeNormal);
+    float distance = -dot(position, planeNormal);
+
+    float t = (approachRate == 0.0)
+        ? NO_HIT
+        : distance / approachRate;
+
+    return vec4(planeNormal, 0.0, t);
+}
+
+RayShapeIntersection intersectHalfSpace(in Ray ray, in float angle, in bool positiveNormal)
+{
+    vec4 intersection = intersectLongitude(ray, angle, positiveNormal);
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);
+
+    bool hitFront = (intersection.w > 0.0) == (dot(ray.pos.xy, intersection.xy) > 0.0);
+    if (!hitFront) {
+        return RayShapeIntersection(intersection, farSide);
+    } else {
+        return RayShapeIntersection(-1.0 * farSide, intersection);
+    }
+}
+
+void intersectFlippedWedge(in Ray ray, in vec2 minMaxAngle, out RayShapeIntersection intersections[2])
+{
+    intersections[0] = intersectHalfSpace(ray, minMaxAngle.x, false);
+    intersections[1] = intersectHalfSpace(ray, minMaxAngle.y, true);
+}
+
+bool hitPositiveHalfPlane(in Ray ray, in vec4 intersection, in bool positiveNormal) {
+    float normalSign = positiveNormal ? 1.0 : -1.0;
+    vec2 planeDirection = vec2(intersection.y, -intersection.x) * normalSign;
+    vec2 hit = ray.pos.xy + intersection.w * ray.dir.xy;
+    return dot(hit, planeDirection) > 0.0;
+}
+
+void intersectHalfPlane(in Ray ray, in float angle, out RayShapeIntersection intersections[2]) {
+    vec4 intersection = intersectLongitude(ray, angle, true);
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);
+
+    if (hitPositiveHalfPlane(ray, intersection, true)) {
+        intersections[0].entry = -1.0 * farSide;
+        intersections[0].exit = vec4(-1.0 * intersection.xy, 0.0, intersection.w);
+        intersections[1].entry = intersection;
+        intersections[1].exit = farSide;
+    } else {
+        vec4 miss = vec4(normalize(ray.dir), NO_HIT);
+        intersections[0].entry = -1.0 * farSide;
+        intersections[0].exit = farSide;
+        intersections[1].entry = miss;
+        intersections[1].exit = miss;
+    }
+}
+
+RayShapeIntersection intersectRegularWedge(in Ray ray, in vec2 minMaxAngle)
+{
+    // Note: works for maxAngle > minAngle + pi, where the "regular wedge"
+    // is actually a negative volume.
+    // Compute intersections with the two planes.
+    // Normals will point toward the "outside" (negative space)
+    vec4 intersect1 = intersectLongitude(ray, minMaxAngle.x, false);
+    vec4 intersect2 = intersectLongitude(ray, minMaxAngle.y, true);
+
+    // Choose intersection with smallest T as the "first", the other as "last"
+    // Note: first or last could be in the "shadow" wedge, beyond the tip
+    bool inOrder = intersect1.w <= intersect2.w;
+    vec4 first = inOrder ? intersect1 : intersect2;
+    vec4 last = inOrder ? intersect2 : intersect1;
+
+    bool firstIsAhead = first.w >= 0.0;
+    bool startedInsideFirst = dot(ray.pos.xy, first.xy) < 0.0;
+    bool exitFromInside = firstIsAhead == startedInsideFirst;
+    bool lastIsAhead = last.w > 0.0;
+    bool startedOutsideLast = dot(ray.pos.xy, last.xy) >= 0.0;
+    bool enterFromOutside = lastIsAhead == startedOutsideLast;
+
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);
+    vec4 miss = vec4(normalize(ray.dir), NO_HIT);
+
+    if (exitFromInside && enterFromOutside) {
+        // Ray crosses both faces of negative wedge, exiting then entering the positive shape
+        return RayShapeIntersection(first, last);
+    } else if (!exitFromInside && enterFromOutside) {
+        // Ray starts inside wedge. last is in shadow wedge, and first is actually the entry
+        return RayShapeIntersection(-1.0 * farSide, first);
+    } else if (exitFromInside && !enterFromOutside) {
+        // First intersection was in the shadow wedge, so last is actually the exit
+        return RayShapeIntersection(last, farSide);
+    } else { // !exitFromInside && !enterFromOutside
+        // Both intersections were in the shadow wedge
+        return RayShapeIntersection(miss, miss);
+    }
+}

package/Source/Shaders/Voxels/IntersectLongitude.js

@@ -0,0 +1,104 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT, INF_HIT,\n\
+// RayShapeIntersection\n\
+\n\
+vec4 intersectLongitude(in Ray ray, in float angle, in bool positiveNormal) {\n\
+    float normalSign = positiveNormal ? 1.0 : -1.0;\n\
+    vec2 planeNormal = vec2(-sin(angle), cos(angle)) * normalSign;\n\
+\n\
+    vec2 position = ray.pos.xy;\n\
+    vec2 direction = ray.dir.xy;\n\
+    float approachRate = dot(direction, planeNormal);\n\
+    float distance = -dot(position, planeNormal);\n\
+\n\
+    float t = (approachRate == 0.0)\n\
+        ? NO_HIT\n\
+        : distance / approachRate;\n\
+\n\
+    return vec4(planeNormal, 0.0, t);\n\
+}\n\
+\n\
+RayShapeIntersection intersectHalfSpace(in Ray ray, in float angle, in bool positiveNormal)\n\
+{\n\
+    vec4 intersection = intersectLongitude(ray, angle, positiveNormal);\n\
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);\n\
+\n\
+    bool hitFront = (intersection.w > 0.0) == (dot(ray.pos.xy, intersection.xy) > 0.0);\n\
+    if (!hitFront) {\n\
+        return RayShapeIntersection(intersection, farSide);\n\
+    } else {\n\
+        return RayShapeIntersection(-1.0 * farSide, intersection);\n\
+    }\n\
+}\n\
+\n\
+void intersectFlippedWedge(in Ray ray, in vec2 minMaxAngle, out RayShapeIntersection intersections[2])\n\
+{\n\
+    intersections[0] = intersectHalfSpace(ray, minMaxAngle.x, false);\n\
+    intersections[1] = intersectHalfSpace(ray, minMaxAngle.y, true);\n\
+}\n\
+\n\
+bool hitPositiveHalfPlane(in Ray ray, in vec4 intersection, in bool positiveNormal) {\n\
+    float normalSign = positiveNormal ? 1.0 : -1.0;\n\
+    vec2 planeDirection = vec2(intersection.y, -intersection.x) * normalSign;\n\
+    vec2 hit = ray.pos.xy + intersection.w * ray.dir.xy;\n\
+    return dot(hit, planeDirection) > 0.0;\n\
+}\n\
+\n\
+void intersectHalfPlane(in Ray ray, in float angle, out RayShapeIntersection intersections[2]) {\n\
+    vec4 intersection = intersectLongitude(ray, angle, true);\n\
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);\n\
+\n\
+    if (hitPositiveHalfPlane(ray, intersection, true)) {\n\
+        intersections[0].entry = -1.0 * farSide;\n\
+        intersections[0].exit = vec4(-1.0 * intersection.xy, 0.0, intersection.w);\n\
+        intersections[1].entry = intersection;\n\
+        intersections[1].exit = farSide;\n\
+    } else {\n\
+        vec4 miss = vec4(normalize(ray.dir), NO_HIT);\n\
+        intersections[0].entry = -1.0 * farSide;\n\
+        intersections[0].exit = farSide;\n\
+        intersections[1].entry = miss;\n\
+        intersections[1].exit = miss;\n\
+    }\n\
+}\n\
+\n\
+RayShapeIntersection intersectRegularWedge(in Ray ray, in vec2 minMaxAngle)\n\
+{\n\
+    // Note: works for maxAngle > minAngle + pi, where the \"regular wedge\"\n\
+    // is actually a negative volume.\n\
+    // Compute intersections with the two planes.\n\
+    // Normals will point toward the \"outside\" (negative space)\n\
+    vec4 intersect1 = intersectLongitude(ray, minMaxAngle.x, false);\n\
+    vec4 intersect2 = intersectLongitude(ray, minMaxAngle.y, true);\n\
+\n\
+    // Choose intersection with smallest T as the \"first\", the other as \"last\"\n\
+    // Note: first or last could be in the \"shadow\" wedge, beyond the tip\n\
+    bool inOrder = intersect1.w <= intersect2.w;\n\
+    vec4 first = inOrder ? intersect1 : intersect2;\n\
+    vec4 last = inOrder ? intersect2 : intersect1;\n\
+\n\
+    bool firstIsAhead = first.w >= 0.0;\n\
+    bool startedInsideFirst = dot(ray.pos.xy, first.xy) < 0.0;\n\
+    bool exitFromInside = firstIsAhead == startedInsideFirst;\n\
+    bool lastIsAhead = last.w > 0.0;\n\
+    bool startedOutsideLast = dot(ray.pos.xy, last.xy) >= 0.0;\n\
+    bool enterFromOutside = lastIsAhead == startedOutsideLast;\n\
+\n\
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);\n\
+    vec4 miss = vec4(normalize(ray.dir), NO_HIT);\n\
+\n\
+    if (exitFromInside && enterFromOutside) {\n\
+        // Ray crosses both faces of negative wedge, exiting then entering the positive shape\n\
+        return RayShapeIntersection(first, last);\n\
+    } else if (!exitFromInside && enterFromOutside) {\n\
+        // Ray starts inside wedge. last is in shadow wedge, and first is actually the entry\n\
+        return RayShapeIntersection(-1.0 * farSide, first);\n\
+    } else if (exitFromInside && !enterFromOutside) {\n\
+        // First intersection was in the shadow wedge, so last is actually the exit\n\
+        return RayShapeIntersection(last, farSide);\n\
+    } else { // !exitFromInside && !enterFromOutside\n\
+        // Both intersections were in the shadow wedge\n\
+        return RayShapeIntersection(miss, miss);\n\
+    }\n\
+}\n\
+";

package/Source/Shaders/Voxels/VoxelFS.glsl

@@ -9,7 +9,11 @@
 // See Megatexture.glsl for the definition of accumulatePropertiesFromMegatexture
 
 #define STEP_COUNT_MAX 1000 // Harcoded value because GLSL doesn't like variable length loops
-#define ALPHA_ACCUM_MAX 0.98 // Must be > 0.0 and <= 1.0
+#if defined(PICKING_VOXEL)
+    #define ALPHA_ACCUM_MAX 0.1
+#else
+    #define ALPHA_ACCUM_MAX 0.98 // Must be > 0.0 and <= 1.0
+#endif
 
 uniform mat3 u_transformDirectionViewToLocal;
 uniform vec3 u_cameraPositionUv;
@@ -42,6 +46,30 @@ vec4 getStepSize(in SampleData sampleData, in Ray viewRay, in RayShapeIntersecti
 #endif
 }
 
+vec2 packIntToVec2(int value) {
+    float shifted = float(value) / 255.0;
+    float lowBits = fract(shifted);
+    float highBits = floor(shifted) / 255.0;
+    return vec2(highBits, lowBits);
+}
+
+vec2 packFloatToVec2(float value) {
+    float lowBits = fract(value);
+    float highBits = floor(value) / 255.0;
+    return vec2(highBits, lowBits);
+}
+
+int getSampleIndex(in vec3 tileUv) {
+    ivec3 voxelDimensions = u_dimensions;
+    vec3 tileCoordinate = clamp(tileUv, 0.0, 1.0) * vec3(voxelDimensions);
+    ivec3 tileIndex = ivec3(floor(tileCoordinate));
+    #if defined(PADDING)
+        voxelDimensions += u_paddingBefore + u_paddingAfter;
+        tileIndex += u_paddingBefore;
+    #endif
+    return tileIndex.x + voxelDimensions.x * (tileIndex.y + voxelDimensions.y * tileIndex.z);
+}
+
 void main()
 {
     vec4 fragCoord = gl_FragCoord;
@@ -102,6 +130,8 @@ void main()
         fragmentInput.voxel.viewDirWorld = viewDirWorld;
         fragmentInput.voxel.surfaceNormal = step.xyz;
         fragmentInput.voxel.travelDistance = step.w;
+        fragmentInput.voxel.tileIndex = sampleDatas[0].megatextureIndex;
+        fragmentInput.voxel.sampleIndex = getSampleIndex(sampleDatas[0].tileUv);
 
         // Run the custom shader
         czm_modelMaterial materialOutput;
@@ -164,6 +194,14 @@ void main()
             discard;
         }
         out_FragColor = u_pickColor;
+    #elif defined(PICKING_VOXEL)
+        // If alpha is 0.0 there is nothing to pick
+        if (colorAccum.a == 0.0) {
+            discard;
+        }
+        vec2 megatextureId = packIntToVec2(sampleDatas[0].megatextureIndex);
+        vec2 sampleIndex = packIntToVec2(getSampleIndex(sampleDatas[0].tileUv));
+        out_FragColor = vec4(megatextureId, sampleIndex);
     #else
         out_FragColor = colorAccum;
     #endif