@cesium/engine 0.1.0 → 1.1.0

package/Source/Shaders/Voxels/VoxelFS.js

@@ -0,0 +1,152 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// See Intersection.glsl for the definition of intersectScene\n\
+// See IntersectionUtils.glsl for the definition of nextIntersection\n\
+// See convertUvToBox.glsl, convertUvToCylinder.glsl, or convertUvToEllipsoid.glsl\n\
+// for the definition of convertUvToShapeUvSpace. The appropriate function is \n\
+// selected based on the VoxelPrimitive shape type, and added to the shader in\n\
+// Scene/VoxelRenderResources.js.\n\
+// See Octree.glsl for the definitions of TraversalData, SampleData,\n\
+// traverseOctreeFromBeginning, and traverseOctreeFromExisting\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\
+\n\
+uniform mat3 u_transformDirectionViewToLocal;\n\
+uniform vec3 u_cameraPositionUv;\n\
+\n\
+#if defined(PICKING)\n\
+    uniform vec4 u_pickColor;\n\
+#endif\n\
+\n\
+#if defined(JITTER)\n\
+float hash(vec2 p)\n\
+{\n\
+    vec3 p3 = fract(vec3(p.xyx) * 50.0); // magic number = hashscale\n\
+    p3 += dot(p3, p3.yzx + 19.19);\n\
+    return fract((p3.x + p3.y) * p3.z);\n\
+}\n\
+#endif\n\
+\n\
+void main()\n\
+{\n\
+    vec4 fragCoord = gl_FragCoord;\n\
+    vec2 screenCoord = (fragCoord.xy - czm_viewport.xy) / czm_viewport.zw; // [0,1]\n\
+    vec3 eyeDirection = normalize(czm_windowToEyeCoordinates(fragCoord).xyz);\n\
+    vec3 viewDirWorld = normalize(czm_inverseViewRotation * eyeDirection); // normalize again just in case\n\
+    vec3 viewDirUv = normalize(u_transformDirectionViewToLocal * eyeDirection); // normalize again just in case\n\
+    vec3 viewPosUv = u_cameraPositionUv;\n\
+\n\
+    Intersections ix;\n\
+    vec2 entryExitT = intersectScene(screenCoord, viewPosUv, viewDirUv, ix);\n\
+\n\
+    // Exit early if the scene was completely missed.\n\
+    if (entryExitT.x == NO_HIT) {\n\
+        discard;\n\
+    }\n\
+\n\
+    float currT = entryExitT.x;\n\
+    float endT = entryExitT.y;\n\
+    vec3 positionUv = viewPosUv + currT * viewDirUv;\n\
+    // TODO: is it possible for this to be out of bounds, and does it matter?\n\
+    vec3 positionUvShapeSpace = convertUvToShapeUvSpace(positionUv);\n\
+\n\
+    // Traverse the tree from the start position\n\
+    TraversalData traversalData;\n\
+    SampleData sampleDatas[SAMPLE_COUNT];\n\
+    traverseOctreeFromBeginning(positionUvShapeSpace, traversalData, sampleDatas);\n\
+\n\
+    // TODO:\n\
+    //  - jitter doesn't affect the first traversal?\n\
+    //  - jitter is always > 0?\n\
+    //  - jitter is only applied at one step?\n\
+    #if defined(JITTER)\n\
+        float noise = hash(screenCoord); // [0,1]\n\
+        currT += noise * traversalData.stepT;\n\
+        positionUv += noise * traversalData.stepT * viewDirUv;\n\
+    #endif\n\
+\n\
+    FragmentInput fragmentInput;\n\
+    #if defined(STATISTICS)\n\
+        setStatistics(fragmentInput.metadata.statistics);\n\
+    #endif\n\
+\n\
+    vec4 colorAccum =vec4(0.0);\n\
+\n\
+    for (int stepCount = 0; stepCount < STEP_COUNT_MAX; ++stepCount) {\n\
+        // Read properties from the megatexture based on the traversal state\n\
+        Properties properties = accumulatePropertiesFromMegatexture(sampleDatas);\n\
+\n\
+        // Prepare the custom shader inputs\n\
+        copyPropertiesToMetadata(properties, fragmentInput.metadata);\n\
+        fragmentInput.voxel.positionUv = positionUv;\n\
+        fragmentInput.voxel.positionShapeUv = positionUvShapeSpace;\n\
+        fragmentInput.voxel.positionUvLocal = sampleDatas[0].tileUv;\n\
+        fragmentInput.voxel.viewDirUv = viewDirUv;\n\
+        fragmentInput.voxel.viewDirWorld = viewDirWorld;\n\
+        fragmentInput.voxel.travelDistance = traversalData.stepT;\n\
+\n\
+        // Run the custom shader\n\
+        czm_modelMaterial materialOutput;\n\
+        fragmentMain(fragmentInput, materialOutput);\n\
+\n\
+        // Sanitize the custom shader output\n\
+        vec4 color = vec4(materialOutput.diffuse, materialOutput.alpha);\n\
+        color.rgb = max(color.rgb, vec3(0.0));\n\
+        color.a = clamp(color.a, 0.0, 1.0);\n\
+\n\
+        // Pre-multiplied alpha blend\n\
+        colorAccum += (1.0 - colorAccum.a) * vec4(color.rgb * color.a, color.a);\n\
+\n\
+        // Stop traversing if the alpha has been fully saturated\n\
+        if (colorAccum.a > ALPHA_ACCUM_MAX) {\n\
+            colorAccum.a = ALPHA_ACCUM_MAX;\n\
+            break;\n\
+        }\n\
+\n\
+        if (traversalData.stepT == 0.0) {\n\
+            // Shape is infinitely thin, no need to traverse further\n\
+            break;\n\
+        }\n\
+\n\
+        // Keep raymarching\n\
+        currT += traversalData.stepT;\n\
+        positionUv += traversalData.stepT * viewDirUv;\n\
+\n\
+        // Check if there's more intersections.\n\
+        if (currT > endT) {\n\
+            #if (INTERSECTION_COUNT == 1)\n\
+                break;\n\
+            #else\n\
+                vec2 entryExitT = nextIntersection(ix);\n\
+                if (entryExitT.x == NO_HIT) {\n\
+                    break;\n\
+                } else {\n\
+                    // Found another intersection. Resume raymarching there\n\
+                    currT = entryExitT.x;\n\
+                    endT = entryExitT.y;\n\
+                    positionUv = viewPosUv + currT * viewDirUv;\n\
+                }\n\
+            #endif\n\
+        }\n\
+\n\
+        // Traverse the tree from the current ray position.\n\
+        // This is similar to traverseOctree but is faster when the ray is in the same tile as the previous step.\n\
+        positionUvShapeSpace = convertUvToShapeUvSpace(positionUv);\n\
+        traverseOctreeFromExisting(positionUvShapeSpace, traversalData, sampleDatas);\n\
+    }\n\
+\n\
+    // Convert the alpha from [0,ALPHA_ACCUM_MAX] to [0,1]\n\
+    colorAccum.a /= ALPHA_ACCUM_MAX;\n\
+\n\
+    #if defined(PICKING)\n\
+        // If alpha is 0.0 there is nothing to pick\n\
+        if (colorAccum.a == 0.0) {\n\
+            discard;\n\
+        }\n\
+        gl_FragColor = u_pickColor;\n\
+    #else\n\
+        gl_FragColor = colorAccum;\n\
+    #endif\n\
+}\n\
+";

