@cesium/engine 1.0.0 → 2.0.0

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 = texture(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 = texture(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 = 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\
+    // 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;
+        }
+        out_FragColor = u_pickColor;
+    #else
+        out_FragColor = colorAccum;
+    #endif
+}

package/Source/Shaders/Voxels/VoxelFS.js

@@ -0,0 +1,152 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// See Intersection.glsl for the definition of intersectScene\n\
+// See IntersectionUtils.glsl for the definition of nextIntersection\n\
+// See convertUvToBox.glsl, convertUvToCylinder.glsl, or convertUvToEllipsoid.glsl\n\
+// for the definition of convertUvToShapeUvSpace. The appropriate function is \n\
+// selected based on the VoxelPrimitive shape type, and added to the shader in\n\
+// Scene/VoxelRenderResources.js.\n\
+// See Octree.glsl for the definitions of TraversalData, SampleData,\n\
+// traverseOctreeFromBeginning, and traverseOctreeFromExisting\n\
+// See Megatexture.glsl for the definition of accumulatePropertiesFromMegatexture\n\
+\n\
+#define STEP_COUNT_MAX 1000 // Harcoded value because GLSL doesn't like variable length loops\n\
+#define ALPHA_ACCUM_MAX 0.98 // Must be > 0.0 and <= 1.0\n\
+\n\
+uniform mat3 u_transformDirectionViewToLocal;\n\
+uniform vec3 u_cameraPositionUv;\n\
+\n\
+#if defined(PICKING)\n\
+    uniform vec4 u_pickColor;\n\
+#endif\n\
+\n\
+#if defined(JITTER)\n\
+float hash(vec2 p)\n\
+{\n\
+    vec3 p3 = fract(vec3(p.xyx) * 50.0); // magic number = hashscale\n\
+    p3 += dot(p3, p3.yzx + 19.19);\n\
+    return fract((p3.x + p3.y) * p3.z);\n\
+}\n\
+#endif\n\
+\n\
+void main()\n\
+{\n\
+    vec4 fragCoord = gl_FragCoord;\n\
+    vec2 screenCoord = (fragCoord.xy - czm_viewport.xy) / czm_viewport.zw; // [0,1]\n\
+    vec3 eyeDirection = normalize(czm_windowToEyeCoordinates(fragCoord).xyz);\n\
+    vec3 viewDirWorld = normalize(czm_inverseViewRotation * eyeDirection); // normalize again just in case\n\
+    vec3 viewDirUv = normalize(u_transformDirectionViewToLocal * eyeDirection); // normalize again just in case\n\
+    vec3 viewPosUv = u_cameraPositionUv;\n\
+\n\
+    Intersections ix;\n\
+    vec2 entryExitT = intersectScene(screenCoord, viewPosUv, viewDirUv, ix);\n\
+\n\
+    // Exit early if the scene was completely missed.\n\
+    if (entryExitT.x == NO_HIT) {\n\
+        discard;\n\
+    }\n\
+\n\
+    float currT = entryExitT.x;\n\
+    float endT = entryExitT.y;\n\
+    vec3 positionUv = viewPosUv + currT * viewDirUv;\n\
+    // TODO: is it possible for this to be out of bounds, and does it matter?\n\
+    vec3 positionUvShapeSpace = convertUvToShapeUvSpace(positionUv);\n\
+\n\
+    // Traverse the tree from the start position\n\
+    TraversalData traversalData;\n\
+    SampleData sampleDatas[SAMPLE_COUNT];\n\
+    traverseOctreeFromBeginning(positionUvShapeSpace, traversalData, sampleDatas);\n\
+\n\
+    // TODO:\n\
+    //  - jitter doesn't affect the first traversal?\n\
+    //  - jitter is always > 0?\n\
+    //  - jitter is only applied at one step?\n\
+    #if defined(JITTER)\n\
+        float noise = hash(screenCoord); // [0,1]\n\
+        currT += noise * traversalData.stepT;\n\
+        positionUv += noise * traversalData.stepT * viewDirUv;\n\
+    #endif\n\
+\n\
+    FragmentInput fragmentInput;\n\
+    #if defined(STATISTICS)\n\
+        setStatistics(fragmentInput.metadata.statistics);\n\
+    #endif\n\
+\n\
+    vec4 colorAccum =vec4(0.0);\n\
+\n\
+    for (int stepCount = 0; stepCount < STEP_COUNT_MAX; ++stepCount) {\n\
+        // Read properties from the megatexture based on the traversal state\n\
+        Properties properties = accumulatePropertiesFromMegatexture(sampleDatas);\n\
+\n\
+        // Prepare the custom shader inputs\n\
+        copyPropertiesToMetadata(properties, fragmentInput.metadata);\n\
+        fragmentInput.voxel.positionUv = positionUv;\n\
+        fragmentInput.voxel.positionShapeUv = positionUvShapeSpace;\n\
+        fragmentInput.voxel.positionUvLocal = sampleDatas[0].tileUv;\n\
+        fragmentInput.voxel.viewDirUv = viewDirUv;\n\
+        fragmentInput.voxel.viewDirWorld = viewDirWorld;\n\
+        fragmentInput.voxel.travelDistance = traversalData.stepT;\n\
+\n\
+        // Run the custom shader\n\
+        czm_modelMaterial materialOutput;\n\
+        fragmentMain(fragmentInput, materialOutput);\n\
+\n\
+        // Sanitize the custom shader output\n\
+        vec4 color = vec4(materialOutput.diffuse, materialOutput.alpha);\n\
+        color.rgb = max(color.rgb, vec3(0.0));\n\
+        color.a = clamp(color.a, 0.0, 1.0);\n\
+\n\
+        // Pre-multiplied alpha blend\n\
+        colorAccum += (1.0 - colorAccum.a) * vec4(color.rgb * color.a, color.a);\n\
+\n\
+        // Stop traversing if the alpha has been fully saturated\n\
+        if (colorAccum.a > ALPHA_ACCUM_MAX) {\n\
+            colorAccum.a = ALPHA_ACCUM_MAX;\n\
+            break;\n\
+        }\n\
+\n\
+        if (traversalData.stepT == 0.0) {\n\
+            // Shape is infinitely thin, no need to traverse further\n\
+            break;\n\
+        }\n\
+\n\
+        // Keep raymarching\n\
+        currT += traversalData.stepT;\n\
+        positionUv += traversalData.stepT * viewDirUv;\n\
+\n\
+        // Check if there's more intersections.\n\
+        if (currT > endT) {\n\
+            #if (INTERSECTION_COUNT == 1)\n\
+                break;\n\
+            #else\n\
+                vec2 entryExitT = nextIntersection(ix);\n\
+                if (entryExitT.x == NO_HIT) {\n\
+                    break;\n\
+                } else {\n\
+                    // Found another intersection. Resume raymarching there\n\
+                    currT = entryExitT.x;\n\
+                    endT = entryExitT.y;\n\
+                    positionUv = viewPosUv + currT * viewDirUv;\n\
+                }\n\
+            #endif\n\
+        }\n\
+\n\
+        // Traverse the tree from the current ray position.\n\
+        // This is similar to traverseOctree but is faster when the ray is in the same tile as the previous step.\n\
+        positionUvShapeSpace = convertUvToShapeUvSpace(positionUv);\n\
+        traverseOctreeFromExisting(positionUvShapeSpace, traversalData, sampleDatas);\n\
+    }\n\
+\n\
+    // Convert the alpha from [0,ALPHA_ACCUM_MAX] to [0,1]\n\
+    colorAccum.a /= ALPHA_ACCUM_MAX;\n\
+\n\
+    #if defined(PICKING)\n\
+        // If alpha is 0.0 there is nothing to pick\n\
+        if (colorAccum.a == 0.0) {\n\
+            discard;\n\
+        }\n\
+        out_FragColor = u_pickColor;\n\
+    #else\n\
+        out_FragColor = colorAccum;\n\
+    #endif\n\
+}\n\
+";

