@cesium/engine 2.0.0 → 2.1.0

package/Source/Shaders/Voxels/Octree.glsl

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

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]