package/Source/Shaders/Voxels/VoxelVS.glsl

@@ -0,0 +1,11 @@
+attribute vec2 position;
+
+uniform vec4 u_ndcSpaceAxisAlignedBoundingBox;
+
+void main() {
+    vec2 aabbMin = u_ndcSpaceAxisAlignedBoundingBox.xy;
+    vec2 aabbMax = u_ndcSpaceAxisAlignedBoundingBox.zw;
+    vec2 translation = 0.5 * (aabbMax + aabbMin);
+    vec2 scale = 0.5 * (aabbMax - aabbMin);
+    gl_Position = vec4(position * scale + translation, 0.0, 1.0);
+}

package/Source/Shaders/Voxels/VoxelVS.js

@@ -0,0 +1,13 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "attribute vec2 position;\n\
+\n\
+uniform vec4 u_ndcSpaceAxisAlignedBoundingBox;\n\
+\n\
+void main() {\n\
+    vec2 aabbMin = u_ndcSpaceAxisAlignedBoundingBox.xy;\n\
+    vec2 aabbMax = u_ndcSpaceAxisAlignedBoundingBox.zw;\n\
+    vec2 translation = 0.5 * (aabbMax + aabbMin);\n\
+    vec2 scale = 0.5 * (aabbMax - aabbMin);\n\
+    gl_Position = vec4(position * scale + translation, 0.0, 1.0);\n\
+}\n\
+";

package/Source/Shaders/Voxels/convertUvToBox.glsl

