@cesium/engine 7.0.0 → 8.0.0

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);

package/Source/Shaders/Voxels/convertUvToCylinder.js

@@ -1,11 +1,8 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "/* Cylinder defines (set in Scene/VoxelCylinderShape.js)\n\
 #define CYLINDER_HAS_SHAPE_BOUNDS_RADIUS\n\
-#define CYLINDER_HAS_SHAPE_BOUNDS_RADIUS_FLAT\n\
 #define CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT\n\
-#define CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT_FLAT\n\
 #define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE\n\
-#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_RANGE_EQUAL_ZERO\n\
 #define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY\n\
 #define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY\n\
 #define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED\n\
@@ -30,46 +27,31 @@ export default "/* Cylinder defines (set in Scene/VoxelCylinderShape.js)\n\
 vec3 convertUvToShapeUvSpace(in vec3 positionUv) {\n\
     vec3 positionLocal = positionUv * 2.0 - 1.0; // [-1,+1]\n\
 \n\
-    // Compute radius\n\
-    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS_FLAT)\n\
-        float radius = 1.0;\n\
-    #else\n\
-        float radius = length(positionLocal.xy); // [0,1]\n\
-        #if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS)\n\
-            radius = radius * u_cylinderUvToShapeUvRadius.x + u_cylinderUvToShapeUvRadius.y; // x = scale, y = offset\n\
-        #endif\n\
+    float radius = length(positionLocal.xy); // [0,1]\n\
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS)\n\
+        radius = radius * u_cylinderUvToShapeUvRadius.x + u_cylinderUvToShapeUvRadius.y; // x = scale, y = offset\n\
     #endif\n\
 \n\
-    // Compute height\n\
-    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT_FLAT)\n\
-        float height = 1.0;\n\
-    #else\n\
-        float height = positionUv.z; // [0,1]\n\
-        #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)\n\
-            height = height * u_cylinderUvToShapeUvHeight.x + u_cylinderUvToShapeUvHeight.y; // x = scale, y = offset\n\
-        #endif\n\
+    float height = positionUv.z; // [0,1]\n\
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)\n\
+        height = height * u_cylinderUvToShapeUvHeight.x + u_cylinderUvToShapeUvHeight.y; // x = scale, y = offset\n\
     #endif\n\
 \n\
-    // Compute angle\n\
-    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_RANGE_EQUAL_ZERO)\n\
-        float angle = 1.0;\n\
-    #else\n\
-        float angle = (atan(positionLocal.y, positionLocal.x) + czm_pi) / czm_twoPi; // [0,1]\n\
-        #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)\n\
-            #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED)\n\
-                // Comparing against u_cylinderShapeUvAngleMinMax has precision problems. u_cylinderShapeUvAngleRangeZeroMid is more conservative.\n\
-                angle += float(angle < u_cylinderShapeUvAngleRangeZeroMid);\n\
-            #endif\n\
-\n\
-            // Avoid flickering from reading voxels from both sides of the -pi/+pi discontinuity.\n\
-            #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY)\n\
-                angle = angle > u_cylinderShapeUvAngleRangeZeroMid ? u_cylinderShapeUvAngleMinMax.x : angle;\n\
-            #elif defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY)\n\
-                angle = angle < u_cylinderShapeUvAngleRangeZeroMid ? u_cylinderShapeUvAngleMinMax.y : angle;\n\
-            #endif\n\
+    float angle = (atan(positionLocal.y, positionLocal.x) + czm_pi) / czm_twoPi; // [0,1]\n\
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)\n\
+        #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED)\n\
+            // Comparing against u_cylinderShapeUvAngleMinMax has precision problems. u_cylinderShapeUvAngleRangeZeroMid is more conservative.\n\
+            angle += float(angle < u_cylinderShapeUvAngleRangeZeroMid);\n\
+        #endif\n\
 \n\
-            angle = angle * u_cylinderUvToShapeUvAngle.x + u_cylinderUvToShapeUvAngle.y; // x = scale, y = offset\n\
+        // Avoid flickering from reading voxels from both sides of the -pi/+pi discontinuity.\n\
+        #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY)\n\
+            angle = angle > u_cylinderShapeUvAngleRangeZeroMid ? u_cylinderShapeUvAngleMinMax.x : angle;\n\
+        #elif defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY)\n\
+            angle = angle < u_cylinderShapeUvAngleRangeZeroMid ? u_cylinderShapeUvAngleMinMax.y : angle;\n\
         #endif\n\
+\n\
+        angle = angle * u_cylinderUvToShapeUvAngle.x + u_cylinderUvToShapeUvAngle.y; // x = scale, y = offset\n\
     #endif\n\
 \n\
     return vec3(radius, height, angle);\n\

package/Source/Shaders/Voxels/convertUvToEllipsoid.glsl

@@ -2,11 +2,8 @@
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MIN_DISCONTINUITY
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MAX_DISCONTINUITY
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE
-#define ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_MIN_MAX_REVERSED
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE
-#define ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO
-#define ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_MIN
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT
 #define ELLIPSOID_IS_SPHERE
 */
