@cesium/engine 6.2.0 → 8.0.0

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

package/Source/Shaders/Voxels/VoxelFS.js

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

package/Source/Shaders/Voxels/convertUvToCylinder.glsl

@@ -1,10 +1,7 @@
 /* Cylinder defines (set in Scene/VoxelCylinderShape.js)
 #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
@@ -29,46 +26,31 @@
 vec3 convertUvToShapeUvSpace(in vec3 positionUv) {
     vec3 positionLocal = positionUv * 2.0 - 1.0; // [-1,+1]
 
-    // Compute radius
-    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS_FLAT)
-        float radius = 1.0;
-    #else
-        float radius = length(positionLocal.xy); // [0,1]
-        #if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS)
-            radius = radius * u_cylinderUvToShapeUvRadius.x + u_cylinderUvToShapeUvRadius.y; // x = scale, y = offset
-        #endif
+    float radius = length(positionLocal.xy); // [0,1]
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS)
+        radius = radius * u_cylinderUvToShapeUvRadius.x + u_cylinderUvToShapeUvRadius.y; // x = scale, y = offset
     #endif
 
-    // Compute height
-    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT_FLAT)
-        float height = 1.0;
-    #else
-        float height = positionUv.z; // [0,1]
-        #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)
-            height = height * u_cylinderUvToShapeUvHeight.x + u_cylinderUvToShapeUvHeight.y; // x = scale, y = offset
-        #endif
+    float height = positionUv.z; // [0,1]
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)
+        height = height * u_cylinderUvToShapeUvHeight.x + u_cylinderUvToShapeUvHeight.y; // x = scale, y = offset
     #endif
 
-    // Compute angle
-    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_RANGE_EQUAL_ZERO)
-        float angle = 1.0;
-    #else
-        float angle = (atan(positionLocal.y, positionLocal.x) + czm_pi) / czm_twoPi; // [0,1]
-        #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)
-            #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED)
-                // Comparing against u_cylinderShapeUvAngleMinMax has precision problems. u_cylinderShapeUvAngleRangeZeroMid is more conservative.
-                angle += float(angle < u_cylinderShapeUvAngleRangeZeroMid);
-            #endif
-
-            // Avoid flickering from reading voxels from both sides of the -pi/+pi discontinuity.
-            #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY)
-                angle = angle > u_cylinderShapeUvAngleRangeZeroMid ? u_cylinderShapeUvAngleMinMax.x : angle;
-            #elif defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY)
-                angle = angle < u_cylinderShapeUvAngleRangeZeroMid ? u_cylinderShapeUvAngleMinMax.y : angle;
-            #endif
+    float angle = (atan(positionLocal.y, positionLocal.x) + czm_pi) / czm_twoPi; // [0,1]
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)
+        #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED)
+            // Comparing against u_cylinderShapeUvAngleMinMax has precision problems. u_cylinderShapeUvAngleRangeZeroMid is more conservative.
+            angle += float(angle < u_cylinderShapeUvAngleRangeZeroMid);
+        #endif
 
-            angle = angle * u_cylinderUvToShapeUvAngle.x + u_cylinderUvToShapeUvAngle.y; // x = scale, y = offset
+        // Avoid flickering from reading voxels from both sides of the -pi/+pi discontinuity.
+        #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY)
+            angle = angle > u_cylinderShapeUvAngleRangeZeroMid ? u_cylinderShapeUvAngleMinMax.x : angle;
+        #elif defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY)
+            angle = angle < u_cylinderShapeUvAngleRangeZeroMid ? u_cylinderShapeUvAngleMinMax.y : angle;
         #endif
+
+        angle = angle * u_cylinderUvToShapeUvAngle.x + u_cylinderUvToShapeUvAngle.y; // x = scale, y = offset
     #endif
 
     return vec3(radius, height, angle);