@cesium/engine 8.0.0 → 9.1.0

package/Source/Shaders/Voxels/Octree.glsl

@@ -79,10 +79,15 @@ int getOctreeParentIndex(in int octreeIndex) {
 */
 vec3 getTileUv(in vec3 shapePosition, in ivec4 octreeCoords) {
 	// PERFORMANCE_IDEA: use bit-shifting (only in WebGL2)
-    float dimAtLevel = pow(2.0, float(octreeCoords.w));
+    float dimAtLevel = exp2(float(octreeCoords.w));
     return shapePosition * dimAtLevel - vec3(octreeCoords.xyz);
 }
 
+vec3 getClampedTileUv(in vec3 shapePosition, in ivec4 octreeCoords) {
+    vec3 tileUv = getTileUv(shapePosition, octreeCoords);
+    return clamp(tileUv, vec3(0.0), vec3(1.0));
+}
+
 void getOctreeLeafSampleData(in OctreeNodeData data, in ivec4 octreeCoords, out SampleData sampleData) {
     sampleData.megatextureIndex = data.data;
     sampleData.tileCoords = (data.flag == OCTREE_FLAG_PACKED_LEAF_FROM_PARENT)
@@ -121,7 +126,7 @@ void getOctreeLeafSampleDatas(in OctreeNodeData data, in ivec4 octreeCoords, out
 #endif
 
 OctreeNodeData traverseOctreeDownwards(in vec3 shapePosition, inout TraversalData traversalData) {
-    float sizeAtLevel = 1.0 / pow(2.0, float(traversalData.octreeCoords.w));
+    float sizeAtLevel = exp2(-1.0 * float(traversalData.octreeCoords.w));
     vec3 start = vec3(traversalData.octreeCoords.xyz) * sizeAtLevel;
     vec3 end = start + vec3(sizeAtLevel);
     OctreeNodeData childData;
@@ -167,11 +172,11 @@ void traverseOctreeFromBeginning(in vec3 shapePosition, out TraversalData traver
 
     #if (SAMPLE_COUNT == 1)
         getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);
     #else
         getOctreeLeafSampleDatas(nodeData, traversalData.octreeCoords, sampleDatas);
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);
-        sampleDatas[1].tileUv = getTileUv(shapePosition, sampleDatas[1].tileCoords);
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);
+        sampleDatas[1].tileUv = getClampedTileUv(shapePosition, sampleDatas[1].tileCoords);
     #endif
 }
 
@@ -189,7 +194,7 @@ bool insideTile(in vec3 shapePosition, in ivec4 octreeCoords) {
 void traverseOctreeFromExisting(in vec3 shapePosition, inout TraversalData traversalData, inout SampleData sampleDatas[SAMPLE_COUNT]) {
     if (insideTile(shapePosition, traversalData.octreeCoords)) {
         for (int i = 0; i < SAMPLE_COUNT; i++) {
-            sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);
+            sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);
         }
         return;
     }
@@ -211,10 +216,10 @@ void traverseOctreeFromExisting(in vec3 shapePosition, inout TraversalData trave
 
     #if (SAMPLE_COUNT == 1)
         getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);
     #else
         getOctreeLeafSampleDatas(nodeData, traversalData.octreeCoords, sampleDatas);
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);
-        sampleDatas[1].tileUv = getTileUv(shapePosition, sampleDatas[1].tileCoords);
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);
+        sampleDatas[1].tileUv = getClampedTileUv(shapePosition, sampleDatas[1].tileCoords);
     #endif
 }

package/Source/Shaders/Voxels/Octree.js