@@ -24,7 +21,7 @@ uniform vec3 u_ellipsoidRadiiUv; // [0,1]
 #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE)
     uniform vec2 u_ellipsoidUvToShapeUvLatitude; // x = scale, y = offset
 #endif
-#if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_MIN) && !defined(ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT)
+#if !defined(ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT)
     uniform float u_ellipsoidInverseHeightDifferenceUv;
     uniform vec2 u_ellipseInnerRadiiUv; // [0,1]
 #endif
@@ -66,38 +63,30 @@ vec3 convertUvToShapeUvSpace(in vec3 positionUv) {
     #endif
 
     // Compute longitude
-    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO)
-        float longitude = 1.0;
-    #else
-        float longitude = (atan(normal.y, normal.x) + czm_pi) / czm_twoPi;
+    float longitude = (atan(normal.y, normal.x) + czm_pi) / czm_twoPi;
 
-        // Correct the angle when max < min
-        // Technically this should compare against min longitude - but it has precision problems so compare against the middle of empty space.
-        #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_MIN_MAX_REVERSED)
-            longitude += float(longitude < u_ellipsoidShapeUvLongitudeMinMaxMid.z);
-        #endif
+    // Correct the angle when max < min
+    // Technically this should compare against min longitude - but it has precision problems so compare against the middle of empty space.
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_MIN_MAX_REVERSED)
+        longitude += float(longitude < u_ellipsoidShapeUvLongitudeMinMaxMid.z);
+    #endif
 
-        // Avoid flickering from reading voxels from both sides of the -pi/+pi discontinuity.
-        #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MIN_DISCONTINUITY)
-            longitude = longitude > u_ellipsoidShapeUvLongitudeMinMaxMid.z ? u_ellipsoidShapeUvLongitudeMinMaxMid.x : longitude;
-        #endif
-        #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MAX_DISCONTINUITY)
-            longitude = longitude < u_ellipsoidShapeUvLongitudeMinMaxMid.z ? u_ellipsoidShapeUvLongitudeMinMaxMid.y : longitude;
-        #endif
+    // Avoid flickering from reading voxels from both sides of the -pi/+pi discontinuity.
+    #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MIN_DISCONTINUITY)
+        longitude = longitude > u_ellipsoidShapeUvLongitudeMinMaxMid.z ? u_ellipsoidShapeUvLongitudeMinMaxMid.x : longitude;
+    #endif
+    #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MAX_DISCONTINUITY)
+        longitude = longitude < u_ellipsoidShapeUvLongitudeMinMaxMid.z ? u_ellipsoidShapeUvLongitudeMinMaxMid.y : longitude;
+    #endif
 
