@cesium/engine 1.0.0 → 1.1.0

package/Source/Shaders/Voxels/IntersectionUtils.js

@@ -0,0 +1,153 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/* Intersection defines\n\
+#define INTERSECTION_COUNT ###\n\
+*/\n\
+\n\
+#define NO_HIT (-czm_infinity)\n\
+#define INF_HIT (czm_infinity * 0.5)\n\
+\n\
+struct Ray {\n\
+    vec3 pos;\n\
+    vec3 dir;\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\
+\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\
+\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\
+\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\
+\n\
+#if (INTERSECTION_COUNT > 1)\n\
+void initializeIntersections(inout Intersections ix) {\n\
+    // Sort the intersections from min T to max T with bubble sort.\n\
+    // Note: If this sorting function changes, some of the intersection test may\n\
+    // need to be updated. Search for \"bubble sort\" to find those areas.\n\
+    const int sortPasses = INTERSECTION_COUNT * 2 - 1;\n\
+    for (int n = sortPasses; n > 0; --n) {\n\
+        for (int i = 0; i < sortPasses; ++i) {\n\
+            // The loop should be: for (i = 0; i < n; ++i) {...} but WebGL1 cannot\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\
+\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\
+\n\
+            ix.intersections[i + 0] = vec2(tmin, bmin);\n\
+            ix.intersections[i + 1] = vec2(tmax, bmax);\n\
+        }\n\
+    }\n\
+\n\
+    // Prepare initial state for nextIntersection\n\
+    ix.index = 0;\n\
+    ix.surroundCount = 0;\n\
+    ix.surroundIsPositive = false;\n\
+}\n\
+#endif\n\
+\n\
+#if (INTERSECTION_COUNT > 1)\n\
+vec2 nextIntersection(inout Intersections ix) {\n\
+    vec2 entryExitT = vec2(NO_HIT);\n\
+\n\
+    const int passCount = INTERSECTION_COUNT * 2;\n\
+\n\
+    if (ix.index == passCount) {\n\
+        return entryExitT;\n\
+    }\n\
+\n\
+    for (int i = 0; i < passCount; ++i) {\n\
+        // The loop should be: for (i = ix.index; i < passCount; ++i) {...} but WebGL1 cannot\n\
+        // loop with non-constant condition, so it has to continue instead.\n\
+        if (i < ix.index) {\n\
+            continue;\n\
+        }\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\
+\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\
+        }\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\
+\n\
+            // entry and exit have been found, so the loop can stop\n\
+            if (exitPositive) {\n\
+                // After exiting positive shape there is nothing left to intersect, so jump to the end index.\n\
+                ix.index = passCount;\n\
+            }\n\
+            break;\n\
+        }\n\
+    }\n\
+\n\
+    return entryExitT;\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/Megatexture.glsl

