@cesium/engine 2.0.0 → 2.2.0

package/Source/Shaders/Voxels/Octree.js

@@ -9,11 +9,11 @@ export default "// These octree flags must be in sync with GpuOctreeFlag in Voxe
 uniform sampler2D u_octreeInternalNodeTexture;\n\
 uniform vec2 u_octreeInternalNodeTexelSizeUv;\n\
 uniform int u_octreeInternalNodeTilesPerRow;\n\
+#if (SAMPLE_COUNT > 1)\n\
 uniform sampler2D u_octreeLeafNodeTexture;\n\
 uniform vec2 u_octreeLeafNodeTexelSizeUv;\n\
 uniform int u_octreeLeafNodeTilesPerRow;\n\
-\n\
-uniform float u_stepSize;\n\
+#endif\n\
 \n\
 struct OctreeNodeData {\n\
     int data;\n\
@@ -21,14 +21,13 @@ struct OctreeNodeData {\n\
 };\n\
 \n\
 struct TraversalData {\n\
-    float stepT;\n\
     ivec4 octreeCoords;\n\
     int parentOctreeIndex;\n\
 };\n\
 \n\
 struct SampleData {\n\
     int megatextureIndex;\n\
-    bool usingParentMegatextureIndex;\n\
+    ivec4 tileCoords;\n\
     vec3 tileUv;\n\
     #if (SAMPLE_COUNT > 1)\n\
         float weight;\n\
@@ -80,85 +79,78 @@ int getOctreeParentIndex(in int octreeIndex) {\n\
 * into the uv-space of a tile within the tileset\n\
 */\n\
 vec3 getTileUv(in vec3 shapePosition, in ivec4 octreeCoords) {\n\
-	// TODO: use bit-shifting (only in WebGL2)\n\
+	// PERFORMANCE_IDEA: use bit-shifting (only in WebGL2)\n\
     float dimAtLevel = pow(2.0, float(octreeCoords.w));\n\
     return shapePosition * dimAtLevel - vec3(octreeCoords.xyz);\n\
 }\n\
 \n\
-void setSampleUv(in vec3 shapePosition, in ivec4 octreeCoords, inout SampleData sampleData) {\n\
-    ivec4 sampleCoords = sampleData.usingParentMegatextureIndex\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\
         ? ivec4(octreeCoords.xyz / 2, octreeCoords.w - 1)\n\
         : octreeCoords;\n\
-    sampleData.tileUv = getTileUv(shapePosition, sampleCoords);\n\
-}\n\
-\n\
-void getOctreeLeafSampleData(in OctreeNodeData data, out SampleData sampleData) {\n\
-    sampleData.megatextureIndex = data.data;\n\
-    sampleData.usingParentMegatextureIndex = data.flag == OCTREE_FLAG_PACKED_LEAF_FROM_PARENT;\n\
 }\n\
 \n\
 #if (SAMPLE_COUNT > 1)\n\
-void getOctreeLeafSampleDatas(in OctreeNodeData data, out SampleData sampleData0, out SampleData sampleData1) {\n\
+void getOctreeLeafSampleDatas(in OctreeNodeData data, in ivec4 octreeCoords, out SampleData sampleDatas[SAMPLE_COUNT]) {\n\
     int leafIndex = data.data;\n\
     int leafNodeTexelCount = 2;\n\
     // Adding 0.5 moves to the center of the texel\n\
     float leafCoordXStart = float(intMod(leafIndex, u_octreeLeafNodeTilesPerRow) * leafNodeTexelCount) + 0.5;\n\
     float leafCoordY = float(leafIndex / u_octreeLeafNodeTilesPerRow) + 0.5;\n\
 \n\
+    // Get an interpolation weight and a flag to determine whether to read the parent texture\n\
     vec2 leafUv0 = u_octreeLeafNodeTexelSizeUv * vec2(leafCoordXStart + 0.0, leafCoordY);\n\
-    vec2 leafUv1 = u_octreeLeafNodeTexelSizeUv * vec2(leafCoordXStart + 1.0, leafCoordY);\n\
     vec4 leafData0 = texture(u_octreeLeafNodeTexture, leafUv0);\n\
-    vec4 leafData1 = texture(u_octreeLeafNodeTexture, leafUv1);\n\
-\n\
     float lerp = normU8x2_toFloat(leafData0.xy);\n\
-\n\
-    sampleData0.megatextureIndex = normU8x2_toInt(leafData1.xy);\n\
-    sampleData1.megatextureIndex = normU8x2_toInt(leafData1.zw);\n\
+    sampleDatas[0].weight = 1.0 - lerp;\n\
+    sampleDatas[1].weight = lerp;\n\
     // TODO: this looks wrong? Should be comparing to OCTREE_FLAG_PACKED_LEAF_FROM_PARENT\n\
-    sampleData0.usingParentMegatextureIndex = normU8_toInt(leafData0.z) == 1;\n\
-    sampleData1.usingParentMegatextureIndex = normU8_toInt(leafData0.w) == 1;\n\
-    sampleData0.weight = 1.0 - lerp;\n\
-    sampleData1.weight = lerp;\n\
+    sampleDatas[0].tileCoords = (normU8_toInt(leafData0.z) == 1)\n\
+        ? ivec4(octreeCoords.xyz / 2, octreeCoords.w - 1)\n\
+        : octreeCoords;\n\
+    sampleDatas[1].tileCoords = (normU8_toInt(leafData0.w) == 1)\n\
+        ? ivec4(octreeCoords.xyz / 2, octreeCoords.w - 1)\n\
+        : octreeCoords;\n\
+\n\
+    // Get megatexture indices for both samples\n\
+    vec2 leafUv1 = u_octreeLeafNodeTexelSizeUv * vec2(leafCoordXStart + 1.0, leafCoordY);\n\
+    vec4 leafData1 = texture(u_octreeLeafNodeTexture, leafUv1);\n\
+    sampleDatas[0].megatextureIndex = normU8x2_toInt(leafData1.xy);\n\
+    sampleDatas[1].megatextureIndex = normU8x2_toInt(leafData1.zw);\n\
 }\n\
 #endif\n\
 \n\
-void traverseOctreeDownwards(in vec3 shapePosition, inout TraversalData traversalData, out SampleData sampleDatas[SAMPLE_COUNT]) {\n\
+OctreeNodeData traverseOctreeDownwards(in vec3 shapePosition, inout TraversalData traversalData) {\n\
     float sizeAtLevel = 1.0 / pow(2.0, float(traversalData.octreeCoords.w));\n\
     vec3 start = vec3(traversalData.octreeCoords.xyz) * sizeAtLevel;\n\
     vec3 end = start + vec3(sizeAtLevel);\n\
+    OctreeNodeData childData;\n\
 \n\
     for (int i = 0; i < OCTREE_MAX_LEVELS; ++i) {\n\
         // Find out which octree child contains the position\n\
         // 0 if before center, 1 if after\n\
         vec3 center = 0.5 * (start + end);\n\
         vec3 childCoord = step(center, shapePosition);\n\
-\n\
-        OctreeNodeData childData = getOctreeChildData(traversalData.parentOctreeIndex, ivec3(childCoord));\n\
 \n\
         // Get octree coords for the next level down\n\
         ivec4 octreeCoords = traversalData.octreeCoords;\n\
         traversalData.octreeCoords = ivec4(octreeCoords.xyz * 2 + ivec3(childCoord), octreeCoords.w + 1);\n\
 \n\
-        if (childData.flag == OCTREE_FLAG_INTERNAL) {\n\
-            // interior tile - keep going deeper\n\
-            start = mix(start, center, childCoord);\n\
-            end = mix(center, end, childCoord);\n\
-            traversalData.parentOctreeIndex = childData.data;\n\
-        } else {\n\
+        childData = getOctreeChildData(traversalData.parentOctreeIndex, ivec3(childCoord));\n\
+\n\
+        if (childData.flag != OCTREE_FLAG_INTERNAL) {\n\
             // leaf tile - stop traversing\n\
-            float dimAtLevel = pow(2.0, float(traversalData.octreeCoords.w));\n\
-            traversalData.stepT = u_stepSize / dimAtLevel;\n\
-            #if (SAMPLE_COUNT == 1)\n\
-                getOctreeLeafSampleData(childData, sampleDatas[0]);\n\
-                setSampleUv(shapePosition, traversalData.octreeCoords, sampleDatas[0]);\n\
-            #else\n\
-                getOctreeLeafSampleDatas(childData, sampleDatas[0], sampleDatas[1]);\n\
-                setSampleUv(shapePosition, traversalData.octreeCoords, sampleDatas[0]);\n\
-                setSampleUv(shapePosition, traversalData.octreeCoords, sampleDatas[1]);\n\
-            #endif\n\
-            return;\n\
+            break;\n\
         }\n\
+\n\
+        // interior tile - keep going deeper\n\
+        start = mix(start, center, childCoord);\n\
+        end = mix(center, end, childCoord);\n\
+        traversalData.parentOctreeIndex = childData.data;\n\
     }\n\
+\n\
+    return childData;\n\
 }\n\
 \n\
 /**\n\
@@ -169,21 +161,19 @@ void traverseOctreeFromBeginning(in vec3 shapePosition, out TraversalData traver
     traversalData.octreeCoords = ivec4(0);\n\
     traversalData.parentOctreeIndex = 0;\n\
 \n\
-    OctreeNodeData rootData = getOctreeNodeData(vec2(0.0));\n\
-    if (rootData.flag == OCTREE_FLAG_LEAF) {\n\
-        // No child data, only the root tile has data\n\
-        traversalData.stepT = u_stepSize;\n\
-        #if (SAMPLE_COUNT == 1)\n\
-            getOctreeLeafSampleData(rootData, sampleDatas[0]);\n\
-            setSampleUv(shapePosition, traversalData.octreeCoords, sampleDatas[0]);\n\
-        #else\n\
-            getOctreeLeafSampleDatas(rootData, sampleDatas[0], sampleDatas[1]);\n\
-            setSampleUv(shapePosition, traversalData.octreeCoords, sampleDatas[0]);\n\
-            setSampleUv(shapePosition, traversalData.octreeCoords, sampleDatas[1]);\n\
-        #endif\n\
-    } else {\n\
-        traverseOctreeDownwards(shapePosition, traversalData, sampleDatas);\n\
+    OctreeNodeData nodeData = getOctreeNodeData(vec2(0.0));\n\
+    if (nodeData.flag != OCTREE_FLAG_LEAF) {\n\
+        nodeData = traverseOctreeDownwards(shapePosition, traversalData);\n\
     }\n\
+\n\
+    #if (SAMPLE_COUNT == 1)\n\
+        getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);\n\
+        sampleDatas[0].tileUv = getTileUv(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\
+    #endif\n\
 }\n\
 \n\
 bool inRange(in vec3 v, in vec3 minVal, in vec3 maxVal) {\n\
@@ -200,24 +190,33 @@ 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\
-            setSampleUv(shapePosition, traversalData.octreeCoords, sampleDatas[i]);\n\
+            sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
         }\n\
-    } else {\n\
-        // Go up tree\n\
-        for (int i = 0; i < OCTREE_MAX_LEVELS; ++i)\n\
-        {\n\
-            traversalData.octreeCoords.xyz /= 2;\n\
-            traversalData.octreeCoords.w -= 1;\n\
-\n\
-            if (!insideTile(shapePosition, traversalData.octreeCoords)) {\n\
-                traversalData.parentOctreeIndex = getOctreeParentIndex(traversalData.parentOctreeIndex);\n\
-            } else {\n\
-                break;\n\
-            }\n\
+        return;\n\
+    }\n\
+\n\
+    // Go up tree until we find a parent tile containing shapePosition\n\
+    for (int i = 0; i < OCTREE_MAX_LEVELS; ++i) {\n\
+        traversalData.octreeCoords.xyz /= 2;\n\
+        traversalData.octreeCoords.w -= 1;\n\
+\n\
+        if (insideTile(shapePosition, traversalData.octreeCoords)) {\n\
+            break;\n\
         }\n\
 \n\
-        // Go down tree\n\
-        traverseOctreeDownwards(shapePosition, traversalData, sampleDatas);\n\
+        traversalData.parentOctreeIndex = getOctreeParentIndex(traversalData.parentOctreeIndex);\n\
     }\n\
+\n\
+    // Go down tree\n\
+    OctreeNodeData nodeData = traverseOctreeDownwards(shapePosition, traversalData);\n\
+\n\
+    #if (SAMPLE_COUNT == 1)\n\
+        getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);\n\
+        sampleDatas[0].tileUv = getTileUv(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\
+    #endif\n\
 }\n\
 ";

package/Source/Shaders/Voxels/VoxelFS.glsl

@@ -13,6 +13,7 @@
 
 uniform mat3 u_transformDirectionViewToLocal;
 uniform vec3 u_cameraPositionUv;
+uniform float u_stepSize;
 
 #if defined(PICKING)
     uniform vec4 u_pickColor;
@@ -27,6 +28,20 @@ float hash(vec2 p)
 }
 #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
+}
+
 void main()
 {
     vec4 fragCoord = gl_FragCoord;
@@ -35,34 +50,36 @@ 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);
+    #else
+        Ray viewRayUv = Ray(viewPosUv, viewDirUv);
+    #endif
 
     Intersections ix;
-    vec2 entryExitT = intersectScene(screenCoord, viewPosUv, viewDirUv, ix);
+    RayShapeIntersection shapeIntersection = intersectScene(screenCoord, viewRayUv, ix);
 
     // Exit early if the scene was completely missed.
-    if (entryExitT.x == NO_HIT) {
+    if (shapeIntersection.entry.w == NO_HIT) {
         discard;
     }
 
-    float currT = entryExitT.x;
-    float endT = entryExitT.y;
+    float currT = shapeIntersection.entry.w * RAY_SCALE;
+    float endT = shapeIntersection.exit.w;
     vec3 positionUv = viewPosUv + currT * viewDirUv;
-    // TODO: is it possible for this to be out of bounds, and does it matter?
     vec3 positionUvShapeSpace = convertUvToShapeUvSpace(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);
 
-    // TODO:
-    //  - jitter doesn't affect the first traversal?
-    //  - jitter is always > 0?
-    //  - jitter is only applied at one step?
     #if defined(JITTER)
         float noise = hash(screenCoord); // [0,1]
-        currT += noise * traversalData.stepT;
-        positionUv += noise * traversalData.stepT * viewDirUv;
+        currT += noise * step.w;
+        positionUv += noise * step.w * viewDirUv;
     #endif
 
     FragmentInput fragmentInput;
@@ -83,7 +100,8 @@ void main()
         fragmentInput.voxel.positionUvLocal = sampleDatas[0].tileUv;
         fragmentInput.voxel.viewDirUv = viewDirUv;
         fragmentInput.voxel.viewDirWorld = viewDirWorld;
-        fragmentInput.voxel.travelDistance = traversalData.stepT;
+        fragmentInput.voxel.surfaceNormal = step.xyz;
+        fragmentInput.voxel.travelDistance = step.w;
 
         // Run the custom shader
         czm_modelMaterial materialOutput;
@@ -103,36 +121,38 @@ void main()
             break;
         }
 
-        if (traversalData.stepT == 0.0) {
-            // Shape is infinitely thin, no need to traverse further
-            break;
+        if (step.w == 0.0) {
+            // Shape is infinitely thin. The ray may have hit the edge of a
+            // foreground voxel. Step ahead slightly to check for more voxels
+            step.w == 0.00001;
         }
 
         // Keep raymarching
-        currT += traversalData.stepT;
-        positionUv += traversalData.stepT * viewDirUv;
+        currT += step.w;
+        positionUv += step.w * viewDirUv;
 
         // Check if there's more intersections.
         if (currT > endT) {
             #if (INTERSECTION_COUNT == 1)
                 break;
             #else
-                vec2 entryExitT = nextIntersection(ix);
-                if (entryExitT.x == NO_HIT) {
+                shapeIntersection = nextIntersection(ix);
+                if (shapeIntersection.entry.w == NO_HIT) {
                     break;
                 } else {
                     // Found another intersection. Resume raymarching there
-                    currT = entryExitT.x;
-                    endT = entryExitT.y;
+                    currT = shapeIntersection.entry.w * RAY_SCALE;
+                    endT = shapeIntersection.exit.w;
                     positionUv = viewPosUv + currT * viewDirUv;
                 }
             #endif
         }
 
         // Traverse the tree from the current ray position.
-        // This is similar to traverseOctree but is faster when the ray is in the same tile as the previous step.
+        // 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);
     }
 
     // Convert the alpha from [0,ALPHA_ACCUM_MAX] to [0,1]

package/Source/Shaders/Voxels/VoxelFS.js

@@ -14,6 +14,7 @@ export default "// See Intersection.glsl for the definition of intersectScene\n\
 \n\
 uniform mat3 u_transformDirectionViewToLocal;\n\
 uniform vec3 u_cameraPositionUv;\n\
+uniform float u_stepSize;\n\
 \n\
 #if defined(PICKING)\n\
     uniform vec4 u_pickColor;\n\
@@ -28,6 +29,20 @@ float hash(vec2 p)\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\
+}\n\
+\n\
 void main()\n\
 {\n\
     vec4 fragCoord = gl_FragCoord;\n\
@@ -36,34 +51,36 @@ 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\
+    #else\n\
+        Ray viewRayUv = Ray(viewPosUv, viewDirUv);\n\
+    #endif\n\
 \n\
     Intersections ix;\n\
-    vec2 entryExitT = intersectScene(screenCoord, viewPosUv, viewDirUv, ix);\n\
+    RayShapeIntersection shapeIntersection = intersectScene(screenCoord, viewRayUv, ix);\n\
 \n\
     // Exit early if the scene was completely missed.\n\
-    if (entryExitT.x == NO_HIT) {\n\
+    if (shapeIntersection.entry.w == NO_HIT) {\n\
         discard;\n\
     }\n\
 \n\
-    float currT = entryExitT.x;\n\
-    float endT = entryExitT.y;\n\
+    float currT = shapeIntersection.entry.w * RAY_SCALE;\n\
+    float endT = shapeIntersection.exit.w;\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\
+    vec4 step = getStepSize(sampleDatas[0], viewRayUv, shapeIntersection);\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\
+        currT += noise * step.w;\n\
+        positionUv += noise * step.w * viewDirUv;\n\
     #endif\n\
 \n\
     FragmentInput fragmentInput;\n\
@@ -84,7 +101,8 @@ void main()\n\
         fragmentInput.voxel.positionUvLocal = sampleDatas[0].tileUv;\n\
         fragmentInput.voxel.viewDirUv = viewDirUv;\n\
         fragmentInput.voxel.viewDirWorld = viewDirWorld;\n\
-        fragmentInput.voxel.travelDistance = traversalData.stepT;\n\
+        fragmentInput.voxel.surfaceNormal = step.xyz;\n\
+        fragmentInput.voxel.travelDistance = step.w;\n\
 \n\
         // Run the custom shader\n\
         czm_modelMaterial materialOutput;\n\
@@ -104,36 +122,38 @@ void main()\n\
             break;\n\
         }\n\
 \n\
-        if (traversalData.stepT == 0.0) {\n\
-            // Shape is infinitely thin, no need to traverse further\n\
-            break;\n\
+        if (step.w == 0.0) {\n\
+            // Shape is infinitely thin. The ray may have hit the edge of a\n\
+            // foreground voxel. Step ahead slightly to check for more voxels\n\
+            step.w == 0.00001;\n\
         }\n\
 \n\
         // Keep raymarching\n\
-        currT += traversalData.stepT;\n\
-        positionUv += traversalData.stepT * viewDirUv;\n\
+        currT += step.w;\n\
+        positionUv += step.w * 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\
+                shapeIntersection = nextIntersection(ix);\n\
+                if (shapeIntersection.entry.w == NO_HIT) {\n\
                     break;\n\
                 } else {\n\
                     // Found another intersection. Resume raymarching there\n\
-                    currT = entryExitT.x;\n\
-                    endT = entryExitT.y;\n\
+                    currT = shapeIntersection.entry.w * RAY_SCALE;\n\
+                    endT = shapeIntersection.exit.w;\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\
+        // 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\
     }\n\
 \n\
     // Convert the alpha from [0,ALPHA_ACCUM_MAX] to [0,1]\n\

package/Source/Shaders/Voxels/convertUvToBox.glsl

@@ -8,9 +8,17 @@
 #endif
 
 vec3 convertUvToShapeUvSpace(in vec3 positionUv) {
-    #if defined(BOX_HAS_SHAPE_BOUNDS)
-        return positionUv * u_boxUvToShapeUvScale + u_boxUvToShapeUvTranslate;
-    #else
-        return positionUv;
-    #endif
+#if defined(BOX_HAS_SHAPE_BOUNDS)
+    return positionUv * u_boxUvToShapeUvScale + u_boxUvToShapeUvTranslate;
+#else
+    return positionUv;
+#endif
+}
+
+vec3 convertShapeUvToUvSpace(in vec3 shapeUv) {
+#if defined(BOX_HAS_SHAPE_BOUNDS)
+    return (shapeUv - u_boxUvToShapeUvTranslate) / u_boxUvToShapeUvScale;
+#else
+    return shapeUv;
+#endif
 }

package/Source/Shaders/Voxels/convertUvToBox.js

@@ -9,10 +9,18 @@ export default "/* Box defines (set in Scene/VoxelBoxShape.js)\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\
+#if defined(BOX_HAS_SHAPE_BOUNDS)\n\
+    return positionUv * u_boxUvToShapeUvScale + u_boxUvToShapeUvTranslate;\n\
+#else\n\
+    return positionUv;\n\
+#endif\n\
+}\n\
+\n\
+vec3 convertShapeUvToUvSpace(in vec3 shapeUv) {\n\
+#if defined(BOX_HAS_SHAPE_BOUNDS)\n\
+    return (shapeUv - u_boxUvToShapeUvTranslate) / u_boxUvToShapeUvScale;\n\
+#else\n\
+    return shapeUv;\n\
+#endif\n\
 }\n\
 ";