package/Source/Shaders/Voxels/VoxelVS.glsl

@@ -0,0 +1,11 @@
+in vec2 position;
+
+uniform vec4 u_ndcSpaceAxisAlignedBoundingBox;
+
+void main() {
+    vec2 aabbMin = u_ndcSpaceAxisAlignedBoundingBox.xy;
+    vec2 aabbMax = u_ndcSpaceAxisAlignedBoundingBox.zw;
+    vec2 translation = 0.5 * (aabbMax + aabbMin);
+    vec2 scale = 0.5 * (aabbMax - aabbMin);
+    gl_Position = vec4(position * scale + translation, 0.0, 1.0);
+}

package/Source/Shaders/Voxels/VoxelVS.js

@@ -0,0 +1,13 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "in vec2 position;\n\
+\n\
+uniform vec4 u_ndcSpaceAxisAlignedBoundingBox;\n\
+\n\
+void main() {\n\
+    vec2 aabbMin = u_ndcSpaceAxisAlignedBoundingBox.xy;\n\
+    vec2 aabbMax = u_ndcSpaceAxisAlignedBoundingBox.zw;\n\
+    vec2 translation = 0.5 * (aabbMax + aabbMin);\n\
+    vec2 scale = 0.5 * (aabbMax - aabbMin);\n\
+    gl_Position = vec4(position * scale + translation, 0.0, 1.0);\n\
+}\n\
+";

package/Source/Shaders/Voxels/convertUvToBox.glsl