@@ -0,0 +1,136 @@
+// See Octree.glsl for the definitions of SampleData and intMod
+
+/* Megatexture defines (set in Scene/VoxelRenderResources.js)
+#define SAMPLE_COUNT ###
+#define NEAREST_SAMPLING
+#define PADDING
+*/
+
+uniform ivec2 u_megatextureSliceDimensions; // number of slices per tile, in two dimensions
+uniform ivec2 u_megatextureTileDimensions; // number of tiles per megatexture, in two dimensions
+uniform vec2 u_megatextureVoxelSizeUv;
+uniform vec2 u_megatextureSliceSizeUv;
+uniform vec2 u_megatextureTileSizeUv;
+
+uniform ivec3 u_dimensions; // does not include padding
+#if defined(PADDING)
+    uniform ivec3 u_paddingBefore;
+    uniform ivec3 u_paddingAfter;
+#endif
+
+// Integer min, max, clamp: For WebGL1 only
+int intMin(int a, int b) {
+    return a <= b ? a : b;
+}
+int intMax(int a, int b) {
+    return a >= b ? a : b;
+}
+int intClamp(int v, int minVal, int maxVal) {
+    return intMin(intMax(v, minVal), maxVal);
+}
+
+vec2 index1DTo2DTexcoord(int index, ivec2 dimensions, vec2 uvScale)
+{
+    int indexX = intMod(index, dimensions.x);
+    int indexY = index / dimensions.x;
+    return vec2(indexX, indexY) * uvScale;
+}
+
+/*
+    How is 3D data stored in a 2D megatexture?
+
+    In this example there is only one loaded tile and it has 2x2x2 voxels (8 voxels total).
+    The data is sliced by Z. The data at Z = 0 is placed in texels (0,0), (0,1), (1,0), (1,1) and
+    the data at Z = 1 is placed in texels (2,0), (2,1), (3,0), (3,1).
+    Note that there could be empty space in the megatexture because it's a power of two.
+
+      0   1   2   3
+    +---+---+---+---+
+    |   |   |   |   | 3
+    +---+---+---+---+
+    |   |   |   |   | 2
+    +-------+-------+
+    |010|110|011|111| 1
+    |--- ---|--- ---|
+    |000|100|001|101| 0
+    +-------+-------+
+
+    When doing linear interpolation the megatexture needs to be sampled twice: once for
+    the Z slice above the voxel coordinate and once for the slice below. The two slices
+    are interpolated with fract(coord.z - 0.5). For example, a Z coordinate of 1.0 is
+    halfway between two Z slices so the interpolation factor is 0.5. Below is a side view
+    of the 3D voxel grid with voxel coordinates on the left side.
+
+    2 +---+
+      |001|
+    1 +-z-+
+      |000|
+    0 +---+
+
+    When doing nearest neighbor the megatexture only needs to be sampled once at the closest Z slice.
+*/
+
+Properties getPropertiesFromMegatexture(in SampleData sampleData) {
+    vec3 tileUv = clamp(sampleData.tileUv, vec3(0.0), vec3(1.0)); // TODO is the clamp necessary?
+    int tileIndex = sampleData.megatextureIndex;
+    vec3 voxelCoord = tileUv * vec3(u_dimensions);
+    ivec3 voxelDimensions = u_dimensions;
+
+    #if defined(PADDING)
+        voxelDimensions += u_paddingBefore + u_paddingAfter;
+        voxelCoord += vec3(u_paddingBefore);
+    #endif
+
+    #if defined(NEAREST_SAMPLING)
+        // Round to the center of the nearest voxel
+        voxelCoord = floor(voxelCoord + vec3(0.5));
+    #endif
+
+    // Tile location
+    vec2 tileUvOffset = index1DTo2DTexcoord(tileIndex, u_megatextureTileDimensions, u_megatextureTileSizeUv);
+
+    // Slice location
+    float slice = voxelCoord.z - 0.5;
+    int sliceIndex = int(floor(slice));
+    int sliceIndex0 = intClamp(sliceIndex, 0, voxelDimensions.z - 1);
+    vec2 sliceUvOffset0 = index1DTo2DTexcoord(sliceIndex0, u_megatextureSliceDimensions, u_megatextureSliceSizeUv);
+
+    // Voxel location
+    vec2 voxelUvOffset = clamp(voxelCoord.xy, vec2(0.5), vec2(voxelDimensions.xy) - vec2(0.5)) * u_megatextureVoxelSizeUv;
+
+    // Final location in the megatexture
+    vec2 uv0 = tileUvOffset + sliceUvOffset0 + voxelUvOffset;
+
+    #if defined(NEAREST_SAMPLING)
+        return getPropertiesFromMegatextureAtUv(uv0);
+    #else
+        float sliceLerp = fract(slice);
+        int sliceIndex1 = intMin(sliceIndex + 1, voxelDimensions.z - 1);
+        vec2 sliceUvOffset1 = index1DTo2DTexcoord(sliceIndex1, u_megatextureSliceDimensions, u_megatextureSliceSizeUv);
+        vec2 uv1 = tileUvOffset + sliceUvOffset1 + voxelUvOffset;
+        Properties properties0 = getPropertiesFromMegatextureAtUv(uv0);
+        Properties properties1 = getPropertiesFromMegatextureAtUv(uv1);
+        return mixProperties(properties0, properties1, sliceLerp);
+    #endif
+}
+
+// Convert an array of sample datas to a final weighted properties.
+Properties accumulatePropertiesFromMegatexture(in SampleData sampleDatas[SAMPLE_COUNT]) {
+    #if (SAMPLE_COUNT == 1)
+        return getPropertiesFromMegatexture(sampleDatas[0]);
+    #else
+        // When more than one sample is taken the accumulator needs to start at 0
+        Properties properties = clearProperties();
+        for (int i = 0; i < SAMPLE_COUNT; ++i) {
+            float weight = sampleDatas[i].weight;
+
+            // Avoid reading the megatexture when the weight is 0 as it can be costly.
+            if (weight > 0.0) {
+                Properties tempProperties = getPropertiesFromMegatexture(sampleDatas[i]);
+                tempProperties = scaleProperties(tempProperties, weight);
+                properties = sumProperties(properties, tempProperties);
+            }
+        }
+        return properties;
+    #endif
+}