@@ -0,0 +1,16 @@
+/* Box defines (set in Scene/VoxelBoxShape.js)
+#define BOX_HAS_SHAPE_BOUNDS
+*/
+
+#if defined(BOX_HAS_SHAPE_BOUNDS)
+    uniform vec3 u_boxUvToShapeUvScale;
+    uniform vec3 u_boxUvToShapeUvTranslate;
+#endif
+
+vec3 convertUvToShapeUvSpace(in vec3 positionUv) {
+    #if defined(BOX_HAS_SHAPE_BOUNDS)
+        return positionUv * u_boxUvToShapeUvScale + u_boxUvToShapeUvTranslate;
+    #else
+        return positionUv;
+    #endif
+}

package/Source/Shaders/Voxels/convertUvToBox.js

@@ -0,0 +1,18 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/* Box defines (set in Scene/VoxelBoxShape.js)\n\
+#define BOX_HAS_SHAPE_BOUNDS\n\
+*/\n\
+\n\
+#if defined(BOX_HAS_SHAPE_BOUNDS)\n\
+    uniform vec3 u_boxUvToShapeUvScale;\n\
+    uniform vec3 u_boxUvToShapeUvTranslate;\n\
+#endif\n\
+\n\
+vec3 convertUvToShapeUvSpace(in vec3 positionUv) {\n\
+    #if defined(BOX_HAS_SHAPE_BOUNDS)\n\
+        return positionUv * u_boxUvToShapeUvScale + u_boxUvToShapeUvTranslate;\n\
+    #else\n\
+        return positionUv;\n\
+    #endif\n\
+}\n\
+";

package/Source/Shaders/Voxels/convertUvToCylinder.glsl

@@ -0,0 +1,79 @@
+/* Cylinder defines (set in Scene/VoxelCylinderShape.js)
+#define CYLINDER_HAS_RENDER_BOUNDS_RADIUS_FLAT
+#define CYLINDER_HAS_RENDER_BOUNDS_HEIGHT_FLAT
+#define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_ZERO
+
+#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
+*/
+
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS)
+    uniform vec2 u_cylinderUvToShapeUvRadius; // x = scale, y = offset
+#endif
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)
+    uniform vec2 u_cylinderUvToShapeUvHeight; // x = scale, y = offset
+#endif
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)
+    uniform vec2 u_cylinderUvToShapeUvAngle; // x = scale, y = offset
+#endif
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY) || defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY)
+    uniform vec2 u_cylinderShapeUvAngleMinMax;
+#endif
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY) || defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY) || defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED)
+    uniform float u_cylinderShapeUvAngleRangeZeroMid;
+#endif
+
+vec3 convertUvToShapeUvSpace(in vec3 positionUv) {
+    vec3 positionLocal = positionUv * 2.0 - 1.0; // [-1,+1]
+
+    // Compute radius
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS_FLAT) || defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_FLAT)
+        float radius = length(positionLocal.xy); // [0,1]
+    #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
+    #endif
+
+    // Compute height
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT_FLAT) || defined(CYLINDER_HAS_RENDER_BOUNDS_HEIGHT_FLAT)
+        float height = positionUv.z; // [0,1]
+    #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
+    #endif
+
+    // Compute angle
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_RANGE_EQUAL_ZERO) || defined(CYLINDER_HAS_RENDER_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
+
+            angle = angle * u_cylinderUvToShapeUvAngle.x + u_cylinderUvToShapeUvAngle.y; // x = scale, y = offset
+        #endif
+    #endif
+
+    return vec3(radius, height, angle);
+}

package/Source/Shaders/Voxels/convertUvToCylinder.js

@@ -0,0 +1,81 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/* Cylinder defines (set in Scene/VoxelCylinderShape.js)\n\
+#define CYLINDER_HAS_RENDER_BOUNDS_RADIUS_FLAT\n\
+#define CYLINDER_HAS_RENDER_BOUNDS_HEIGHT_FLAT\n\
+#define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_ZERO\n\
+\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\
+*/\n\
+\n\
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS)\n\
+    uniform vec2 u_cylinderUvToShapeUvRadius; // x = scale, y = offset\n\
+#endif\n\
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)\n\
+    uniform vec2 u_cylinderUvToShapeUvHeight; // x = scale, y = offset\n\
+#endif\n\
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)\n\
+    uniform vec2 u_cylinderUvToShapeUvAngle; // x = scale, y = offset\n\
+#endif\n\
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY) || defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY)\n\
+    uniform vec2 u_cylinderShapeUvAngleMinMax;\n\
+#endif\n\
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY) || defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY) || defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED)\n\
+    uniform float u_cylinderShapeUvAngleRangeZeroMid;\n\
+#endif\n\
+\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) || defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_FLAT)\n\
+        float radius = length(positionLocal.xy); // [0,1]\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\
+    #endif\n\
+\n\
+    // Compute height\n\
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT_FLAT) || defined(CYLINDER_HAS_RENDER_BOUNDS_HEIGHT_FLAT)\n\
+        float height = positionUv.z; // [0,1]\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\
+    #endif\n\
+\n\
+    // Compute angle\n\
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_RANGE_EQUAL_ZERO) || defined(CYLINDER_HAS_RENDER_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\
+\n\
+            angle = angle * u_cylinderUvToShapeUvAngle.x + u_cylinderUvToShapeUvAngle.y; // x = scale, y = offset\n\
+        #endif\n\
+    #endif\n\
+\n\
+    return vec3(radius, height, angle);\n\
+}\n\
+";