@@ -0,0 +1,16 @@
+/* Box defines (set in Scene/VoxelBoxShape.js)
+#define BOX_HAS_SHAPE_BOUNDS
+*/
+
+#if defined(BOX_HAS_SHAPE_BOUNDS)
+    uniform vec3 u_boxUvToShapeUvScale;
+    uniform vec3 u_boxUvToShapeUvTranslate;
+#endif
+
+vec3 convertUvToShapeUvSpace(in vec3 positionUv) {
+    #if defined(BOX_HAS_SHAPE_BOUNDS)
+        return positionUv * u_boxUvToShapeUvScale + u_boxUvToShapeUvTranslate;
+    #else
+        return positionUv;
+    #endif
+}

package/Source/Shaders/Voxels/convertUvToBox.js

@@ -0,0 +1,18 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/* Box defines (set in Scene/VoxelBoxShape.js)\n\
+#define BOX_HAS_SHAPE_BOUNDS\n\
+*/\n\
+\n\
+#if defined(BOX_HAS_SHAPE_BOUNDS)\n\
+    uniform vec3 u_boxUvToShapeUvScale;\n\
+    uniform vec3 u_boxUvToShapeUvTranslate;\n\
+#endif\n\
+\n\
+vec3 convertUvToShapeUvSpace(in vec3 positionUv) {\n\
+    #if defined(BOX_HAS_SHAPE_BOUNDS)\n\
+        return positionUv * u_boxUvToShapeUvScale + u_boxUvToShapeUvTranslate;\n\
+    #else\n\
+        return positionUv;\n\
+    #endif\n\
+}\n\
+";

package/Source/Shaders/Voxels/convertUvToCylinder.glsl

@@ -0,0 +1,75 @@
+/* Cylinder defines (set in Scene/VoxelCylinderShape.js)
+#define CYLINDER_HAS_SHAPE_BOUNDS_RADIUS
+#define CYLINDER_HAS_SHAPE_BOUNDS_RADIUS_FLAT
+#define CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT
+#define CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT_FLAT
+#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE
+#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_RANGE_EQUAL_ZERO
+#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY
+#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY
+#define CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED
+*/
+
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS)
+    uniform vec2 u_cylinderUvToShapeUvRadius; // x = scale, y = offset
+#endif
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)
+    uniform vec2 u_cylinderUvToShapeUvHeight; // x = scale, y = offset
+#endif
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)
+    uniform vec2 u_cylinderUvToShapeUvAngle; // x = scale, y = offset
+#endif
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY) || defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY)
+    uniform vec2 u_cylinderShapeUvAngleMinMax;
+#endif
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY) || defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY) || defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED)
+    uniform float u_cylinderShapeUvAngleRangeZeroMid;
+#endif
+
+vec3 convertUvToShapeUvSpace(in vec3 positionUv) {
+    vec3 positionLocal = positionUv * 2.0 - 1.0; // [-1,+1]
+
+    // Compute radius
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS_FLAT)
+        float radius = 1.0;
+    #else
+        float radius = length(positionLocal.xy); // [0,1]
+        #if defined(CYLINDER_HAS_SHAPE_BOUNDS_RADIUS)
+            radius = radius * u_cylinderUvToShapeUvRadius.x + u_cylinderUvToShapeUvRadius.y; // x = scale, y = offset
+        #endif
+    #endif
+
+    // Compute height
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT_FLAT)
+        float height = 1.0;
+    #else
+        float height = positionUv.z; // [0,1]
+        #if defined(CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT)
+            height = height * u_cylinderUvToShapeUvHeight.x + u_cylinderUvToShapeUvHeight.y; // x = scale, y = offset
+        #endif
+    #endif
+
+    // Compute angle
+    #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_RANGE_EQUAL_ZERO)
+        float angle = 1.0;
+    #else
+        float angle = (atan(positionLocal.y, positionLocal.x) + czm_pi) / czm_twoPi; // [0,1]
+        #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)
+            #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED)
+                // Comparing against u_cylinderShapeUvAngleMinMax has precision problems. u_cylinderShapeUvAngleRangeZeroMid is more conservative.
+                angle += float(angle < u_cylinderShapeUvAngleRangeZeroMid);
+            #endif
+
+            // Avoid flickering from reading voxels from both sides of the -pi/+pi discontinuity.
+            #if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY)
+                angle = angle > u_cylinderShapeUvAngleRangeZeroMid ? u_cylinderShapeUvAngleMinMax.x : angle;
+            #elif defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY)
+                angle = angle < u_cylinderShapeUvAngleRangeZeroMid ? u_cylinderShapeUvAngleMinMax.y : angle;
+            #endif
+
+            angle = angle * u_cylinderUvToShapeUvAngle.x + u_cylinderUvToShapeUvAngle.y; // x = scale, y = offset
+        #endif
+    #endif
+
+    return vec3(radius, height, angle);
+}