package/Source/Shaders/Voxels/Megatexture.js

@@ -0,0 +1,138 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// See Octree.glsl for the definitions of SampleData and intMod\n\
+\n\
+/* Megatexture defines (set in Scene/VoxelRenderResources.js)\n\
+#define SAMPLE_COUNT ###\n\
+#define NEAREST_SAMPLING\n\
+#define PADDING\n\
+*/\n\
+\n\
+uniform ivec2 u_megatextureSliceDimensions; // number of slices per tile, in two dimensions\n\
+uniform ivec2 u_megatextureTileDimensions; // number of tiles per megatexture, in two dimensions\n\
+uniform vec2 u_megatextureVoxelSizeUv;\n\
+uniform vec2 u_megatextureSliceSizeUv;\n\
+uniform vec2 u_megatextureTileSizeUv;\n\
+\n\
+uniform ivec3 u_dimensions; // does not include padding\n\
+#if defined(PADDING)\n\
+    uniform ivec3 u_paddingBefore;\n\
+    uniform ivec3 u_paddingAfter;\n\
+#endif\n\
+\n\
+// Integer min, max, clamp: For WebGL1 only\n\
+int intMin(int a, int b) {\n\
+    return a <= b ? a : b;\n\
+}\n\
+int intMax(int a, int b) {\n\
+    return a >= b ? a : b;\n\
+}\n\
+int intClamp(int v, int minVal, int maxVal) {\n\
+    return intMin(intMax(v, minVal), maxVal);\n\
+}\n\
+\n\
+vec2 index1DTo2DTexcoord(int index, ivec2 dimensions, vec2 uvScale)\n\
+{\n\
+    int indexX = intMod(index, dimensions.x);\n\
+    int indexY = index / dimensions.x;\n\
+    return vec2(indexX, indexY) * uvScale;\n\
+}\n\
+\n\
+/*\n\
+    How is 3D data stored in a 2D megatexture?\n\
+\n\
+    In this example there is only one loaded tile and it has 2x2x2 voxels (8 voxels total).\n\
+    The data is sliced by Z. The data at Z = 0 is placed in texels (0,0), (0,1), (1,0), (1,1) and\n\
+    the data at Z = 1 is placed in texels (2,0), (2,1), (3,0), (3,1).\n\
+    Note that there could be empty space in the megatexture because it's a power of two.\n\
+\n\
+      0   1   2   3\n\
+    +---+---+---+---+\n\
+    |   |   |   |   | 3\n\
+    +---+---+---+---+\n\
+    |   |   |   |   | 2\n\
+    +-------+-------+\n\
+    |010|110|011|111| 1\n\
+    |--- ---|--- ---|\n\
+    |000|100|001|101| 0\n\
+    +-------+-------+\n\
+\n\
+    When doing linear interpolation the megatexture needs to be sampled twice: once for\n\
+    the Z slice above the voxel coordinate and once for the slice below. The two slices\n\
+    are interpolated with fract(coord.z - 0.5). For example, a Z coordinate of 1.0 is\n\
+    halfway between two Z slices so the interpolation factor is 0.5. Below is a side view\n\
+    of the 3D voxel grid with voxel coordinates on the left side.\n\
+\n\
+    2 +---+\n\
+      |001|\n\
+    1 +-z-+\n\
+      |000|\n\
+    0 +---+\n\
+\n\
+    When doing nearest neighbor the megatexture only needs to be sampled once at the closest Z slice.\n\
+*/\n\
+\n\
+Properties getPropertiesFromMegatexture(in SampleData sampleData) {\n\
+    vec3 tileUv = clamp(sampleData.tileUv, vec3(0.0), vec3(1.0)); // TODO is the clamp necessary?\n\
+    int tileIndex = sampleData.megatextureIndex;\n\
+    vec3 voxelCoord = tileUv * vec3(u_dimensions);\n\
+    ivec3 voxelDimensions = u_dimensions;\n\
+\n\
+    #if defined(PADDING)\n\
+        voxelDimensions += u_paddingBefore + u_paddingAfter;\n\
+        voxelCoord += vec3(u_paddingBefore);\n\
+    #endif\n\
+\n\
+    #if defined(NEAREST_SAMPLING)\n\
+        // Round to the center of the nearest voxel\n\
+        voxelCoord = floor(voxelCoord + vec3(0.5));\n\
+    #endif\n\
+\n\
+    // Tile location\n\
+    vec2 tileUvOffset = index1DTo2DTexcoord(tileIndex, u_megatextureTileDimensions, u_megatextureTileSizeUv);\n\
+\n\
+    // Slice location\n\
+    float slice = voxelCoord.z - 0.5;\n\
+    int sliceIndex = int(floor(slice));\n\
+    int sliceIndex0 = intClamp(sliceIndex, 0, voxelDimensions.z - 1);\n\
+    vec2 sliceUvOffset0 = index1DTo2DTexcoord(sliceIndex0, u_megatextureSliceDimensions, u_megatextureSliceSizeUv);\n\
+\n\
+    // Voxel location\n\
+    vec2 voxelUvOffset = clamp(voxelCoord.xy, vec2(0.5), vec2(voxelDimensions.xy) - vec2(0.5)) * u_megatextureVoxelSizeUv;\n\
+\n\
+    // Final location in the megatexture\n\
+    vec2 uv0 = tileUvOffset + sliceUvOffset0 + voxelUvOffset;\n\
+\n\
+    #if defined(NEAREST_SAMPLING)\n\
+        return getPropertiesFromMegatextureAtUv(uv0);\n\
+    #else\n\
+        float sliceLerp = fract(slice);\n\
+        int sliceIndex1 = intMin(sliceIndex + 1, voxelDimensions.z - 1);\n\
+        vec2 sliceUvOffset1 = index1DTo2DTexcoord(sliceIndex1, u_megatextureSliceDimensions, u_megatextureSliceSizeUv);\n\
+        vec2 uv1 = tileUvOffset + sliceUvOffset1 + voxelUvOffset;\n\
+        Properties properties0 = getPropertiesFromMegatextureAtUv(uv0);\n\
+        Properties properties1 = getPropertiesFromMegatextureAtUv(uv1);\n\
+        return mixProperties(properties0, properties1, sliceLerp);\n\
+    #endif\n\
+}\n\
+\n\
+// Convert an array of sample datas to a final weighted properties.\n\
+Properties accumulatePropertiesFromMegatexture(in SampleData sampleDatas[SAMPLE_COUNT]) {\n\
+    #if (SAMPLE_COUNT == 1)\n\
+        return getPropertiesFromMegatexture(sampleDatas[0]);\n\
+    #else\n\
+        // When more than one sample is taken the accumulator needs to start at 0\n\
+        Properties properties = clearProperties();\n\
+        for (int i = 0; i < SAMPLE_COUNT; ++i) {\n\
+            float weight = sampleDatas[i].weight;\n\
+\n\
+            // Avoid reading the megatexture when the weight is 0 as it can be costly.\n\
+            if (weight > 0.0) {\n\
+                Properties tempProperties = getPropertiesFromMegatexture(sampleDatas[i]);\n\
+                tempProperties = scaleProperties(tempProperties, weight);\n\
+                properties = sumProperties(properties, tempProperties);\n\
+            }\n\
+        }\n\
+        return properties;\n\
+    #endif\n\
+}\n\
+";