@@ -80,10 +80,15 @@ int getOctreeParentIndex(in int octreeIndex) {\n\
 */\n\
 vec3 getTileUv(in vec3 shapePosition, in ivec4 octreeCoords) {\n\
 	// PERFORMANCE_IDEA: use bit-shifting (only in WebGL2)\n\
-    float dimAtLevel = pow(2.0, float(octreeCoords.w));\n\
+    float dimAtLevel = exp2(float(octreeCoords.w));\n\
     return shapePosition * dimAtLevel - vec3(octreeCoords.xyz);\n\
 }\n\
 \n\
+vec3 getClampedTileUv(in vec3 shapePosition, in ivec4 octreeCoords) {\n\
+    vec3 tileUv = getTileUv(shapePosition, octreeCoords);\n\
+    return clamp(tileUv, vec3(0.0), vec3(1.0));\n\
+}\n\
+\n\
 void getOctreeLeafSampleData(in OctreeNodeData data, in ivec4 octreeCoords, out SampleData sampleData) {\n\
     sampleData.megatextureIndex = data.data;\n\
     sampleData.tileCoords = (data.flag == OCTREE_FLAG_PACKED_LEAF_FROM_PARENT)\n\
@@ -122,7 +127,7 @@ void getOctreeLeafSampleDatas(in OctreeNodeData data, in ivec4 octreeCoords, out
 #endif\n\
 \n\
 OctreeNodeData traverseOctreeDownwards(in vec3 shapePosition, inout TraversalData traversalData) {\n\
-    float sizeAtLevel = 1.0 / pow(2.0, float(traversalData.octreeCoords.w));\n\
+    float sizeAtLevel = exp2(-1.0 * float(traversalData.octreeCoords.w));\n\
     vec3 start = vec3(traversalData.octreeCoords.xyz) * sizeAtLevel;\n\
     vec3 end = start + vec3(sizeAtLevel);\n\
     OctreeNodeData childData;\n\
@@ -168,11 +173,11 @@ void traverseOctreeFromBeginning(in vec3 shapePosition, out TraversalData traver
 \n\
     #if (SAMPLE_COUNT == 1)\n\
         getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);\n\
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
     #else\n\
         getOctreeLeafSampleDatas(nodeData, traversalData.octreeCoords, sampleDatas);\n\
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
-        sampleDatas[1].tileUv = getTileUv(shapePosition, sampleDatas[1].tileCoords);\n\
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
+        sampleDatas[1].tileUv = getClampedTileUv(shapePosition, sampleDatas[1].tileCoords);\n\
     #endif\n\
 }\n\
 \n\
@@ -190,7 +195,7 @@ bool insideTile(in vec3 shapePosition, in ivec4 octreeCoords) {\n\
 void traverseOctreeFromExisting(in vec3 shapePosition, inout TraversalData traversalData, inout SampleData sampleDatas[SAMPLE_COUNT]) {\n\
     if (insideTile(shapePosition, traversalData.octreeCoords)) {\n\
         for (int i = 0; i < SAMPLE_COUNT; i++) {\n\
-            sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
+            sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
         }\n\
         return;\n\
     }\n\
@@ -212,11 +217,11 @@ void traverseOctreeFromExisting(in vec3 shapePosition, inout TraversalData trave
 \n\
     #if (SAMPLE_COUNT == 1)\n\
         getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);\n\
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
     #else\n\
         getOctreeLeafSampleDatas(nodeData, traversalData.octreeCoords, sampleDatas);\n\
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
-        sampleDatas[1].tileUv = getTileUv(shapePosition, sampleDatas[1].tileCoords);\n\
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
+        sampleDatas[1].tileUv = getClampedTileUv(shapePosition, sampleDatas[1].tileCoords);\n\
     #endif\n\
 }\n\
 ";

package/Source/Shaders/Voxels/VoxelFS.glsl

@@ -23,27 +23,68 @@ uniform float u_stepSize;
     uniform vec4 u_pickColor;
 #endif
 
-#if defined(JITTER)
-float hash(vec2 p)
-{
-    vec3 p3 = fract(vec3(p.xyx) * 50.0); // magic number = hashscale
-    p3 += dot(p3, p3.yzx + 19.19);
-    return fract((p3.x + p3.y) * p3.z);
+vec3 getSampleSize(in int level) {
+    vec3 sampleCount = exp2(float(level)) * vec3(u_dimensions);
+    vec3 sampleSizeUv = 1.0 / sampleCount;
+    return scaleShapeUvToShapeSpace(sampleSizeUv);
 }
-#endif
 
-vec4 getStepSize(in SampleData sampleData, in Ray viewRay, in RayShapeIntersection shapeIntersection) {
-#if defined(SHAPE_BOX)
-    Box voxelBox = constructVoxelBox(sampleData.tileCoords, sampleData.tileUv);
-    RayShapeIntersection voxelIntersection = intersectBox(viewRay, voxelBox);
-    vec4 entry = shapeIntersection.entry.w >= voxelIntersection.entry.w ? shapeIntersection.entry : voxelIntersection.entry;
-    float exit = min(voxelIntersection.exit.w, shapeIntersection.exit.w);
-    float dt = (exit - entry.w) * RAY_SCALE;
-    return vec4(normalize(entry.xyz), dt);
-#else
-    float dimAtLevel = pow(2.0, float(sampleData.tileCoords.w));
-    return vec4(viewRay.dir, u_stepSize / dimAtLevel);
-#endif
+#define MINIMUM_STEP_SCALAR (0.02)
+#define SHIFT_FRACTION (0.001)
+
+/**
+ * Given a coordinate within a tile, and sample spacings along a ray through
+ * the coordinate, find the distance to the points where the ray entered and
+ * exited the voxel cell, along with the surface normals at those points.
+ * The surface normals are returned in shape space coordinates.
+ */
+RayShapeIntersection getVoxelIntersection(in vec3 tileUv, in vec3 sampleSizeAlongRay) {
+    vec3 voxelCoord = tileUv * vec3(u_dimensions);
+    vec3 directions = sign(sampleSizeAlongRay);
+    vec3 positiveDirections = max(directions, 0.0);
+    vec3 entryCoord = mix(ceil(voxelCoord), floor(voxelCoord), positiveDirections);
+    vec3 exitCoord = entryCoord + directions;
+
+    vec3 distanceFromEntry = -abs((entryCoord - voxelCoord) * sampleSizeAlongRay);
+    float lastEntry = maxComponent(distanceFromEntry);
+    bvec3 isLastEntry = equal(distanceFromEntry, vec3(lastEntry));
+    vec3 entryNormal = -1.0 * vec3(isLastEntry) * directions;
+    vec4 entry = vec4(entryNormal, lastEntry);
+
+    vec3 distanceToExit = abs((exitCoord - voxelCoord) * sampleSizeAlongRay);
+    float firstExit = minComponent(distanceToExit);
+    bvec3 isFirstExit = equal(distanceToExit, vec3(firstExit));
+    vec3 exitNormal = vec3(isFirstExit) * directions;
+    vec4 exit = vec4(exitNormal, firstExit);
+
+    return RayShapeIntersection(entry, exit);
+}
+
+vec4 getStepSize(in SampleData sampleData, in Ray viewRay, in RayShapeIntersection shapeIntersection, in mat3 jacobianT, in float currentT) {
+    // The Jacobian is computed in a space where the shape spans [-1, 1].
+    // But the ray is marched in a space where the shape fills [0, 1].
+    // So we need to scale the Jacobian by 2.
+    vec3 gradient = 2.0 * viewRay.rawDir * jacobianT;
+    vec3 sampleSizeAlongRay = getSampleSize(sampleData.tileCoords.w) / gradient;
+
+    RayShapeIntersection voxelIntersection = getVoxelIntersection(sampleData.tileUv, sampleSizeAlongRay);
+
+    // Transform normal from shape space to Cartesian space
+    vec3 voxelNormal = normalize(jacobianT * voxelIntersection.entry.xyz);
+    // Compare with the shape intersection, to choose the appropriate normal
+    vec4 voxelEntry = vec4(voxelNormal, currentT + voxelIntersection.entry.w);
+    vec4 entry = intersectionMax(shapeIntersection.entry, voxelEntry);
+
+    float fixedStep = minComponent(abs(sampleSizeAlongRay)) * u_stepSize;
+    float shift = fixedStep * SHIFT_FRACTION;
+    float dt = voxelIntersection.exit.w + shift;
+    if ((currentT + dt) > shapeIntersection.exit.w) {
+        // Stop at end of shape
+        dt = shapeIntersection.exit.w - currentT + shift;
+    }
+    float stepSize = clamp(dt, fixedStep * MINIMUM_STEP_SCALAR, fixedStep + shift);
+
+    return vec4(entry.xyz, stepSize);
 }
 
 vec2 packIntToVec2(int value) {
@@ -61,13 +102,19 @@ vec2 packFloatToVec2(float value) {
 
 int getSampleIndex(in vec3 tileUv) {
     ivec3 voxelDimensions = u_dimensions;
-    vec3 tileCoordinate = clamp(tileUv, 0.0, 1.0) * vec3(voxelDimensions);
-    ivec3 tileIndex = ivec3(floor(tileCoordinate));
+    vec3 sampleCoordinate = tileUv * vec3(voxelDimensions);
+    // tileUv = 1.0 is a valid coordinate but sampleIndex = voxelDimensions is not.
+    // (tileUv = 1.0 corresponds to the last sample, at index = voxelDimensions - 1).
+    // Clamp to [0, voxelDimensions - 0.5) to avoid numerical error before flooring
+    vec3 maxCoordinate = vec3(voxelDimensions) - vec3(0.5);
+    sampleCoordinate = clamp(sampleCoordinate, vec3(0.0), maxCoordinate);
+    ivec3 sampleIndex = ivec3(floor(sampleCoordinate));
     #if defined(PADDING)
         voxelDimensions += u_paddingBefore + u_paddingAfter;
-        tileIndex += u_paddingBefore;
+        sampleIndex += u_paddingBefore;
     #endif
-    return tileIndex.x + voxelDimensions.x * (tileIndex.y + voxelDimensions.y * tileIndex.z);
+    // Convert to a 1D index for lookup in a 1D data array
+    return sampleIndex.x + voxelDimensions.x * (sampleIndex.y + voxelDimensions.y * sampleIndex.z);
 }
 
 void main()
@@ -78,11 +125,13 @@ void main()
     vec3 viewDirWorld = normalize(czm_inverseViewRotation * eyeDirection); // normalize again just in case
     vec3 viewDirUv = normalize(u_transformDirectionViewToLocal * eyeDirection); // normalize again just in case
     vec3 viewPosUv = u_cameraPositionUv;
-    #if defined(SHAPE_BOX)
-        vec3 dInv = 1.0 / viewDirUv;
-        Ray viewRayUv = Ray(viewPosUv, viewDirUv, dInv);
+    #if defined(SHAPE_ELLIPSOID)
+        // viewDirUv has been scaled to a space where the ellipsoid is a sphere.
+        // Undo this scaling to get the raw direction.
+        vec3 rawDir = viewDirUv * u_ellipsoidRadiiUv;
+        Ray viewRayUv = Ray(viewPosUv, viewDirUv, rawDir);
     #else
-        Ray viewRayUv = Ray(viewPosUv, viewDirUv);
+        Ray viewRayUv = Ray(viewPosUv, viewDirUv, viewDirUv);
     #endif
 
     Intersections ix;
@@ -93,20 +142,20 @@ void main()
         discard;
     }
 
-    float currT = shapeIntersection.entry.w * RAY_SCALE;
+    float currentT = shapeIntersection.entry.w;
     float endT = shapeIntersection.exit.w;
-    vec3 positionUv = viewPosUv + currT * viewDirUv;
-    vec3 positionUvShapeSpace = convertUvToShapeUvSpace(positionUv);
+    vec3 positionUv = viewPosUv + currentT * viewDirUv;
+    PointJacobianT pointJacobian = convertUvToShapeUvSpaceDerivative(positionUv);
 
     // Traverse the tree from the start position
     TraversalData traversalData;
     SampleData sampleDatas[SAMPLE_COUNT];
-    traverseOctreeFromBeginning(positionUvShapeSpace, traversalData, sampleDatas);
-    vec4 step = getStepSize(sampleDatas[0], viewRayUv, shapeIntersection);
+    traverseOctreeFromBeginning(pointJacobian.point, traversalData, sampleDatas);
+    vec4 step = getStepSize(sampleDatas[0], viewRayUv, shapeIntersection, pointJacobian.jacobianT, currentT);
 
     #if defined(JITTER)
         float noise = hash(screenCoord); // [0,1]
-        currT += noise * step.w;
+        currentT += noise * step.w;
         positionUv += noise * step.w * viewDirUv;
     #endif
 
@@ -115,7 +164,7 @@ void main()
         setStatistics(fragmentInput.metadata.statistics);
     #endif
 
-    vec4 colorAccum =vec4(0.0);
+    vec4 colorAccum = vec4(0.0);
 
     for (int stepCount = 0; stepCount < STEP_COUNT_MAX; ++stepCount) {
         // Read properties from the megatexture based on the traversal state
@@ -124,12 +173,13 @@ void main()
         // Prepare the custom shader inputs
         copyPropertiesToMetadata(properties, fragmentInput.metadata);
         fragmentInput.voxel.positionUv = positionUv;
-        fragmentInput.voxel.positionShapeUv = positionUvShapeSpace;
+        fragmentInput.voxel.positionShapeUv = pointJacobian.point;
         fragmentInput.voxel.positionUvLocal = sampleDatas[0].tileUv;
         fragmentInput.voxel.viewDirUv = viewDirUv;
         fragmentInput.voxel.viewDirWorld = viewDirWorld;
         fragmentInput.voxel.surfaceNormal = step.xyz;
         fragmentInput.voxel.travelDistance = step.w;
+        fragmentInput.voxel.stepCount = stepCount;
         fragmentInput.voxel.tileIndex = sampleDatas[0].megatextureIndex;
         fragmentInput.voxel.sampleIndex = getSampleIndex(sampleDatas[0].tileUv);
 
@@ -158,11 +208,11 @@ void main()
         }
 
         // Keep raymarching
-        currT += step.w;
-        positionUv += step.w * viewDirUv;
+        currentT += step.w;
+        positionUv = viewPosUv + currentT * viewDirUv;
 
         // Check if there's more intersections.
-        if (currT > endT) {
+        if (currentT > endT) {
             #if (INTERSECTION_COUNT == 1)
                 break;
             #else
@@ -171,18 +221,18 @@ void main()
                     break;
                 } else {
                     // Found another intersection. Resume raymarching there
-                    currT = shapeIntersection.entry.w * RAY_SCALE;
+                    currentT = shapeIntersection.entry.w;
                     endT = shapeIntersection.exit.w;
-                    positionUv = viewPosUv + currT * viewDirUv;
+                    positionUv = viewPosUv + currentT * viewDirUv;
                 }
             #endif
         }
 
         // Traverse the tree from the current ray position.
         // This is similar to traverseOctreeFromBeginning but is faster when the ray is in the same tile as the previous step.
-        positionUvShapeSpace = convertUvToShapeUvSpace(positionUv);
-        traverseOctreeFromExisting(positionUvShapeSpace, traversalData, sampleDatas);
-        step = getStepSize(sampleDatas[0], viewRayUv, shapeIntersection);
+        pointJacobian = convertUvToShapeUvSpaceDerivative(positionUv);
+        traverseOctreeFromExisting(pointJacobian.point, traversalData, sampleDatas);
+        step = getStepSize(sampleDatas[0], viewRayUv, shapeIntersection, pointJacobian.jacobianT, currentT);
     }
 
     // Convert the alpha from [0,ALPHA_ACCUM_MAX] to [0,1]

package/Source/Shaders/Voxels/VoxelFS.js

@@ -24,27 +24,68 @@ uniform float u_stepSize;\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\
+vec3 getSampleSize(in int level) {\n\
+    vec3 sampleCount = exp2(float(level)) * vec3(u_dimensions);\n\
+    vec3 sampleSizeUv = 1.0 / sampleCount;\n\
+    return scaleShapeUvToShapeSpace(sampleSizeUv);\n\
 }\n\
-#endif\n\
 \n\
-vec4 getStepSize(in SampleData sampleData, in Ray viewRay, in RayShapeIntersection shapeIntersection) {\n\
-#if defined(SHAPE_BOX)\n\
-    Box voxelBox = constructVoxelBox(sampleData.tileCoords, sampleData.tileUv);\n\
-    RayShapeIntersection voxelIntersection = intersectBox(viewRay, voxelBox);\n\
-    vec4 entry = shapeIntersection.entry.w >= voxelIntersection.entry.w ? shapeIntersection.entry : voxelIntersection.entry;\n\
-    float exit = min(voxelIntersection.exit.w, shapeIntersection.exit.w);\n\
-    float dt = (exit - entry.w) * RAY_SCALE;\n\
-    return vec4(normalize(entry.xyz), dt);\n\
-#else\n\
-    float dimAtLevel = pow(2.0, float(sampleData.tileCoords.w));\n\
-    return vec4(viewRay.dir, u_stepSize / dimAtLevel);\n\
-#endif\n\
+#define MINIMUM_STEP_SCALAR (0.02)\n\
+#define SHIFT_FRACTION (0.001)\n\
+\n\
+/**\n\
+ * Given a coordinate within a tile, and sample spacings along a ray through\n\
+ * the coordinate, find the distance to the points where the ray entered and\n\
+ * exited the voxel cell, along with the surface normals at those points.\n\
+ * The surface normals are returned in shape space coordinates.\n\
+ */\n\
+RayShapeIntersection getVoxelIntersection(in vec3 tileUv, in vec3 sampleSizeAlongRay) {\n\
+    vec3 voxelCoord = tileUv * vec3(u_dimensions);\n\
+    vec3 directions = sign(sampleSizeAlongRay);\n\
+    vec3 positiveDirections = max(directions, 0.0);\n\
+    vec3 entryCoord = mix(ceil(voxelCoord), floor(voxelCoord), positiveDirections);\n\
+    vec3 exitCoord = entryCoord + directions;\n\
+\n\
+    vec3 distanceFromEntry = -abs((entryCoord - voxelCoord) * sampleSizeAlongRay);\n\
+    float lastEntry = maxComponent(distanceFromEntry);\n\
+    bvec3 isLastEntry = equal(distanceFromEntry, vec3(lastEntry));\n\
+    vec3 entryNormal = -1.0 * vec3(isLastEntry) * directions;\n\
+    vec4 entry = vec4(entryNormal, lastEntry);\n\
+\n\
+    vec3 distanceToExit = abs((exitCoord - voxelCoord) * sampleSizeAlongRay);\n\
+    float firstExit = minComponent(distanceToExit);\n\
+    bvec3 isFirstExit = equal(distanceToExit, vec3(firstExit));\n\
+    vec3 exitNormal = vec3(isFirstExit) * directions;\n\
+    vec4 exit = vec4(exitNormal, firstExit);\n\
+\n\
+    return RayShapeIntersection(entry, exit);\n\
+}\n\
+\n\
+vec4 getStepSize(in SampleData sampleData, in Ray viewRay, in RayShapeIntersection shapeIntersection, in mat3 jacobianT, in float currentT) {\n\
+    // The Jacobian is computed in a space where the shape spans [-1, 1].\n\
+    // But the ray is marched in a space where the shape fills [0, 1].\n\
+    // So we need to scale the Jacobian by 2.\n\
+    vec3 gradient = 2.0 * viewRay.rawDir * jacobianT;\n\
+    vec3 sampleSizeAlongRay = getSampleSize(sampleData.tileCoords.w) / gradient;\n\
+\n\
+    RayShapeIntersection voxelIntersection = getVoxelIntersection(sampleData.tileUv, sampleSizeAlongRay);\n\
+\n\
+    // Transform normal from shape space to Cartesian space\n\
+    vec3 voxelNormal = normalize(jacobianT * voxelIntersection.entry.xyz);\n\
+    // Compare with the shape intersection, to choose the appropriate normal\n\
+    vec4 voxelEntry = vec4(voxelNormal, currentT + voxelIntersection.entry.w);\n\
+    vec4 entry = intersectionMax(shapeIntersection.entry, voxelEntry);\n\
+\n\
+    float fixedStep = minComponent(abs(sampleSizeAlongRay)) * u_stepSize;\n\
+    float shift = fixedStep * SHIFT_FRACTION;\n\
+    float dt = voxelIntersection.exit.w + shift;\n\
+    if ((currentT + dt) > shapeIntersection.exit.w) {\n\
+        // Stop at end of shape\n\
+        dt = shapeIntersection.exit.w - currentT + shift;\n\
+    }\n\
+    float stepSize = clamp(dt, fixedStep * MINIMUM_STEP_SCALAR, fixedStep + shift);\n\
+\n\
+    return vec4(entry.xyz, stepSize);\n\
 }\n\
 \n\
 vec2 packIntToVec2(int value) {\n\
@@ -62,13 +103,19 @@ vec2 packFloatToVec2(float value) {\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\
+    vec3 sampleCoordinate = tileUv * vec3(voxelDimensions);\n\
+    // tileUv = 1.0 is a valid coordinate but sampleIndex = voxelDimensions is not.\n\
+    // (tileUv = 1.0 corresponds to the last sample, at index = voxelDimensions - 1).\n\
+    // Clamp to [0, voxelDimensions - 0.5) to avoid numerical error before flooring\n\
+    vec3 maxCoordinate = vec3(voxelDimensions) - vec3(0.5);\n\
+    sampleCoordinate = clamp(sampleCoordinate, vec3(0.0), maxCoordinate);\n\
+    ivec3 sampleIndex = ivec3(floor(sampleCoordinate));\n\
     #if defined(PADDING)\n\
         voxelDimensions += u_paddingBefore + u_paddingAfter;\n\
-        tileIndex += u_paddingBefore;\n\
+        sampleIndex += u_paddingBefore;\n\
     #endif\n\
-    return tileIndex.x + voxelDimensions.x * (tileIndex.y + voxelDimensions.y * tileIndex.z);\n\
+    // Convert to a 1D index for lookup in a 1D data array\n\
+    return sampleIndex.x + voxelDimensions.x * (sampleIndex.y + voxelDimensions.y * sampleIndex.z);\n\
 }\n\
 \n\
 void main()\n\
@@ -79,11 +126,13 @@ void main()\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\
-    #if defined(SHAPE_BOX)\n\
-        vec3 dInv = 1.0 / viewDirUv;\n\
-        Ray viewRayUv = Ray(viewPosUv, viewDirUv, dInv);\n\
+    #if defined(SHAPE_ELLIPSOID)\n\
+        // viewDirUv has been scaled to a space where the ellipsoid is a sphere.\n\
+        // Undo this scaling to get the raw direction.\n\
+        vec3 rawDir = viewDirUv * u_ellipsoidRadiiUv;\n\
+        Ray viewRayUv = Ray(viewPosUv, viewDirUv, rawDir);\n\
     #else\n\
-        Ray viewRayUv = Ray(viewPosUv, viewDirUv);\n\
+        Ray viewRayUv = Ray(viewPosUv, viewDirUv, viewDirUv);\n\
     #endif\n\
 \n\
     Intersections ix;\n\
@@ -94,20 +143,20 @@ void main()\n\
         discard;\n\
     }\n\
 \n\
-    float currT = shapeIntersection.entry.w * RAY_SCALE;\n\
+    float currentT = shapeIntersection.entry.w;\n\
     float endT = shapeIntersection.exit.w;\n\
-    vec3 positionUv = viewPosUv + currT * viewDirUv;\n\
-    vec3 positionUvShapeSpace = convertUvToShapeUvSpace(positionUv);\n\
+    vec3 positionUv = viewPosUv + currentT * viewDirUv;\n\
+    PointJacobianT pointJacobian = convertUvToShapeUvSpaceDerivative(positionUv);\n\
 \n\
     // Traverse the tree from the start position\n\
     TraversalData traversalData;\n\
     SampleData sampleDatas[SAMPLE_COUNT];\n\
-    traverseOctreeFromBeginning(positionUvShapeSpace, traversalData, sampleDatas);\n\
-    vec4 step = getStepSize(sampleDatas[0], viewRayUv, shapeIntersection);\n\
+    traverseOctreeFromBeginning(pointJacobian.point, traversalData, sampleDatas);\n\
+    vec4 step = getStepSize(sampleDatas[0], viewRayUv, shapeIntersection, pointJacobian.jacobianT, currentT);\n\
 \n\
     #if defined(JITTER)\n\
         float noise = hash(screenCoord); // [0,1]\n\
-        currT += noise * step.w;\n\
+        currentT += noise * step.w;\n\
         positionUv += noise * step.w * viewDirUv;\n\
     #endif\n\
 \n\
@@ -116,7 +165,7 @@ void main()\n\
         setStatistics(fragmentInput.metadata.statistics);\n\
     #endif\n\
 \n\
-    vec4 colorAccum =vec4(0.0);\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\
@@ -125,12 +174,13 @@ void main()\n\
         // Prepare the custom shader inputs\n\
         copyPropertiesToMetadata(properties, fragmentInput.metadata);\n\
         fragmentInput.voxel.positionUv = positionUv;\n\
-        fragmentInput.voxel.positionShapeUv = positionUvShapeSpace;\n\
+        fragmentInput.voxel.positionShapeUv = pointJacobian.point;\n\
         fragmentInput.voxel.positionUvLocal = sampleDatas[0].tileUv;\n\
         fragmentInput.voxel.viewDirUv = viewDirUv;\n\
         fragmentInput.voxel.viewDirWorld = viewDirWorld;\n\
         fragmentInput.voxel.surfaceNormal = step.xyz;\n\
         fragmentInput.voxel.travelDistance = step.w;\n\
+        fragmentInput.voxel.stepCount = stepCount;\n\
         fragmentInput.voxel.tileIndex = sampleDatas[0].megatextureIndex;\n\
         fragmentInput.voxel.sampleIndex = getSampleIndex(sampleDatas[0].tileUv);\n\
 \n\
@@ -159,11 +209,11 @@ void main()\n\
         }\n\
 \n\
         // Keep raymarching\n\
-        currT += step.w;\n\
-        positionUv += step.w * viewDirUv;\n\
+        currentT += step.w;\n\
+        positionUv = viewPosUv + currentT * viewDirUv;\n\
 \n\
         // Check if there's more intersections.\n\
-        if (currT > endT) {\n\
+        if (currentT > endT) {\n\
             #if (INTERSECTION_COUNT == 1)\n\
                 break;\n\
             #else\n\
@@ -172,18 +222,18 @@ void main()\n\
                     break;\n\
                 } else {\n\
                     // Found another intersection. Resume raymarching there\n\
-                    currT = shapeIntersection.entry.w * RAY_SCALE;\n\
+                    currentT = shapeIntersection.entry.w;\n\
                     endT = shapeIntersection.exit.w;\n\
-                    positionUv = viewPosUv + currT * viewDirUv;\n\
+                    positionUv = viewPosUv + currentT * viewDirUv;\n\
                 }\n\
             #endif\n\
         }\n\
 \n\
         // Traverse the tree from the current ray position.\n\
         // This is similar to traverseOctreeFromBeginning 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\
-        step = getStepSize(sampleDatas[0], viewRayUv, shapeIntersection);\n\
+        pointJacobian = convertUvToShapeUvSpaceDerivative(positionUv);\n\
+        traverseOctreeFromExisting(pointJacobian.point, traversalData, sampleDatas);\n\
+        step = getStepSize(sampleDatas[0], viewRayUv, shapeIntersection, pointJacobian.jacobianT, currentT);\n\
     }\n\
 \n\
     // Convert the alpha from [0,ALPHA_ACCUM_MAX] to [0,1]\n\

package/Source/Shaders/Voxels/VoxelUtils.glsl

@@ -0,0 +1,31 @@
+struct Ray {
+    vec3 pos;
+    vec3 dir;
+    vec3 rawDir;
+};
+
+#if defined(JITTER)
+/**
+ * Generate a pseudo-random value for a given 2D screen coordinate.
+ * Similar to https://www.shadertoy.com/view/4djSRW with a modified hashscale.
+ */
+float hash(vec2 p)
+{
+    vec3 p3 = fract(vec3(p.xyx) * 50.0);
+    p3 += dot(p3, p3.yzx + 19.19);
+    return fract((p3.x + p3.y) * p3.z);
+}
+#endif
+
+float minComponent(in vec3 v) {
+    return min(min(v.x, v.y), v.z);
+}
+
+float maxComponent(in vec3 v) {
+    return max(max(v.x, v.y), v.z);
+}
+
+struct PointJacobianT {
+    vec3 point;
+    mat3 jacobianT;
+};

package/Source/Shaders/Voxels/VoxelUtils.js

@@ -0,0 +1,33 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "struct Ray {\n\
+    vec3 pos;\n\
+    vec3 dir;\n\
+    vec3 rawDir;\n\
+};\n\
+\n\
+#if defined(JITTER)\n\
+/**\n\
+ * Generate a pseudo-random value for a given 2D screen coordinate.\n\
+ * Similar to https://www.shadertoy.com/view/4djSRW with a modified hashscale.\n\
+ */\n\
+float hash(vec2 p)\n\
+{\n\
+    vec3 p3 = fract(vec3(p.xyx) * 50.0);\n\
+    p3 += dot(p3, p3.yzx + 19.19);\n\
+    return fract((p3.x + p3.y) * p3.z);\n\
+}\n\
+#endif\n\
+\n\
+float minComponent(in vec3 v) {\n\
+    return min(min(v.x, v.y), v.z);\n\
+}\n\
+\n\
+float maxComponent(in vec3 v) {\n\
+    return max(max(v.x, v.y), v.z);\n\
+}\n\
+\n\
+struct PointJacobianT {\n\
+    vec3 point;\n\
+    mat3 jacobianT;\n\
+};\n\
+";