@cesium/engine 2.0.0 → 2.2.0

package/Source/Shaders/Voxels/IntersectionUtils.glsl

@@ -4,59 +4,61 @@
 
 #define NO_HIT (-czm_infinity)
 #define INF_HIT (czm_infinity * 0.5)
+#define RAY_SHIFT (0.000003163)
+#define RAY_SCALE (1.003163)
 
 struct Ray {
     vec3 pos;
     vec3 dir;
+#if defined(SHAPE_BOX)
+    vec3 dInv;
+#endif
+};
+
+struct RayShapeIntersection {
+    vec4 entry;
+    vec4 exit;
 };
 
 struct Intersections {
     // Don't access these member variables directly - call the functions instead.
 
-    #if (INTERSECTION_COUNT > 1)
-        // Store an array of intersections. Each intersection is composed of:
-        //  x for the T value
-        //  y for the shape type - which encodes positive vs negative and entering vs exiting
-        // For example:
-        //  y = 0: positive shape entry
-        //  y = 1: positive shape exit
-        //  y = 2: negative shape entry
-        //  y = 3: negative shape exit
-        vec2 intersections[INTERSECTION_COUNT * 2];
+    // Store an array of ray-surface intersections. Each intersection is composed of:
+    //  .xyz for the surface normal at the intersection point
+    //  .w for the T value
+    // The scale of the normal encodes the shape intersection type:
+    //  length(intersection.xyz) = 1: positive shape entry
+    //  length(intersection.xyz) = 2: positive shape exit
+    //  length(intersection.xyz) = 3: negative shape entry
+    //  length(intersection.xyz) = 4: negative shape exit
+    // INTERSECTION_COUNT is the number of ray-*shape* (volume) intersections,
+    // so we need twice as many to track ray-*surface* intersections
+    vec4 intersections[INTERSECTION_COUNT * 2];
 
+    #if (INTERSECTION_COUNT > 1)
         // Maintain state for future nextIntersection calls
         int index;
         int surroundCount;
         bool surroundIsPositive;
-    #else
-        // When there's only one positive shape intersection none of the extra stuff is needed.
-        float intersections[2];
     #endif
 };
 
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.
-#if (INTERSECTION_COUNT > 1)
-    #define getIntersection(/*inout Intersections*/ ix, /*int*/ index) (ix).intersections[(index)].x
-#else
-    #define getIntersection(/*inout Intersections*/ ix, /*int*/ index) (ix).intersections[(index)]
-#endif
-
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.
-#define getIntersectionPair(/*inout Intersections*/ ix, /*int*/ index) vec2(getIntersection((ix), (index) * 2 + 0), getIntersection((ix), (index) * 2 + 1))
+RayShapeIntersection getFirstIntersection(in Intersections ix) 
+{
+    return RayShapeIntersection(ix.intersections[0], ix.intersections[1]);
+}
 
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.
-#if (INTERSECTION_COUNT > 1)
-    #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*enter*/ enter) (ix).intersections[(index)] = vec2((t), float(!positive) * 2.0 + float(!enter))
-#else
-    #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*enter*/ enter) (ix).intersections[(index)] = (t)
-#endif
+vec4 encodeIntersectionType(vec4 intersection, int index, bool entry)
+{
+    float scale = float(index > 0) * 2.0 + float(!entry) + 1.0;
+    return vec4(intersection.xyz * scale, intersection.w);
+}
 
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.
-#if (INTERSECTION_COUNT > 1)
-    #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec2((entryExit).x, float((index) > 0) * 2.0 + 0.0); (ix).intersections[(index) * 2 + 1] = vec2((entryExit).y, float((index) > 0) * 2.0 + 1.0)
-#else
-    #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = (entryExit).x; (ix).intersections[(index) * 2 + 1] = (entryExit).y
-#endif
+// Use defines instead of real functions because WebGL1 cannot access array with non-constant index.
+#define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*bool*/ enter) (ix).intersections[(index)] = vec4(0.0, float(!positive) * 2.0 + float(!enter) + 1.0, 0.0, (t))
+#define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec4(0.0, float((index) > 0) * 2.0 + 1.0, 0.0, (entryExit).x); (ix).intersections[(index) * 2 + 1] = vec4(0.0, float((index) > 0) * 2.0 + 2.0, 0.0, (entryExit).y)
+#define setSurfaceIntersection(/*inout Intersections*/ ix, /*int*/ index, /*vec4*/ intersection) (ix).intersections[(index)] = intersection;
+#define setShapeIntersection(/*inout Intersections*/ ix, /*int*/ index, /*RayShapeIntersection*/ intersection) (ix).intersections[(index) * 2 + 0] = encodeIntersectionType((intersection).entry, (index), true); (ix).intersections[(index) * 2 + 1] = encodeIntersectionType((intersection).exit, (index), false)
 
 #if (INTERSECTION_COUNT > 1)
 void initializeIntersections(inout Intersections ix) {
@@ -70,21 +72,13 @@ void initializeIntersections(inout Intersections ix) {
             // loop with non-constant condition, so it has to break early instead
             if (i >= n) { break; }
 
-            vec2 intersect0 = ix.intersections[i + 0];
-            vec2 intersect1 = ix.intersections[i + 1];
-
-            float t0 = intersect0.x;
-            float t1 = intersect1.x;
-            float b0 = intersect0.y;
-            float b1 = intersect1.y;
+            vec4 intersect0 = ix.intersections[i + 0];
+            vec4 intersect1 = ix.intersections[i + 1];
 
-            float tmin = min(t0, t1);
-            float tmax = max(t0, t1);
-            float bmin = tmin == t0 ? b0 : b1;
-            float bmax = tmin == t0 ? b1 : b0;
+            bool inOrder = intersect0.w <= intersect1.w;
 
-            ix.intersections[i + 0] = vec2(tmin, bmin);
-            ix.intersections[i + 1] = vec2(tmax, bmax);
+            ix.intersections[i + 0] = inOrder ? intersect0 : intersect1;
+            ix.intersections[i + 1] = inOrder ? intersect1 : intersect0;
         }
     }
 