package/Source/Shaders/Voxels/Octree.glsl

@@ -0,0 +1,221 @@
+// These octree flags must be in sync with GpuOctreeFlag in VoxelTraversal.js
+#define OCTREE_FLAG_INTERNAL 0
+#define OCTREE_FLAG_LEAF 1
+#define OCTREE_FLAG_PACKED_LEAF_FROM_PARENT 2
+
+#define OCTREE_MAX_LEVELS 32 // Harcoded value because GLSL doesn't like variable length loops
+
+uniform sampler2D u_octreeInternalNodeTexture;
+uniform vec2 u_octreeInternalNodeTexelSizeUv;
+uniform int u_octreeInternalNodeTilesPerRow;
+uniform sampler2D u_octreeLeafNodeTexture;
+uniform vec2 u_octreeLeafNodeTexelSizeUv;
+uniform int u_octreeLeafNodeTilesPerRow;
+
+uniform float u_stepSize;
+
+struct OctreeNodeData {
+    int data;
+    int flag;
+};
+
+struct TraversalData {
+    float stepT;
+    ivec4 octreeCoords;
+    int parentOctreeIndex;
+};
+
+struct SampleData {
+    int megatextureIndex;
+    bool usingParentMegatextureIndex;
+    vec3 tileUv;
+    #if (SAMPLE_COUNT > 1)
+        float weight;
+    #endif
+};
+
+// Integer mod: For WebGL1 only
+int intMod(in int a, in int b) {
+    return a - (b * (a / b));
+}
+int normU8_toInt(in float value) {
+    return int(value * 255.0);
+}
+int normU8x2_toInt(in vec2 value) {
+    return int(value.x * 255.0) + 256 * int(value.y * 255.0);
+}
+float normU8x2_toFloat(in vec2 value) {
+    return float(normU8x2_toInt(value)) / 65535.0;
+}
+
+OctreeNodeData getOctreeNodeData(in vec2 octreeUv) {
+    vec4 texData = texture2D(u_octreeInternalNodeTexture, octreeUv);
+
+    OctreeNodeData data;
+    data.data = normU8x2_toInt(texData.xy);
+    data.flag = normU8x2_toInt(texData.zw);
+    return data;
+}
+
+OctreeNodeData getOctreeChildData(in int parentOctreeIndex, in ivec3 childCoord) {
+    int childIndex = childCoord.z * 4 + childCoord.y * 2 + childCoord.x;
+    int octreeCoordX = intMod(parentOctreeIndex, u_octreeInternalNodeTilesPerRow) * 9 + 1 + childIndex;
+    int octreeCoordY = parentOctreeIndex / u_octreeInternalNodeTilesPerRow;
+    vec2 octreeUv = u_octreeInternalNodeTexelSizeUv * vec2(float(octreeCoordX) + 0.5, float(octreeCoordY) + 0.5);
+    return getOctreeNodeData(octreeUv);
+}
+
+int getOctreeParentIndex(in int octreeIndex) {
+    int octreeCoordX = intMod(octreeIndex, u_octreeInternalNodeTilesPerRow) * 9;
+    int octreeCoordY = octreeIndex / u_octreeInternalNodeTilesPerRow;
+    vec2 octreeUv = u_octreeInternalNodeTexelSizeUv * vec2(float(octreeCoordX) + 0.5, float(octreeCoordY) + 0.5);
+    vec4 parentData = texture2D(u_octreeInternalNodeTexture, octreeUv);
+    int parentOctreeIndex = normU8x2_toInt(parentData.xy);
+    return parentOctreeIndex;
+}
+
+/**
+* Convert a position in the uv-space of the tileset bounding shape
+* 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)
+    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
+        ? 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) {
+    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;
+
+    vec2 leafUv0 = u_octreeLeafNodeTexelSizeUv * vec2(leafCoordXStart + 0.0, leafCoordY);
+    vec2 leafUv1 = u_octreeLeafNodeTexelSizeUv * vec2(leafCoordXStart + 1.0, leafCoordY);
+    vec4 leafData0 = texture2D(u_octreeLeafNodeTexture, leafUv0);
+    vec4 leafData1 = texture2D(u_octreeLeafNodeTexture, leafUv1);
+
+    float lerp = normU8x2_toFloat(leafData0.xy);
+
+    sampleData0.megatextureIndex = normU8x2_toInt(leafData1.xy);
+    sampleData1.megatextureIndex = normU8x2_toInt(leafData1.zw);
+    // 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;
+}
+#endif
+
+void traverseOctreeDownwards(in vec3 shapePosition, inout TraversalData traversalData, out SampleData sampleDatas[SAMPLE_COUNT]) {
+    float sizeAtLevel = 1.0 / pow(2.0, float(traversalData.octreeCoords.w));
+    vec3 start = vec3(traversalData.octreeCoords.xyz) * sizeAtLevel;
+    vec3 end = start + vec3(sizeAtLevel);
+
+    for (int i = 0; i < OCTREE_MAX_LEVELS; ++i) {
+        // Find out which octree child contains the position
+        // 0 if before center, 1 if after
+        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 {
+            // 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;
+        }
+    }
+}
+
+/**
+* Transform a given position to an octree tile coordinate and a position within that tile,
+* and find the corresponding megatexture index and texture coordinates
+*/
+void traverseOctreeFromBeginning(in vec3 shapePosition, out TraversalData traversalData, out SampleData sampleDatas[SAMPLE_COUNT]) {
+    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);
+    }
+}
+
+bool inRange(in vec3 v, in vec3 minVal, in vec3 maxVal) {
+    return clamp(v, minVal, maxVal) == v;
+}
+
+bool insideTile(in vec3 shapePosition, in ivec4 octreeCoords) {
+    vec3 tileUv = getTileUv(shapePosition, octreeCoords);
+	bool inside = inRange(tileUv, vec3(0.0), vec3(1.0));
+	// Assume (!) the position is always inside the root tile.
+	return inside || octreeCoords.w == 0;
+}
+
+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]);
+        }
+    } 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;
+            }
+        }
+
+        // Go down tree
+        traverseOctreeDownwards(shapePosition, traversalData, sampleDatas);
+    }
+}