@cesium/engine 0.1.0 → 1.1.0

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);
+    }
+}

package/Source/Shaders/Voxels/Octree.js

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

package/Source/Shaders/Voxels/VoxelFS.glsl

@@ -0,0 +1,150 @@
+// See Intersection.glsl for the definition of intersectScene
+// See IntersectionUtils.glsl for the definition of nextIntersection
+// See convertUvToBox.glsl, convertUvToCylinder.glsl, or convertUvToEllipsoid.glsl
+// for the definition of convertUvToShapeUvSpace. The appropriate function is 
+// selected based on the VoxelPrimitive shape type, and added to the shader in
+// Scene/VoxelRenderResources.js.
+// See Octree.glsl for the definitions of TraversalData, SampleData,
+// traverseOctreeFromBeginning, and traverseOctreeFromExisting
+// See Megatexture.glsl for the definition of accumulatePropertiesFromMegatexture
+
+#define STEP_COUNT_MAX 1000 // Harcoded value because GLSL doesn't like variable length loops
+#define ALPHA_ACCUM_MAX 0.98 // Must be > 0.0 and <= 1.0
+
+uniform mat3 u_transformDirectionViewToLocal;
+uniform vec3 u_cameraPositionUv;
+
+#if defined(PICKING)
+    uniform vec4 u_pickColor;
+#endif
+
+#if defined(JITTER)
+float hash(vec2 p)
+{
+    vec3 p3 = fract(vec3(p.xyx) * 50.0); // magic number = hashscale
+    p3 += dot(p3, p3.yzx + 19.19);
+    return fract((p3.x + p3.y) * p3.z);
+}
+#endif
+
+void main()
+{
+    vec4 fragCoord = gl_FragCoord;
+    vec2 screenCoord = (fragCoord.xy - czm_viewport.xy) / czm_viewport.zw; // [0,1]
+    vec3 eyeDirection = normalize(czm_windowToEyeCoordinates(fragCoord).xyz);
+    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;
+
+    Intersections ix;
+    vec2 entryExitT = intersectScene(screenCoord, viewPosUv, viewDirUv, ix);
+
+    // Exit early if the scene was completely missed.
+    if (entryExitT.x == NO_HIT) {
+        discard;
+    }
+
+    float currT = entryExitT.x;
+    float endT = entryExitT.y;
+    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);
+
+    // 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;
+    #endif
+
+    FragmentInput fragmentInput;
+    #if defined(STATISTICS)
+        setStatistics(fragmentInput.metadata.statistics);
+    #endif
+
+    vec4 colorAccum =vec4(0.0);
+
+    for (int stepCount = 0; stepCount < STEP_COUNT_MAX; ++stepCount) {
+        // Read properties from the megatexture based on the traversal state
+        Properties properties = accumulatePropertiesFromMegatexture(sampleDatas);
+
+        // Prepare the custom shader inputs
+        copyPropertiesToMetadata(properties, fragmentInput.metadata);
+        fragmentInput.voxel.positionUv = positionUv;
+        fragmentInput.voxel.positionShapeUv = positionUvShapeSpace;
+        fragmentInput.voxel.positionUvLocal = sampleDatas[0].tileUv;
+        fragmentInput.voxel.viewDirUv = viewDirUv;
+        fragmentInput.voxel.viewDirWorld = viewDirWorld;
+        fragmentInput.voxel.travelDistance = traversalData.stepT;
+
+        // Run the custom shader
+        czm_modelMaterial materialOutput;
+        fragmentMain(fragmentInput, materialOutput);
+
+        // Sanitize the custom shader output
+        vec4 color = vec4(materialOutput.diffuse, materialOutput.alpha);
+        color.rgb = max(color.rgb, vec3(0.0));
+        color.a = clamp(color.a, 0.0, 1.0);
+
+        // Pre-multiplied alpha blend
+        colorAccum += (1.0 - colorAccum.a) * vec4(color.rgb * color.a, color.a);
+
+        // Stop traversing if the alpha has been fully saturated
+        if (colorAccum.a > ALPHA_ACCUM_MAX) {
+            colorAccum.a = ALPHA_ACCUM_MAX;
+            break;
+        }
+
+        if (traversalData.stepT == 0.0) {
+            // Shape is infinitely thin, no need to traverse further
+            break;
+        }
+
+        // Keep raymarching
+        currT += traversalData.stepT;
+        positionUv += traversalData.stepT * 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) {
+                    break;
+                } else {
+                    // Found another intersection. Resume raymarching there
+                    currT = entryExitT.x;
+                    endT = entryExitT.y;
+                    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.
+        positionUvShapeSpace = convertUvToShapeUvSpace(positionUv);
+        traverseOctreeFromExisting(positionUvShapeSpace, traversalData, sampleDatas);
+    }
+
+    // Convert the alpha from [0,ALPHA_ACCUM_MAX] to [0,1]
+    colorAccum.a /= ALPHA_ACCUM_MAX;
+
+    #if defined(PICKING)
+        // If alpha is 0.0 there is nothing to pick
+        if (colorAccum.a == 0.0) {
+            discard;
+        }
+        gl_FragColor = u_pickColor;
+    #else
+        gl_FragColor = colorAccum;
+    #endif
+}