@cesium/engine 8.0.0 → 9.1.0

package/Source/Shaders/Voxels/convertUvToBox.glsl

@@ -7,14 +7,27 @@
     uniform vec3 u_boxUvToShapeUvTranslate;
 #endif
 
-vec3 convertUvToShapeUvSpace(in vec3 positionUv) {
+PointJacobianT convertUvToShapeSpaceDerivative(in vec3 positionUv) {
+    // For BOX, UV space = shape space, so we can use positionUv as-is,
+    // and the Jacobian is the identity matrix, except that a step of 1
+    // only spans half the shape space [-1, 1], so the identity is scaled.
+    return PointJacobianT(positionUv, mat3(0.5));
+}
+
+vec3 convertShapeToShapeUvSpace(in vec3 positionShape) {
 #if defined(BOX_HAS_SHAPE_BOUNDS)
-    return positionUv * u_boxUvToShapeUvScale + u_boxUvToShapeUvTranslate;
+    return positionShape * u_boxUvToShapeUvScale + u_boxUvToShapeUvTranslate;
 #else
-    return positionUv;
+    return positionShape;
 #endif
 }
 
+PointJacobianT convertUvToShapeUvSpaceDerivative(in vec3 positionUv) {
+    PointJacobianT pointJacobian = convertUvToShapeSpaceDerivative(positionUv);
+    pointJacobian.point = convertShapeToShapeUvSpace(pointJacobian.point);
+    return pointJacobian;
+}
+
 vec3 convertShapeUvToUvSpace(in vec3 shapeUv) {
 #if defined(BOX_HAS_SHAPE_BOUNDS)
     return (shapeUv - u_boxUvToShapeUvTranslate) / u_boxUvToShapeUvScale;
@@ -22,3 +35,11 @@ vec3 convertShapeUvToUvSpace(in vec3 shapeUv) {
     return shapeUv;
 #endif
 }
+
+vec3 scaleShapeUvToShapeSpace(in vec3 shapeUv) {
+#if defined(BOX_HAS_SHAPE_BOUNDS)
+    return shapeUv / u_boxUvToShapeUvScale;
+#else
+    return shapeUv;
+#endif
+}

package/Source/Shaders/Voxels/convertUvToBox.js

@@ -8,14 +8,27 @@ export default "/* Box defines (set in Scene/VoxelBoxShape.js)\n\
     uniform vec3 u_boxUvToShapeUvTranslate;\n\
 #endif\n\
 \n\
-vec3 convertUvToShapeUvSpace(in vec3 positionUv) {\n\
+PointJacobianT convertUvToShapeSpaceDerivative(in vec3 positionUv) {\n\
+    // For BOX, UV space = shape space, so we can use positionUv as-is,\n\
+    // and the Jacobian is the identity matrix, except that a step of 1\n\
+    // only spans half the shape space [-1, 1], so the identity is scaled.\n\
+    return PointJacobianT(positionUv, mat3(0.5));\n\
+}\n\
+\n\
+vec3 convertShapeToShapeUvSpace(in vec3 positionShape) {\n\
 #if defined(BOX_HAS_SHAPE_BOUNDS)\n\
-    return positionUv * u_boxUvToShapeUvScale + u_boxUvToShapeUvTranslate;\n\
+    return positionShape * u_boxUvToShapeUvScale + u_boxUvToShapeUvTranslate;\n\
 #else\n\
-    return positionUv;\n\
+    return positionShape;\n\
 #endif\n\
 }\n\
 \n\
+PointJacobianT convertUvToShapeUvSpaceDerivative(in vec3 positionUv) {\n\
+    PointJacobianT pointJacobian = convertUvToShapeSpaceDerivative(positionUv);\n\
+    pointJacobian.point = convertShapeToShapeUvSpace(pointJacobian.point);\n\
+    return pointJacobian;\n\
+}\n\
+\n\
 vec3 convertShapeUvToUvSpace(in vec3 shapeUv) {\n\
 #if defined(BOX_HAS_SHAPE_BOUNDS)\n\
     return (shapeUv - u_boxUvToShapeUvTranslate) / u_boxUvToShapeUvScale;\n\
@@ -23,4 +36,11 @@ vec3 convertShapeUvToUvSpace(in vec3 shapeUv) {\n\
     return shapeUv;\n\
 #endif\n\
 }\n\
-";
+\n\
+vec3 scaleShapeUvToShapeSpace(in vec3 shapeUv) {\n\
+#if defined(BOX_HAS_SHAPE_BOUNDS)\n\
+    return shapeUv / u_boxUvToShapeUvScale;\n\
+#else\n\
+    return shapeUv;\n\
+#endif\n\
+}";

package/Source/Shaders/Voxels/convertUvToCylinder.glsl

@@ -23,20 +23,37 @@
     uniform float u_cylinderShapeUvAngleRangeZeroMid;
 #endif
 
-vec3 convertUvToShapeUvSpace(in vec3 positionUv) {
-    vec3 positionLocal = positionUv * 2.0 - 1.0; // [-1,+1]
+PointJacobianT convertUvToShapeSpaceDerivative(in vec3 positionUv) {
+    // Convert from Cartesian UV space [0, 1] to Cartesian local space [-1, 1]
+    vec3 position = positionUv * 2.0 - 1.0;
 
-    float radius = length(positionLocal.xy); // [0,1]
+    float radius = length(position.xy); // [0, 1]
+    vec3 radial = normalize(vec3(position.xy, 0.0));
+
+    // Shape space height is defined within [0, 1]
+    float height = positionUv.z; // [0, 1]
+    vec3 z = vec3(0.0, 0.0, 1.0);
+
+    float angle = atan(position.y, position.x);
+    vec3 east = normalize(vec3(-position.y, position.x, 0.0));
+
+    vec3 point = vec3(radius, height, angle);
+    mat3 jacobianT = mat3(radial, z, east / length(position.xy));
+    return PointJacobianT(point, jacobianT);
+}
+
+vec3 convertShapeToShapeUvSpace(in vec3 positionShape) {
+    float radius = positionShape.x;
     #if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS)
-        radius = radius * u_cylinderUvToShapeUvRadius.x + u_cylinderUvToShapeUvRadius.y; // x = scale, y = offset
+        radius = radius * u_cylinderUvToShapeUvRadius.x + u_cylinderUvToShapeUvRadius.y;
     #endif
 
-    float height = positionUv.z; // [0,1]
+    float height = positionShape.y;
     #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)
-        height = height * u_cylinderUvToShapeUvHeight.x + u_cylinderUvToShapeUvHeight.y; // x = scale, y = offset
+        height = height * u_cylinderUvToShapeUvHeight.x + u_cylinderUvToShapeUvHeight.y;
     #endif
 
-    float angle = (atan(positionLocal.y, positionLocal.x) + czm_pi) / czm_twoPi; // [0,1]
+    float angle = (positionShape.z + czm_pi) / czm_twoPi;
     #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.
@@ -50,7 +67,32 @@ vec3 convertUvToShapeUvSpace(in vec3 positionUv) {
             angle = angle < u_cylinderShapeUvAngleRangeZeroMid ? u_cylinderShapeUvAngleMinMax.y : angle;
         #endif
 
-        angle = angle * u_cylinderUvToShapeUvAngle.x + u_cylinderUvToShapeUvAngle.y; // x = scale, y = offset
+        angle = angle * u_cylinderUvToShapeUvAngle.x + u_cylinderUvToShapeUvAngle.y;
+    #endif
+
+    return vec3(radius, height, angle);
+}
+
+PointJacobianT convertUvToShapeUvSpaceDerivative(in vec3 positionUv) {
+    PointJacobianT pointJacobian = convertUvToShapeSpaceDerivative(positionUv);
+    pointJacobian.point = convertShapeToShapeUvSpace(pointJacobian.point);
+    return pointJacobian;
+}
+
+vec3 scaleShapeUvToShapeSpace(in vec3 shapeUv) {
+    float radius = shapeUv.x;
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS)
+        radius /= u_cylinderUvToShapeUvRadius.x;
+    #endif
+
+    float height = shapeUv.y;
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)
+        height /= u_cylinderUvToShapeUvHeight.x;
+    #endif
+
+    float angle = shapeUv.z * czm_twoPi;
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)
+        angle /= u_cylinderUvToShapeUvAngle.x;
     #endif
 
     return vec3(radius, height, angle);

package/Source/Shaders/Voxels/convertUvToCylinder.js

@@ -24,20 +24,37 @@ export default "/* Cylinder defines (set in Scene/VoxelCylinderShape.js)\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\
+PointJacobianT convertUvToShapeSpaceDerivative(in vec3 positionUv) {\n\
+    // Convert from Cartesian UV space [0, 1] to Cartesian local space [-1, 1]\n\
+    vec3 position = positionUv * 2.0 - 1.0;\n\
 \n\
-    float radius = length(positionLocal.xy); // [0,1]\n\
+    float radius = length(position.xy); // [0, 1]\n\
+    vec3 radial = normalize(vec3(position.xy, 0.0));\n\
+\n\
+    // Shape space height is defined within [0, 1]\n\
+    float height = positionUv.z; // [0, 1]\n\
+    vec3 z = vec3(0.0, 0.0, 1.0);\n\
+\n\
+    float angle = atan(position.y, position.x);\n\
+    vec3 east = normalize(vec3(-position.y, position.x, 0.0));\n\
+\n\
+    vec3 point = vec3(radius, height, angle);\n\
+    mat3 jacobianT = mat3(radial, z, east / length(position.xy));\n\
+    return PointJacobianT(point, jacobianT);\n\
+}\n\
+\n\
+vec3 convertShapeToShapeUvSpace(in vec3 positionShape) {\n\
+    float radius = positionShape.x;\n\
     #if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS)\n\
-        radius = radius * u_cylinderUvToShapeUvRadius.x + u_cylinderUvToShapeUvRadius.y; // x = scale, y = offset\n\
+        radius = radius * u_cylinderUvToShapeUvRadius.x + u_cylinderUvToShapeUvRadius.y;\n\
     #endif\n\
 \n\
-    float height = positionUv.z; // [0,1]\n\
+    float height = positionShape.y;\n\
     #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)\n\
-        height = height * u_cylinderUvToShapeUvHeight.x + u_cylinderUvToShapeUvHeight.y; // x = scale, y = offset\n\
+        height = height * u_cylinderUvToShapeUvHeight.x + u_cylinderUvToShapeUvHeight.y;\n\
     #endif\n\
 \n\
-    float angle = (atan(positionLocal.y, positionLocal.x) + czm_pi) / czm_twoPi; // [0,1]\n\
+    float angle = (positionShape.z + czm_pi) / czm_twoPi;\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\
@@ -51,7 +68,32 @@ vec3 convertUvToShapeUvSpace(in vec3 positionUv) {\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\
+        angle = angle * u_cylinderUvToShapeUvAngle.x + u_cylinderUvToShapeUvAngle.y;\n\
+    #endif\n\
+\n\
+    return vec3(radius, height, angle);\n\
+}\n\
+\n\
+PointJacobianT convertUvToShapeUvSpaceDerivative(in vec3 positionUv) {\n\
+    PointJacobianT pointJacobian = convertUvToShapeSpaceDerivative(positionUv);\n\
+    pointJacobian.point = convertShapeToShapeUvSpace(pointJacobian.point);\n\
+    return pointJacobian;\n\
+}\n\
+\n\
+vec3 scaleShapeUvToShapeSpace(in vec3 shapeUv) {\n\
+    float radius = shapeUv.x;\n\
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS)\n\
+        radius /= u_cylinderUvToShapeUvRadius.x;\n\
+    #endif\n\
+\n\
+    float height = shapeUv.y;\n\
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)\n\
+        height /= u_cylinderUvToShapeUvHeight.x;\n\
+    #endif\n\
+\n\
+    float angle = shapeUv.z * czm_twoPi;\n\
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)\n\
+        angle /= u_cylinderUvToShapeUvAngle.x;\n\
     #endif\n\
 \n\
     return vec3(radius, height, angle);\n\

package/Source/Shaders/Voxels/convertUvToEllipsoid.glsl

@@ -4,14 +4,11 @@
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_MIN_MAX_REVERSED
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE
-#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
+uniform vec2 u_evoluteScale; // (radiiUv.x ^ 2 - radiiUv.z ^ 2) * vec2(1.0, -1.0) / radiiUv;
+uniform vec3 u_ellipsoidInverseRadiiSquaredUv;
 #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
@@ -21,49 +18,71 @@ 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_FLAT)
-    uniform float u_ellipsoidInverseHeightDifferenceUv;
-    uniform vec2 u_ellipseInnerRadiiUv; // [0,1]
-#endif
+uniform float u_ellipsoidInverseHeightDifferenceUv;
 
 // 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) {
+// Extended to return radius of curvature along with the point
+vec3 nearestPointAndRadiusOnEllipse(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;
+    vec2 inverseRadii = 1.0 / radii;
+
+    // We describe the ellipse parametrically: v = radii * vec2(cos(t), sin(t))
+    // but store the cos and sin of t in a vec2 for efficiency.
+    // Initial guess: t = pi/4
+    vec2 tTrigs = vec2(0.7071067811865476);
+    // Initial guess of point on ellipsoid
+    vec2 v = radii * tTrigs;
+    // Center of curvature of the ellipse at v
+    vec2 evolute = u_evoluteScale * tTrigs * tTrigs * tTrigs;
 
     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;
+        // Find the (approximate) intersection of p - evolute with the ellipsoid.
+        vec2 q = normalize(p - evolute) * length(v - evolute);
+        // Update the estimate of t.
+        tTrigs = (q + evolute) * inverseRadii;
+        tTrigs = normalize(clamp(tTrigs, 0.0, 1.0));
+        v = radii * tTrigs;
+        evolute = u_evoluteScale * tTrigs * tTrigs * tTrigs;
     }
-    return length(v * sign(pos) - pos) * sign(p.y - v.y);
+
+    return vec3(v * sign(pos), length(v - evolute));
 }
 