package/Source/Shaders/Voxels/convertUvToEllipsoid.glsl

@@ -0,0 +1,133 @@
+/* Ellipsoid defines (set in Scene/VoxelEllipsoidShape.js)
+#define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO
+#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_RENDER_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO
+#define ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE
+#define ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO
+#define ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_FLAT
+#define ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_MIN
+#define ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT
+#define ELLIPSOID_IS_SPHERE
+*/
+
+uniform vec3 u_ellipsoidRadiiUv; // [0,1]
+#if !defined(ELLIPSOID_IS_SPHERE)
+    uniform vec3 u_ellipsoidInverseRadiiSquaredUv;
+#endif
+#if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MIN_DISCONTINUITY) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MAX_DISCONTINUITY) || defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_MIN_MAX_REVERSED)
+    uniform vec3 u_ellipsoidShapeUvLongitudeMinMaxMid;
+#endif
+#if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE)
+    uniform vec2 u_ellipsoidUvToShapeUvLongitude; // x = scale, y = offset
+#endif
+#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)
+    uniform float u_ellipsoidInverseHeightDifferenceUv;
+    uniform vec2 u_ellipseInnerRadiiUv; // [0,1]
+#endif
+
+// robust iterative solution without trig functions
+// https://github.com/0xfaded/ellipse_demo/issues/1
+// https://stackoverflow.com/questions/22959698/distance-from-given-point-to-given-ellipse
+// Pro: Good when radii.x ~= radii.y
+// Con: Breaks at pos.x ~= 0.0, especially inside the ellipse
+// Con: Inaccurate with exterior points and thin ellipses
+float ellipseDistanceIterative (vec2 pos, vec2 radii) {
+    vec2 p = abs(pos);
+    vec2 invRadii = 1.0 / radii;
+    vec2 a = vec2(1.0, -1.0) * (radii.x * radii.x - radii.y * radii.y) * invRadii;
+    vec2 t = vec2(0.70710678118); // sqrt(2) / 2
+    vec2 v = radii * t;
+
+    const int iterations = 3;
+    for (int i = 0; i < iterations; ++i) {
+        vec2 e = a * pow(t, vec2(3.0));
+        vec2 q = normalize(p - e) * length(v - e);
+        t = normalize((q + e) * invRadii);
+        v = radii * t;
+    }
+    return length(v * sign(pos) - pos) * sign(p.y - v.y);
+}
+
+vec3 convertUvToShapeUvSpace(in vec3 positionUv) {
+    // Compute position and normal.
+    // Convert positionUv [0,1] to local space [-1,+1] to "normalized" cartesian space [-a,+a] where a = (radii + height) / (max(radii) + height).
+    // A point on the largest ellipsoid axis would be [-1,+1] and everything else would be smaller.
+    vec3 positionLocal = positionUv * 2.0 - 1.0;
+    #if defined(ELLIPSOID_IS_SPHERE)
+        vec3 posEllipsoid = positionLocal * u_ellipsoidRadiiUv.x;
+        vec3 normal = normalize(posEllipsoid);
+    #else
+        vec3 posEllipsoid = positionLocal * u_ellipsoidRadiiUv;
+        vec3 normal = normalize(posEllipsoid * u_ellipsoidInverseRadiiSquaredUv); // geodetic surface normal
+    #endif
+
+    // Compute longitude
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO)
+        float longitude = 1.0;
+    #else
+        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
+
+        // 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
+    #endif
+
+    // Compute latitude
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO) || defined(ELLIPSOID_HAS_RENDER_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
+    #endif
+
+    // Compute height
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_FLAT)
+        // TODO: This breaks down when minBounds == maxBounds. To fix it, this
+        // function would have to know if ray is intersecting the front or back of the shape
+        // and set the shape space position to 1 (front) or 0 (back) accordingly.
+        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
+        #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
+        #endif
+    #endif
+
+    return vec3(longitude, latitude, height);
+}

package/Source/Shaders/Voxels/convertUvToEllipsoid.js