-        #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE)
-            longitude = longitude * u_ellipsoidUvToShapeUvLongitude.x + u_ellipsoidUvToShapeUvLongitude.y;
-        #endif
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE)
+        longitude = longitude * u_ellipsoidUvToShapeUvLongitude.x + u_ellipsoidUvToShapeUvLongitude.y;
     #endif
 
     // Compute latitude
-    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO)
-        float latitude = 1.0;
-    #else
-        float latitude = (asin(normal.z) + czm_piOverTwo) / czm_pi;
-        #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE)
-            latitude = latitude * u_ellipsoidUvToShapeUvLatitude.x + u_ellipsoidUvToShapeUvLatitude.y;
-        #endif
+    float latitude = (asin(normal.z) + czm_piOverTwo) / czm_pi;
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE)
+        latitude = latitude * u_ellipsoidUvToShapeUvLatitude.x + u_ellipsoidUvToShapeUvLatitude.y;
     #endif
 
     // Compute height
@@ -108,21 +97,12 @@ vec3 convertUvToShapeUvSpace(in vec3 positionUv) {
         float height = 1.0;
     #else
         #if defined(ELLIPSOID_IS_SPHERE)
-            #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_MIN)
-                float height = (length(posEllipsoid) - u_ellipseInnerRadiiUv.x) * u_ellipsoidInverseHeightDifferenceUv;
-            #else
-                float height = length(posEllipsoid);
-            #endif
+            float height = (length(posEllipsoid) - u_ellipseInnerRadiiUv.x) * u_ellipsoidInverseHeightDifferenceUv;
         #else
-            #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_MIN)
-                // Convert the 3D position to a 2D position relative to the ellipse (radii.x, radii.z) (assuming radii.x == radii.y which is true for WGS84).
-                // This is an optimization so that math can be done with ellipses instead of ellipsoids.
-                vec2 posEllipse = vec2(length(posEllipsoid.xy), posEllipsoid.z);
-                float height = ellipseDistanceIterative(posEllipse, u_ellipseInnerRadiiUv) * u_ellipsoidInverseHeightDifferenceUv;
-            #else
-                // TODO: this is probably not correct
-                float height = length(posEllipsoid);
-            #endif
+            // Convert the 3D position to a 2D position relative to the ellipse (radii.x, radii.z) (assuming radii.x == radii.y which is true for WGS84).
+            // This is an optimization so that math can be done with ellipses instead of ellipsoids.
+            vec2 posEllipse = vec2(length(posEllipsoid.xy), posEllipsoid.z);
+            float height = ellipseDistanceIterative(posEllipse, u_ellipseInnerRadiiUv) * u_ellipsoidInverseHeightDifferenceUv;
         #endif
     #endif
 

package/Source/Shaders/Voxels/convertUvToEllipsoid.js

@@ -3,11 +3,8 @@ export default "/* Ellipsoid defines (set in Scene/VoxelEllipsoidShape.js)\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MIN_DISCONTINUITY\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MAX_DISCONTINUITY\n\
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE\n\
-#define ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO\n\
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_MIN_MAX_REVERSED\n\
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE\n\
-#define ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO\n\
-#define ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_MIN\n\
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT\n\
 #define ELLIPSOID_IS_SPHERE\n\
 */\n\
@@ -25,7 +22,7 @@ uniform vec3 u_ellipsoidRadiiUv; // [0,1]\n\
 #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE)\n\
     uniform vec2 u_ellipsoidUvToShapeUvLatitude; // x = scale, y = offset\n\
 #endif\n\
-#if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_MIN) && !defined(ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT)\n\
+#if !defined(ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT)\n\
     uniform float u_ellipsoidInverseHeightDifferenceUv;\n\
     uniform vec2 u_ellipseInnerRadiiUv; // [0,1]\n\
 #endif\n\
@@ -67,38 +64,30 @@ vec3 convertUvToShapeUvSpace(in vec3 positionUv) {\n\
     #endif\n\
 \n\
     // Compute longitude\n\
-    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO)\n\
-        float longitude = 1.0;\n\
-    #else\n\
-        float longitude = (atan(normal.y, normal.x) + czm_pi) / czm_twoPi;\n\
+    float longitude = (atan(normal.y, normal.x) + czm_pi) / czm_twoPi;\n\
 \n\
-        // Correct the angle when max < min\n\
-        // Technically this should compare against min longitude - but it has precision problems so compare against the middle of empty space.\n\
-        #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_MIN_MAX_REVERSED)\n\
-            longitude += float(longitude < u_ellipsoidShapeUvLongitudeMinMaxMid.z);\n\
-        #endif\n\
+    // Correct the angle when max < min\n\
+    // Technically this should compare against min longitude - but it has precision problems so compare against the middle of empty space.\n\
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_MIN_MAX_REVERSED)\n\
+        longitude += float(longitude < u_ellipsoidShapeUvLongitudeMinMaxMid.z);\n\
+    #endif\n\
 \n\
-        // Avoid flickering from reading voxels from both sides of the -pi/+pi discontinuity.\n\
-        #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MIN_DISCONTINUITY)\n\
-            longitude = longitude > u_ellipsoidShapeUvLongitudeMinMaxMid.z ? u_ellipsoidShapeUvLongitudeMinMaxMid.x : longitude;\n\
-        #endif\n\
-        #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MAX_DISCONTINUITY)\n\
-            longitude = longitude < u_ellipsoidShapeUvLongitudeMinMaxMid.z ? u_ellipsoidShapeUvLongitudeMinMaxMid.y : longitude;\n\
-        #endif\n\
+    // Avoid flickering from reading voxels from both sides of the -pi/+pi discontinuity.\n\
+    #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MIN_DISCONTINUITY)\n\
+        longitude = longitude > u_ellipsoidShapeUvLongitudeMinMaxMid.z ? u_ellipsoidShapeUvLongitudeMinMaxMid.x : longitude;\n\
+    #endif\n\
+    #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MAX_DISCONTINUITY)\n\
+        longitude = longitude < u_ellipsoidShapeUvLongitudeMinMaxMid.z ? u_ellipsoidShapeUvLongitudeMinMaxMid.y : longitude;\n\
+    #endif\n\
 \n\
-        #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE)\n\
-            longitude = longitude * u_ellipsoidUvToShapeUvLongitude.x + u_ellipsoidUvToShapeUvLongitude.y;\n\
-        #endif\n\
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE)\n\
+        longitude = longitude * u_ellipsoidUvToShapeUvLongitude.x + u_ellipsoidUvToShapeUvLongitude.y;\n\
     #endif\n\
 \n\
     // Compute latitude\n\
-    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO)\n\
-        float latitude = 1.0;\n\
-    #else\n\
-        float latitude = (asin(normal.z) + czm_piOverTwo) / czm_pi;\n\
-        #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE)\n\
-            latitude = latitude * u_ellipsoidUvToShapeUvLatitude.x + u_ellipsoidUvToShapeUvLatitude.y;\n\
-        #endif\n\
+    float latitude = (asin(normal.z) + czm_piOverTwo) / czm_pi;\n\
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE)\n\
+        latitude = latitude * u_ellipsoidUvToShapeUvLatitude.x + u_ellipsoidUvToShapeUvLatitude.y;\n\
     #endif\n\
 \n\
     // Compute height\n\
@@ -109,21 +98,12 @@ vec3 convertUvToShapeUvSpace(in vec3 positionUv) {\n\
         float height = 1.0;\n\
     #else\n\
         #if defined(ELLIPSOID_IS_SPHERE)\n\
-            #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_MIN)\n\
-                float height = (length(posEllipsoid) - u_ellipseInnerRadiiUv.x) * u_ellipsoidInverseHeightDifferenceUv;\n\
-            #else\n\
-                float height = length(posEllipsoid);\n\
-            #endif\n\
+            float height = (length(posEllipsoid) - u_ellipseInnerRadiiUv.x) * u_ellipsoidInverseHeightDifferenceUv;\n\
         #else\n\
-            #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_MIN)\n\
-                // Convert the 3D position to a 2D position relative to the ellipse (radii.x, radii.z) (assuming radii.x == radii.y which is true for WGS84).\n\
-                // This is an optimization so that math can be done with ellipses instead of ellipsoids.\n\
-                vec2 posEllipse = vec2(length(posEllipsoid.xy), posEllipsoid.z);\n\
-                float height = ellipseDistanceIterative(posEllipse, u_ellipseInnerRadiiUv) * u_ellipsoidInverseHeightDifferenceUv;\n\
-            #else\n\
-                // TODO: this is probably not correct\n\
-                float height = length(posEllipsoid);\n\
-            #endif\n\
+            // Convert the 3D position to a 2D position relative to the ellipse (radii.x, radii.z) (assuming radii.x == radii.y which is true for WGS84).\n\
+            // This is an optimization so that math can be done with ellipses instead of ellipsoids.\n\
+            vec2 posEllipse = vec2(length(posEllipsoid.xy), posEllipsoid.z);\n\
+            float height = ellipseDistanceIterative(posEllipse, u_ellipseInnerRadiiUv) * u_ellipsoidInverseHeightDifferenceUv;\n\
         #endif\n\
     #endif\n\
 \n\

package/Source/Workers/createGeometry.js

@@ -1,23 +1,46 @@
+import DeveloperError from "../Core/DeveloperError.js";
+import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import PrimitivePipeline from "../Scene/PrimitivePipeline.js";
 import createTaskProcessorWorker from "./createTaskProcessorWorker.js";
+/* global require */
 
 const moduleCache = {};
 
-async function getModule(moduleName) {
-  let module = moduleCache[moduleName];
-  if (!defined(module)) {
+async function getModule(moduleName, modulePath) {
+  let module = defaultValue(moduleCache[modulePath] ?? moduleCache[moduleName]);
+
+  if (defined(module)) {
+    return module;
+  }
+
+  if (defined(modulePath)) {
+    // ignore moduleName and use the path to import
     if (typeof exports === "object") {
       // Use CommonJS-style require.
-      /* global require */
-      moduleCache[module] = module = require(`Workers/${moduleName}`);
+      module = require(modulePath);
     } else {
       // Use ESM-style dynamic import
-      const result = await import(`./${moduleName}.js`);
+      const result = await import(modulePath);
       module = result.default;
-      moduleCache[module] = module;
     }
+
+    moduleCache[modulePath] = module;
+    return module;
   }
+
+  if (typeof exports === "object") {
+    // Use CommonJS-style require.
+    module = require(`Workers/${moduleName}`);
+  } else {
+    // Use ESM-style dynamic import
+    const result = defined(modulePath)
+      ? await import(modulePath)
+      : await import(`./${moduleName}.js`);
+    module = result.default;
+  }
+
+  moduleCache[moduleName] = module;
   return module;
 }
 
@@ -30,11 +53,17 @@ async function createGeometry(parameters, transferableObjects) {
     const task = subTasks[i];
     const geometry = task.geometry;
     const moduleName = task.moduleName;
+    const modulePath = task.modulePath;
+
+    if (defined(moduleName) && defined(modulePath)) {
+      throw new DeveloperError("Must only set moduleName or modulePath");
+    }
 
-    if (defined(moduleName)) {
-      resultsOrPromises[i] = getModule(moduleName).then((createFunction) =>
-        createFunction(geometry, task.offset)
-      );
+    if (defined(moduleName) || defined(modulePath)) {
+      resultsOrPromises[i] = getModule(
+        moduleName,
+        modulePath
+      ).then((createFunction) => createFunction(geometry, task.offset));
     } else {
       // Already created geometry
       resultsOrPromises[i] = geometry;