-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
+PointJacobianT convertUvToShapeSpaceDerivative(in vec3 positionUv) {
+    // Convert from UV space [0, 1] to local space [-1, 1]
+    vec3 position = positionUv * 2.0 - 1.0;
+    // Undo the scaling from ellipsoid to sphere
+    position = position * u_ellipsoidRadiiUv;
+
+    float longitude = atan(position.y, position.x);
+    vec3 east = normalize(vec3(-position.y, position.x, 0.0));
+
+    // Convert the 3D position to a 2D position relative to the ellipse (radii.x, radii.z)
+    // (assume radii.y == radii.x) and find the nearest point on the ellipse and its normal
+    float distanceFromZAxis = length(position.xy);
+    vec2 posEllipse = vec2(distanceFromZAxis, position.z);
+    vec3 surfacePointAndRadius = nearestPointAndRadiusOnEllipse(posEllipse, u_ellipsoidRadiiUv.xz);
+    vec2 surfacePoint = surfacePointAndRadius.xy;
+
+    vec2 normal2d = normalize(surfacePoint * u_ellipsoidInverseRadiiSquaredUv.xz);
+    float latitude = atan(normal2d.y, normal2d.x);
+    vec3 north = vec3(-normal2d.y * normalize(position.xy), abs(normal2d.x));
+
+    float heightSign = length(posEllipse) < length(surfacePoint) ? -1.0 : 1.0;
+    float height = heightSign * length(posEllipse - surfacePoint);
+    vec3 up = normalize(cross(east, north));
+
+    vec3 point = vec3(longitude, latitude, height);
+    mat3 jacobianT = mat3(east / distanceFromZAxis, north / (surfacePointAndRadius.z + height), up);
+    return PointJacobianT(point, jacobianT);
+}
 