@@ -0,0 +1,135 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/* Ellipsoid defines (set in Scene/VoxelEllipsoidShape.js)\n\
+#define ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO\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_RENDER_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO\n\
+#define ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE\n\
+#define ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO\n\
+#define ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_FLAT\n\
+#define ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_MIN\n\
+#define ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT\n\
+#define ELLIPSOID_IS_SPHERE\n\
+*/\n\
+\n\
+uniform vec3 u_ellipsoidRadiiUv; // [0,1]\n\
+#if !defined(ELLIPSOID_IS_SPHERE)\n\
+    uniform vec3 u_ellipsoidInverseRadiiSquaredUv;\n\
+#endif\n\
+#if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MIN_DISCONTINUITY) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MAX_DISCONTINUITY) || defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_MIN_MAX_REVERSED)\n\
+    uniform vec3 u_ellipsoidShapeUvLongitudeMinMaxMid;\n\
+#endif\n\
+#if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE)\n\
+    uniform vec2 u_ellipsoidUvToShapeUvLongitude; // x = scale, y = offset\n\
+#endif\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\
+    uniform float u_ellipsoidInverseHeightDifferenceUv;\n\
+    uniform vec2 u_ellipseInnerRadiiUv; // [0,1]\n\
+#endif\n\
+\n\
+// robust iterative solution without trig functions\n\
+// https://github.com/0xfaded/ellipse_demo/issues/1\n\
+// https://stackoverflow.com/questions/22959698/distance-from-given-point-to-given-ellipse\n\
+// Pro: Good when radii.x ~= radii.y\n\
+// Con: Breaks at pos.x ~= 0.0, especially inside the ellipse\n\
+// Con: Inaccurate with exterior points and thin ellipses\n\
+float ellipseDistanceIterative (vec2 pos, vec2 radii) {\n\
+    vec2 p = abs(pos);\n\
+    vec2 invRadii = 1.0 / radii;\n\
+    vec2 a = vec2(1.0, -1.0) * (radii.x * radii.x - radii.y * radii.y) * invRadii;\n\
+    vec2 t = vec2(0.70710678118); // sqrt(2) / 2\n\
+    vec2 v = radii * t;\n\
+\n\
+    const int iterations = 3;\n\
+    for (int i = 0; i < iterations; ++i) {\n\
+        vec2 e = a * pow(t, vec2(3.0));\n\
+        vec2 q = normalize(p - e) * length(v - e);\n\
+        t = normalize((q + e) * invRadii);\n\
+        v = radii * t;\n\
+    }\n\
+    return length(v * sign(pos) - pos) * sign(p.y - v.y);\n\
+}\n\
+\n\
+vec3 convertUvToShapeUvSpace(in vec3 positionUv) {\n\
+    // Compute position and normal.\n\
+    // Convert positionUv [0,1] to local space [-1,+1] to \"normalized\" cartesian space [-a,+a] where a = (radii + height) / (max(radii) + height).\n\
+    // A point on the largest ellipsoid axis would be [-1,+1] and everything else would be smaller.\n\
+    vec3 positionLocal = positionUv * 2.0 - 1.0;\n\
+    #if defined(ELLIPSOID_IS_SPHERE)\n\
+        vec3 posEllipsoid = positionLocal * u_ellipsoidRadiiUv.x;\n\
+        vec3 normal = normalize(posEllipsoid);\n\
+    #else\n\
+        vec3 posEllipsoid = positionLocal * u_ellipsoidRadiiUv;\n\
+        vec3 normal = normalize(posEllipsoid * u_ellipsoidInverseRadiiSquaredUv); // geodetic surface normal\n\
+    #endif\n\
+\n\
+    // Compute longitude\n\
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO) || defined(ELLIPSOID_HAS_RENDER_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\
+\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\
+\n\
+        #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE)\n\
+            longitude = longitude * u_ellipsoidUvToShapeUvLongitude.x + u_ellipsoidUvToShapeUvLongitude.y;\n\
+        #endif\n\
+    #endif\n\
+\n\
+    // Compute latitude\n\
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO) || defined(ELLIPSOID_HAS_RENDER_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\
+    #endif\n\
+\n\
+    // Compute height\n\
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_FLAT)\n\
+        // TODO: This breaks down when minBounds == maxBounds. To fix it, this\n\
+        // function would have to know if ray is intersecting the front or back of the shape\n\
+        // and set the shape space position to 1 (front) or 0 (back) accordingly.\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\
+        #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\
+        #endif\n\
+    #endif\n\
+\n\
+    return vec3(longitude, latitude, height);\n\
+}\n\
+";