@@ -96,13 +90,14 @@ void initializeIntersections(inout Intersections ix) {
 #endif
 
 #if (INTERSECTION_COUNT > 1)
-vec2 nextIntersection(inout Intersections ix) {
-    vec2 entryExitT = vec2(NO_HIT);
+RayShapeIntersection nextIntersection(inout Intersections ix) {
+    vec4 surfaceIntersection = vec4(0.0, 0.0, 0.0, NO_HIT);
+    RayShapeIntersection shapeIntersection = RayShapeIntersection(surfaceIntersection, surfaceIntersection);
 
     const int passCount = INTERSECTION_COUNT * 2;
 
     if (ix.index == passCount) {
-        return entryExitT;
+        return shapeIntersection;
     }
 
     for (int i = 0; i < passCount; ++i) {
@@ -114,25 +109,24 @@ vec2 nextIntersection(inout Intersections ix) {
 
         ix.index = i + 1;
 
-        vec2 intersect = ix.intersections[i];
-        float t = intersect.x;
-        bool currShapeIsPositive = intersect.y < 2.0;
-        bool enter = mod(intersect.y, 2.0) == 0.0;
+        surfaceIntersection = ix.intersections[i];
+        int intersectionType = int(length(surfaceIntersection.xyz) - 0.5);
+        bool currShapeIsPositive = intersectionType < 2;
+        bool enter = intMod(intersectionType, 2) == 0;
 
         ix.surroundCount += enter ? +1 : -1;
         ix.surroundIsPositive = currShapeIsPositive ? enter : ix.surroundIsPositive;
 
         // entering positive or exiting negative
         if (ix.surroundCount == 1 && ix.surroundIsPositive && enter == currShapeIsPositive) {
-            entryExitT.x = t;
+            shapeIntersection.entry = surfaceIntersection;
         }
 
         // exiting positive or entering negative after being inside positive
-        // TODO: Can this be simplified?
         bool exitPositive = !enter && currShapeIsPositive && ix.surroundCount == 0;
         bool enterNegativeFromPositive = enter && !currShapeIsPositive && ix.surroundCount == 2 && ix.surroundIsPositive;
         if (exitPositive || enterNegativeFromPositive) {
-            entryExitT.y = t;
+            shapeIntersection.exit = surfaceIntersection;
 
             // entry and exit have been found, so the loop can stop
             if (exitPositive) {
@@ -143,9 +137,8 @@ vec2 nextIntersection(inout Intersections ix) {
         }
     }
 
-    return entryExitT;
+    return shapeIntersection;
 }
 #endif
 
 // NOTE: initializeIntersections, nextIntersection aren't even declared unless INTERSECTION_COUNT > 1
-// export { NO_HIT, INF_HIT, Ray, Intersections, getIntersectionPair, setIntersectionPair, initializeIntersections, nextIntersection };

package/Source/Shaders/Voxels/IntersectionUtils.js

@@ -5,59 +5,61 @@ export default "/* Intersection defines\n\
 \n\
 #define NO_HIT (-czm_infinity)\n\
 #define INF_HIT (czm_infinity * 0.5)\n\
+#define RAY_SHIFT (0.000003163)\n\
+#define RAY_SCALE (1.003163)\n\
 \n\
 struct Ray {\n\
     vec3 pos;\n\
     vec3 dir;\n\
+#if defined(SHAPE_BOX)\n\
+    vec3 dInv;\n\
+#endif\n\
+};\n\
+\n\
+struct RayShapeIntersection {\n\
+    vec4 entry;\n\
+    vec4 exit;\n\
 };\n\
 \n\
 struct Intersections {\n\
     // Don't access these member variables directly - call the functions instead.\n\
 \n\
-    #if (INTERSECTION_COUNT > 1)\n\
-        // Store an array of intersections. Each intersection is composed of:\n\
-        //  x for the T value\n\
-        //  y for the shape type - which encodes positive vs negative and entering vs exiting\n\
-        // For example:\n\
-        //  y = 0: positive shape entry\n\
-        //  y = 1: positive shape exit\n\
-        //  y = 2: negative shape entry\n\
-        //  y = 3: negative shape exit\n\
-        vec2 intersections[INTERSECTION_COUNT * 2];\n\
+    // Store an array of ray-surface intersections. Each intersection is composed of:\n\
+    //  .xyz for the surface normal at the intersection point\n\
+    //  .w for the T value\n\
+    // The scale of the normal encodes the shape intersection type:\n\
+    //  length(intersection.xyz) = 1: positive shape entry\n\
+    //  length(intersection.xyz) = 2: positive shape exit\n\
+    //  length(intersection.xyz) = 3: negative shape entry\n\
+    //  length(intersection.xyz) = 4: negative shape exit\n\
+    // INTERSECTION_COUNT is the number of ray-*shape* (volume) intersections,\n\
+    // so we need twice as many to track ray-*surface* intersections\n\
+    vec4 intersections[INTERSECTION_COUNT * 2];\n\
 \n\
+    #if (INTERSECTION_COUNT > 1)\n\
         // Maintain state for future nextIntersection calls\n\
         int index;\n\
         int surroundCount;\n\
         bool surroundIsPositive;\n\
-    #else\n\
-        // When there's only one positive shape intersection none of the extra stuff is needed.\n\
-        float intersections[2];\n\
     #endif\n\
 };\n\
 \n\
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.\n\
-#if (INTERSECTION_COUNT > 1)\n\
-    #define getIntersection(/*inout Intersections*/ ix, /*int*/ index) (ix).intersections[(index)].x\n\
-#else\n\
-    #define getIntersection(/*inout Intersections*/ ix, /*int*/ index) (ix).intersections[(index)]\n\
-#endif\n\
-\n\
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.\n\
-#define getIntersectionPair(/*inout Intersections*/ ix, /*int*/ index) vec2(getIntersection((ix), (index) * 2 + 0), getIntersection((ix), (index) * 2 + 1))\n\
+RayShapeIntersection getFirstIntersection(in Intersections ix) \n\
+{\n\
+    return RayShapeIntersection(ix.intersections[0], ix.intersections[1]);\n\
+}\n\
 \n\
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.\n\
-#if (INTERSECTION_COUNT > 1)\n\
-    #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*enter*/ enter) (ix).intersections[(index)] = vec2((t), float(!positive) * 2.0 + float(!enter))\n\
-#else\n\
-    #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*enter*/ enter) (ix).intersections[(index)] = (t)\n\
-#endif\n\
+vec4 encodeIntersectionType(vec4 intersection, int index, bool entry)\n\
+{\n\
+    float scale = float(index > 0) * 2.0 + float(!entry) + 1.0;\n\
+    return vec4(intersection.xyz * scale, intersection.w);\n\
+}\n\
 \n\
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.\n\
-#if (INTERSECTION_COUNT > 1)\n\
-    #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec2((entryExit).x, float((index) > 0) * 2.0 + 0.0); (ix).intersections[(index) * 2 + 1] = vec2((entryExit).y, float((index) > 0) * 2.0 + 1.0)\n\
-#else\n\
-    #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = (entryExit).x; (ix).intersections[(index) * 2 + 1] = (entryExit).y\n\
-#endif\n\
+// Use defines instead of real functions because WebGL1 cannot access array with non-constant index.\n\
+#define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*bool*/ enter) (ix).intersections[(index)] = vec4(0.0, float(!positive) * 2.0 + float(!enter) + 1.0, 0.0, (t))\n\
+#define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec4(0.0, float((index) > 0) * 2.0 + 1.0, 0.0, (entryExit).x); (ix).intersections[(index) * 2 + 1] = vec4(0.0, float((index) > 0) * 2.0 + 2.0, 0.0, (entryExit).y)\n\
+#define setSurfaceIntersection(/*inout Intersections*/ ix, /*int*/ index, /*vec4*/ intersection) (ix).intersections[(index)] = intersection;\n\
+#define setShapeIntersection(/*inout Intersections*/ ix, /*int*/ index, /*RayShapeIntersection*/ intersection) (ix).intersections[(index) * 2 + 0] = encodeIntersectionType((intersection).entry, (index), true); (ix).intersections[(index) * 2 + 1] = encodeIntersectionType((intersection).exit, (index), false)\n\
 \n\
 #if (INTERSECTION_COUNT > 1)\n\
 void initializeIntersections(inout Intersections ix) {\n\
@@ -71,21 +73,13 @@ void initializeIntersections(inout Intersections ix) {\n\
             // loop with non-constant condition, so it has to break early instead\n\
             if (i >= n) { break; }\n\
 \n\
-            vec2 intersect0 = ix.intersections[i + 0];\n\
-            vec2 intersect1 = ix.intersections[i + 1];\n\
-\n\
-            float t0 = intersect0.x;\n\
-            float t1 = intersect1.x;\n\
-            float b0 = intersect0.y;\n\
-            float b1 = intersect1.y;\n\
+            vec4 intersect0 = ix.intersections[i + 0];\n\
+            vec4 intersect1 = ix.intersections[i + 1];\n\
 \n\
-            float tmin = min(t0, t1);\n\
-            float tmax = max(t0, t1);\n\
-            float bmin = tmin == t0 ? b0 : b1;\n\
-            float bmax = tmin == t0 ? b1 : b0;\n\
+            bool inOrder = intersect0.w <= intersect1.w;\n\
 \n\
-            ix.intersections[i + 0] = vec2(tmin, bmin);\n\
-            ix.intersections[i + 1] = vec2(tmax, bmax);\n\
+            ix.intersections[i + 0] = inOrder ? intersect0 : intersect1;\n\
+            ix.intersections[i + 1] = inOrder ? intersect1 : intersect0;\n\
         }\n\
     }\n\
 \n\
@@ -97,13 +91,14 @@ void initializeIntersections(inout Intersections ix) {\n\
 #endif\n\
 \n\
 #if (INTERSECTION_COUNT > 1)\n\
-vec2 nextIntersection(inout Intersections ix) {\n\
-    vec2 entryExitT = vec2(NO_HIT);\n\
+RayShapeIntersection nextIntersection(inout Intersections ix) {\n\
+    vec4 surfaceIntersection = vec4(0.0, 0.0, 0.0, NO_HIT);\n\
+    RayShapeIntersection shapeIntersection = RayShapeIntersection(surfaceIntersection, surfaceIntersection);\n\
 \n\
     const int passCount = INTERSECTION_COUNT * 2;\n\
 \n\
     if (ix.index == passCount) {\n\
-        return entryExitT;\n\
+        return shapeIntersection;\n\
     }\n\
 \n\
     for (int i = 0; i < passCount; ++i) {\n\
@@ -115,25 +110,24 @@ vec2 nextIntersection(inout Intersections ix) {\n\
 \n\
         ix.index = i + 1;\n\
 \n\
-        vec2 intersect = ix.intersections[i];\n\
-        float t = intersect.x;\n\
-        bool currShapeIsPositive = intersect.y < 2.0;\n\
-        bool enter = mod(intersect.y, 2.0) == 0.0;\n\
+        surfaceIntersection = ix.intersections[i];\n\
+        int intersectionType = int(length(surfaceIntersection.xyz) - 0.5);\n\
+        bool currShapeIsPositive = intersectionType < 2;\n\
+        bool enter = intMod(intersectionType, 2) == 0;\n\
 \n\
         ix.surroundCount += enter ? +1 : -1;\n\
         ix.surroundIsPositive = currShapeIsPositive ? enter : ix.surroundIsPositive;\n\
 \n\
         // entering positive or exiting negative\n\
         if (ix.surroundCount == 1 && ix.surroundIsPositive && enter == currShapeIsPositive) {\n\
-            entryExitT.x = t;\n\
+            shapeIntersection.entry = surfaceIntersection;\n\
         }\n\
 \n\
         // exiting positive or entering negative after being inside positive\n\
-        // TODO: Can this be simplified?\n\
         bool exitPositive = !enter && currShapeIsPositive && ix.surroundCount == 0;\n\
         bool enterNegativeFromPositive = enter && !currShapeIsPositive && ix.surroundCount == 2 && ix.surroundIsPositive;\n\
         if (exitPositive || enterNegativeFromPositive) {\n\
-            entryExitT.y = t;\n\
+            shapeIntersection.exit = surfaceIntersection;\n\
 \n\
             // entry and exit have been found, so the loop can stop\n\
             if (exitPositive) {\n\
@@ -144,10 +138,9 @@ vec2 nextIntersection(inout Intersections ix) {\n\
         }\n\
     }\n\
 \n\
-    return entryExitT;\n\
+    return shapeIntersection;\n\
 }\n\
 #endif\n\
 \n\
 // NOTE: initializeIntersections, nextIntersection aren't even declared unless INTERSECTION_COUNT > 1\n\
-// export { NO_HIT, INF_HIT, Ray, Intersections, getIntersectionPair, setIntersectionPair, initializeIntersections, nextIntersection };\n\
 ";

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
 }