-    // Compute longitude
-    float longitude = (atan(normal.y, normal.x) + czm_pi) / czm_twoPi;
+vec3 convertShapeToShapeUvSpace(in vec3 positionShape) {
+    // Longitude: shift & scale to [0, 1]
+    float longitude = (positionShape.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.
@@ -83,28 +102,38 @@ vec3 convertUvToShapeUvSpace(in vec3 positionUv) {
         longitude = longitude * u_ellipsoidUvToShapeUvLongitude.x + u_ellipsoidUvToShapeUvLongitude.y;
     #endif
 
-    // Compute latitude
-    float latitude = (asin(normal.z) + czm_piOverTwo) / czm_pi;
+    // Latitude: shift and scale to [0, 1]
+    float latitude = (positionShape.y + czm_piOverTwo) / czm_pi;
     #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE)
         latitude = latitude * u_ellipsoidUvToShapeUvLatitude.x + u_ellipsoidUvToShapeUvLatitude.y;
     #endif
 
-    // Compute height
-    #if defined(ELLIPSOID_HAS_SHAPE_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)
-            float height = (length(posEllipsoid) - u_ellipseInnerRadiiUv.x) * u_ellipsoidInverseHeightDifferenceUv;
-        #else
-            // 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
+    // Height: scale to the range [0, 1]
+    float height = 1.0 + positionShape.z * u_ellipsoidInverseHeightDifferenceUv;
+
+    return vec3(longitude, latitude, height);
+}
+
+PointJacobianT convertUvToShapeUvSpaceDerivative(in vec3 positionUv) {
+    PointJacobianT pointJacobian = convertUvToShapeSpaceDerivative(positionUv);
+    pointJacobian.point = convertShapeToShapeUvSpace(pointJacobian.point);
+    return pointJacobian;
+}
+
+vec3 scaleShapeUvToShapeSpace(in vec3 shapeUv) {
+    // Convert from [0, 1] to radians [-pi, pi]
+    float longitude = shapeUv.x * czm_twoPi;
+    #if defined (ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE)
+        longitude /= u_ellipsoidUvToShapeUvLongitude.x;
+    #endif
+
+    // Convert from [0, 1] to radians [-pi/2, pi/2]
+    float latitude = shapeUv.y * czm_pi;
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE)
+        latitude /= u_ellipsoidUvToShapeUvLatitude.x;
     #endif
+    
+    float height = shapeUv.z / u_ellipsoidInverseHeightDifferenceUv;
 
     return vec3(longitude, latitude, height);
 }

package/Source/Shaders/Voxels/convertUvToEllipsoid.js

@@ -5,14 +5,11 @@ export default "/* Ellipsoid defines (set in Scene/VoxelEllipsoidShape.js)\n\
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE\n\
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_MIN_MAX_REVERSED\n\
 #define ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE\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\
+uniform vec2 u_evoluteScale; // (radiiUv.x ^ 2 - radiiUv.z ^ 2) * vec2(1.0, -1.0) / radiiUv;\n\
+uniform vec3 u_ellipsoidInverseRadiiSquaredUv;\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\
@@ -22,49 +19,71 @@ 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_FLAT)\n\
-    uniform float u_ellipsoidInverseHeightDifferenceUv;\n\
-    uniform vec2 u_ellipseInnerRadiiUv; // [0,1]\n\
-#endif\n\
+uniform float u_ellipsoidInverseHeightDifferenceUv;\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\
+// Extended to return radius of curvature along with the point\n\
+vec3 nearestPointAndRadiusOnEllipse(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\
+    vec2 inverseRadii = 1.0 / radii;\n\
+\n\
+    // We describe the ellipse parametrically: v = radii * vec2(cos(t), sin(t))\n\
+    // but store the cos and sin of t in a vec2 for efficiency.\n\
+    // Initial guess: t = pi/4\n\
+    vec2 tTrigs = vec2(0.7071067811865476);\n\
+    // Initial guess of point on ellipsoid\n\
+    vec2 v = radii * tTrigs;\n\
+    // Center of curvature of the ellipse at v\n\
+    vec2 evolute = u_evoluteScale * tTrigs * tTrigs * tTrigs;\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\
+        // Find the (approximate) intersection of p - evolute with the ellipsoid.\n\
+        vec2 q = normalize(p - evolute) * length(v - evolute);\n\
+        // Update the estimate of t.\n\
+        tTrigs = (q + evolute) * inverseRadii;\n\
+        tTrigs = normalize(clamp(tTrigs, 0.0, 1.0));\n\
+        v = radii * tTrigs;\n\
+        evolute = u_evoluteScale * tTrigs * tTrigs * tTrigs;\n\
     }\n\
-    return length(v * sign(pos) - pos) * sign(p.y - v.y);\n\
+\n\
+    return vec3(v * sign(pos), length(v - evolute));\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\
+PointJacobianT convertUvToShapeSpaceDerivative(in vec3 positionUv) {\n\
+    // Convert from UV space [0, 1] to local space [-1, 1]\n\
+    vec3 position = positionUv * 2.0 - 1.0;\n\
+    // Undo the scaling from ellipsoid to sphere\n\
+    position = position * u_ellipsoidRadiiUv;\n\
+\n\
+    float longitude = atan(position.y, position.x);\n\
+    vec3 east = normalize(vec3(-position.y, position.x, 0.0));\n\
+\n\
+    // Convert the 3D position to a 2D position relative to the ellipse (radii.x, radii.z)\n\
+    // (assume radii.y == radii.x) and find the nearest point on the ellipse and its normal\n\
+    float distanceFromZAxis = length(position.xy);\n\
+    vec2 posEllipse = vec2(distanceFromZAxis, position.z);\n\
+    vec3 surfacePointAndRadius = nearestPointAndRadiusOnEllipse(posEllipse, u_ellipsoidRadiiUv.xz);\n\
+    vec2 surfacePoint = surfacePointAndRadius.xy;\n\
+\n\
+    vec2 normal2d = normalize(surfacePoint * u_ellipsoidInverseRadiiSquaredUv.xz);\n\
+    float latitude = atan(normal2d.y, normal2d.x);\n\
+    vec3 north = vec3(-normal2d.y * normalize(position.xy), abs(normal2d.x));\n\
+\n\
+    float heightSign = length(posEllipse) < length(surfacePoint) ? -1.0 : 1.0;\n\
+    float height = heightSign * length(posEllipse - surfacePoint);\n\
+    vec3 up = normalize(cross(east, north));\n\
+\n\
+    vec3 point = vec3(longitude, latitude, height);\n\
+    mat3 jacobianT = mat3(east / distanceFromZAxis, north / (surfacePointAndRadius.z + height), up);\n\
+    return PointJacobianT(point, jacobianT);\n\
+}\n\
 \n\
-    // Compute longitude\n\
-    float longitude = (atan(normal.y, normal.x) + czm_pi) / czm_twoPi;\n\
+vec3 convertShapeToShapeUvSpace(in vec3 positionShape) {\n\
+    // Longitude: shift & scale to [0, 1]\n\
+    float longitude = (positionShape.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\
@@ -84,28 +103,38 @@ vec3 convertUvToShapeUvSpace(in vec3 positionUv) {\n\
         longitude = longitude * u_ellipsoidUvToShapeUvLongitude.x + u_ellipsoidUvToShapeUvLongitude.y;\n\
     #endif\n\
 \n\
-    // Compute latitude\n\
-    float latitude = (asin(normal.z) + czm_piOverTwo) / czm_pi;\n\
+    // Latitude: shift and scale to [0, 1]\n\
+    float latitude = (positionShape.y + 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\
-    #if defined(ELLIPSOID_HAS_SHAPE_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\
-            float height = (length(posEllipsoid) - u_ellipseInnerRadiiUv.x) * u_ellipsoidInverseHeightDifferenceUv;\n\
-        #else\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\
+    // Height: scale to the range [0, 1]\n\
+    float height = 1.0 + positionShape.z * u_ellipsoidInverseHeightDifferenceUv;\n\
+\n\
+    return vec3(longitude, latitude, height);\n\
+}\n\
+\n\
+PointJacobianT convertUvToShapeUvSpaceDerivative(in vec3 positionUv) {\n\
+    PointJacobianT pointJacobian = convertUvToShapeSpaceDerivative(positionUv);\n\
+    pointJacobian.point = convertShapeToShapeUvSpace(pointJacobian.point);\n\
+    return pointJacobian;\n\
+}\n\
+\n\
+vec3 scaleShapeUvToShapeSpace(in vec3 shapeUv) {\n\
+    // Convert from [0, 1] to radians [-pi, pi]\n\
+    float longitude = shapeUv.x * czm_twoPi;\n\
+    #if defined (ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE)\n\
+        longitude /= u_ellipsoidUvToShapeUvLongitude.x;\n\
+    #endif\n\
+\n\
+    // Convert from [0, 1] to radians [-pi/2, pi/2]\n\
+    float latitude = shapeUv.y * czm_pi;\n\
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE)\n\
+        latitude /= u_ellipsoidUvToShapeUvLatitude.x;\n\
     #endif\n\
+    \n\
+    float height = shapeUv.z / u_ellipsoidInverseHeightDifferenceUv;\n\
 \n\
     return vec3(longitude, latitude, height);\n\
 }\n\