deeptwins-cesium-engine 0.1.2 → 0.1.4

package/Source/Shaders/Voxels/Octree.js

@@ -30,6 +30,11 @@ struct TraversalData {\n\
     int parentOctreeIndex;\n\
 };\n\
 \n\
+struct TileAndUvCoordinate {\n\
+    ivec4 tileCoords;\n\
+    vec3 tileUv;\n\
+};\n\
+\n\
 struct SampleData {\n\
     int megatextureIndex;\n\
     ivec4 tileCoords;\n\
@@ -40,10 +45,6 @@ struct SampleData {\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\
@@ -65,14 +66,14 @@ OctreeNodeData getOctreeNodeData(in vec2 octreeUv) {\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 octreeCoordX = (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 octreeCoordX = (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\
@@ -80,33 +81,31 @@ int getOctreeParentIndex(in int octreeIndex) {\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\
-	// PERFORMANCE_IDEA: use bit-shifting (only in WebGL2)\n\
-    float dimAtLevel = exp2(float(octreeCoords.w));\n\
-    return shapePosition * dimAtLevel - vec3(octreeCoords.xyz);\n\
+vec3 getTileUv(in TileAndUvCoordinate tileAndUv, in ivec4 octreeCoords) {\n\
+    int levelDifference = tileAndUv.tileCoords.w - octreeCoords.w;\n\
+    float scalar = exp2(-1.0 * float(levelDifference));\n\
+    vec3 originShift = vec3(tileAndUv.tileCoords.xyz - (octreeCoords.xyz << levelDifference)) * scalar;\n\
+    return tileAndUv.tileUv * scalar + originShift;\n\
 }\n\
 \n\
-vec3 getClampedTileUv(in vec3 shapePosition, in ivec4 octreeCoords) {\n\
-    vec3 tileUv = getTileUv(shapePosition, octreeCoords);\n\
+vec3 getClampedTileUv(in TileAndUvCoordinate tileAndUv, in ivec4 octreeCoords) {\n\
+    vec3 tileUv = getTileUv(tileAndUv, octreeCoords);\n\
     return clamp(tileUv, vec3(0.0), vec3(1.0));\n\
 }\n\
 \n\
-void addSampleCoordinates(in vec3 shapePosition, inout SampleData sampleData) {\n\
-    vec3 tileUv = getClampedTileUv(shapePosition, sampleData.tileCoords);\n\
+void addSampleCoordinates(in TileAndUvCoordinate tileAndUv, inout SampleData sampleData) {\n\
+    vec3 tileUv = getClampedTileUv(tileAndUv, sampleData.tileCoords);\n\
 \n\
     vec3 inputCoordinate = tileUv * vec3(u_dimensions);\n\
 #if defined(PADDING)\n\
     inputCoordinate += vec3(u_paddingBefore);\n\
 #endif\n\
-#if defined(GLTF_METADATA_ORDER)\n\
+#if defined(Y_UP_METADATA_ORDER)\n\
 #if defined(SHAPE_BOX)\n\
     float inputY = inputCoordinate.y;\n\
-    inputCoordinate.y = float(u_inputDimensions.y) - inputCoordinate.z;\n\
-    inputCoordinate.z = inputY;\n\
+    inputCoordinate.y = inputCoordinate.z;\n\
+    // u_inputDimensions.z is the y-up dimension along the 3D Tiles y-axis.\n\
+    inputCoordinate.z = float(u_inputDimensions.z) - inputY;\n\
 #elif defined(SHAPE_CYLINDER)\n\
     float angle = inputCoordinate.y;\n\
     float height = inputCoordinate.z;\n\
@@ -138,7 +137,7 @@ void getOctreeLeafSampleDatas(in OctreeNodeData data, in ivec4 octreeCoords, out
     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 leafCoordXStart = float((leafIndex % u_octreeLeafNodeTilesPerRow) * leafNodeTexelCount) + 0.5;\n\
     float leafCoordY = float(leafIndex / u_octreeLeafNodeTilesPerRow) + 0.5;\n\
 \n\
     // Get an interpolation weight and a flag to determine whether to read the parent texture\n\
@@ -163,32 +162,25 @@ void getOctreeLeafSampleDatas(in OctreeNodeData data, in ivec4 octreeCoords, out
 }\n\
 #endif\n\
 \n\
-OctreeNodeData traverseOctreeDownwards(in vec3 shapePosition, inout TraversalData traversalData) {\n\
-    float sizeAtLevel = exp2(-1.0 * float(traversalData.octreeCoords.w));\n\
-    vec3 start = vec3(traversalData.octreeCoords.xyz) * sizeAtLevel;\n\
-    vec3 end = start + vec3(sizeAtLevel);\n\
+OctreeNodeData traverseOctreeDownwards(in ivec4 tileCoordinate, inout TraversalData traversalData) {\n\
     OctreeNodeData childData;\n\
 \n\
     for (int i = 0; i < OCTREE_MAX_LEVELS; ++i) {\n\
-        // Find out which octree child contains the position\n\
-        // 0 if before center, 1 if after\n\
-        vec3 center = 0.5 * (start + end);\n\
-        vec3 childCoord = step(center, shapePosition);\n\
-\n\
-        // 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\
+        // tileCoordinate.xyz is defined at the level of detail tileCoordinate.w.\n\
+        // Find the corresponding coordinate at the level traversalData.octreeCoords.w\n\
+        int level = traversalData.octreeCoords.w + 1;\n\
+        int levelDifference = tileCoordinate.w - level;\n\
+        ivec3 coordinateAtLevel = tileCoordinate.xyz >> levelDifference;\n\
+        traversalData.octreeCoords = ivec4(coordinateAtLevel, level);\n\
 \n\
-        childData = getOctreeChildData(traversalData.parentOctreeIndex, ivec3(childCoord));\n\
+        ivec3 childCoordinate = coordinateAtLevel & 1;\n\
+        childData = getOctreeChildData(traversalData.parentOctreeIndex, childCoordinate);\n\
 \n\
         if (childData.flag != OCTREE_FLAG_INTERNAL) {\n\
             // leaf tile - stop traversing\n\
             break;\n\
         }\n\
 \n\
-        // interior tile - keep going deeper\n\
-        start = mix(start, center, childCoord);\n\
-        end = mix(center, end, childCoord);\n\
         traversalData.parentOctreeIndex = childData.data;\n\
     }\n\
 \n\
@@ -199,50 +191,50 @@ OctreeNodeData traverseOctreeDownwards(in vec3 shapePosition, inout TraversalDat
 * 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\
+void traverseOctreeFromBeginning(in TileAndUvCoordinate tileAndUv, out TraversalData traversalData, out SampleData sampleDatas[SAMPLE_COUNT]) {\n\
     traversalData.octreeCoords = ivec4(0);\n\
     traversalData.parentOctreeIndex = 0;\n\
 \n\
     OctreeNodeData nodeData = getOctreeNodeData(vec2(0.0));\n\
     if (nodeData.flag != OCTREE_FLAG_LEAF) {\n\
-        nodeData = traverseOctreeDownwards(shapePosition, traversalData);\n\
+        nodeData = traverseOctreeDownwards(tileAndUv.tileCoords, traversalData);\n\
     }\n\
 \n\
     #if (SAMPLE_COUNT == 1)\n\
         getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);\n\
-        addSampleCoordinates(shapePosition, sampleDatas[0]);\n\
+        addSampleCoordinates(tileAndUv, sampleDatas[0]);\n\
     #else\n\
         getOctreeLeafSampleDatas(nodeData, traversalData.octreeCoords, sampleDatas);\n\
-        addSampleCoordinates(shapePosition, sampleDatas[0]);\n\
-        addSampleCoordinates(shapePosition, sampleDatas[1]);\n\
+        addSampleCoordinates(tileAndUv, sampleDatas[0]);\n\
+        addSampleCoordinates(tileAndUv, sampleDatas[1]);\n\
     #endif\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\
+bool insideTile(in ivec4 tileCoordinate, in ivec4 octreeCoords) {\n\
+    int levelDifference = tileCoordinate.w - octreeCoords.w;\n\
+    if (levelDifference < 0) {\n\
+        return false;\n\
+    }\n\
+    ivec3 coordinateAtLevel = tileCoordinate.xyz >> levelDifference;\n\
+    return coordinateAtLevel == octreeCoords.xyz;\n\
 }\n\
 \n\
-void traverseOctreeFromExisting(in vec3 shapePosition, inout TraversalData traversalData, inout SampleData sampleDatas[SAMPLE_COUNT]) {\n\
-    if (insideTile(shapePosition, traversalData.octreeCoords)) {\n\
+void traverseOctreeFromExisting(in TileAndUvCoordinate tileAndUv, inout TraversalData traversalData, inout SampleData sampleDatas[SAMPLE_COUNT]) {\n\
+    ivec4 tileCoords = tileAndUv.tileCoords;\n\
+    if (insideTile(tileCoords, traversalData.octreeCoords)) {\n\
         for (int i = 0; i < SAMPLE_COUNT; i++) {\n\
-            addSampleCoordinates(shapePosition, sampleDatas[i]);\n\
+            addSampleCoordinates(tileAndUv, sampleDatas[i]);\n\
         }\n\
         return;\n\
     }\n\
 \n\
-    // Go up tree until we find a parent tile containing shapePosition\n\
+    // Go up tree until we find a parent tile containing tileCoords.\n\
+    // Assumes all parents are available all they way up to the root.\n\
     for (int i = 0; i < OCTREE_MAX_LEVELS; ++i) {\n\
         traversalData.octreeCoords.xyz /= 2;\n\
         traversalData.octreeCoords.w -= 1;\n\
 \n\
-        if (insideTile(shapePosition, traversalData.octreeCoords)) {\n\
+        if (insideTile(tileCoords, traversalData.octreeCoords)) {\n\
             break;\n\
         }\n\
 \n\
@@ -250,15 +242,15 @@ void traverseOctreeFromExisting(in vec3 shapePosition, inout TraversalData trave
     }\n\
 \n\
     // Go down tree\n\
-    OctreeNodeData nodeData = traverseOctreeDownwards(shapePosition, traversalData);\n\
+    OctreeNodeData nodeData = traverseOctreeDownwards(tileCoords, traversalData);\n\
 \n\
     #if (SAMPLE_COUNT == 1)\n\
         getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);\n\
-        addSampleCoordinates(shapePosition, sampleDatas[0]);\n\
+        addSampleCoordinates(tileAndUv, sampleDatas[0]);\n\
     #else\n\
         getOctreeLeafSampleDatas(nodeData, traversalData.octreeCoords, sampleDatas);\n\
-        addSampleCoordinates(shapePosition, sampleDatas[0]);\n\
-        addSampleCoordinates(shapePosition, sampleDatas[1]);\n\
+        addSampleCoordinates(tileAndUv, sampleDatas[0]);\n\
+        addSampleCoordinates(tileAndUv, sampleDatas[1]);\n\
     #endif\n\
 }\n\
 ";

package/Source/Shaders/Voxels/VoxelFS.js

@@ -1,10 +1,10 @@
 //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 convertLocalToBoxUv.glsl, convertLocalToCylinderUv.glsl, or convertLocalToEllipsoidUv.glsl\n\
+// for the definitions of convertLocalToShapeSpaceDerivative and getTileAndUvCoordinate. \n\
+// The appropriate functions are selected based on the VoxelPrimitive shape type, \n\
+// and added to the shader in 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\
@@ -16,8 +16,10 @@ export default "// See Intersection.glsl for the definition of intersectScene\n\
     #define ALPHA_ACCUM_MAX 0.98 // Must be > 0.0 and <= 1.0\n\
 #endif\n\
 \n\
+uniform mat4 u_transformPositionViewToLocal;\n\
 uniform mat3 u_transformDirectionViewToLocal;\n\
-uniform vec3 u_cameraPositionUv;\n\
+uniform vec3 u_cameraPositionLocal;\n\
+uniform vec3 u_cameraDirectionLocal;\n\
 uniform float u_stepSize;\n\
 \n\
 #if defined(PICKING)\n\
@@ -62,16 +64,15 @@ RayShapeIntersection getVoxelIntersection(in vec3 tileUv, in vec3 sampleSizeAlon
 }\n\
 \n\
 vec4 getStepSize(in SampleData sampleData, in Ray viewRay, in RayShapeIntersection shapeIntersection, in mat3 jacobianT, in float currentT) {\n\
-    // The Jacobian is computed in a space where the shape spans [-1, 1].\n\
-    // But the ray is marched in a space where the shape fills [0, 1].\n\
-    // So we need to scale the Jacobian by 2.\n\
-    vec3 gradient = 2.0 * viewRay.rawDir * jacobianT;\n\
+    vec3 gradient = viewRay.dir * jacobianT;\n\
     vec3 sampleSizeAlongRay = getSampleSize(sampleData.tileCoords.w) / gradient;\n\
 \n\
     RayShapeIntersection voxelIntersection = getVoxelIntersection(sampleData.tileUv, sampleSizeAlongRay);\n\
 \n\
-    // Transform normal from shape space to Cartesian space\n\
-    vec3 voxelNormal = normalize(jacobianT * voxelIntersection.entry.xyz);\n\
+    // Transform normal from shape space to Cartesian space to eye space\n\
+    vec3 voxelNormal = jacobianT * voxelIntersection.entry.xyz;\n\
+    voxelNormal = normalize(czm_normal * voxelNormal);\n\
+\n\
     // Compare with the shape intersection, to choose the appropriate normal\n\
     vec4 voxelEntry = vec4(voxelNormal, currentT + voxelIntersection.entry.w);\n\
     vec4 entry = intersectionMax(shapeIntersection.entry, voxelEntry);\n\
@@ -112,26 +113,41 @@ int getSampleIndex(in SampleData sampleData) {\n\
     return sampleIndex.x + u_inputDimensions.x * (sampleIndex.y + u_inputDimensions.y * sampleIndex.z);\n\
 }\n\
 \n\
+/**\n\
+ * Compute the view ray at the current fragment, in the local coordinates of the shape.\n\
+ */\n\
+Ray getViewRayLocal() {\n\
+    vec4 eyeCoordinates = czm_windowToEyeCoordinates(gl_FragCoord);\n\
+    vec3 origin;\n\
+    vec3 direction;\n\
+    if (czm_orthographicIn3D == 1.0) {\n\
+        eyeCoordinates.z = 0.0;\n\
+        origin = (u_transformPositionViewToLocal * eyeCoordinates).xyz;\n\
+        direction = u_cameraDirectionLocal;\n\
+    } else {\n\
+        origin = u_cameraPositionLocal;\n\
+        direction = u_transformDirectionViewToLocal * normalize(eyeCoordinates.xyz);\n\
+    }\n\
+    return Ray(origin, direction);\n\
+}\n\
+\n\
+Ray getViewRayEC() {\n\
+    vec4 eyeCoordinates = czm_windowToEyeCoordinates(gl_FragCoord);\n\
+    vec3 viewPosEC = (czm_orthographicIn3D == 1.0)\n\
+        ? vec3(eyeCoordinates.xy, 0.0)\n\
+        : vec3(0.0);\n\
+    vec3 viewDirEC = normalize(eyeCoordinates.xyz);\n\
+    return Ray(viewPosEC, viewDirEC);\n\
+}\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\
-    #if defined(SHAPE_ELLIPSOID)\n\
-        // viewDirUv has been scaled to a space where the ellipsoid is a sphere.\n\
-        // Undo this scaling to get the raw direction.\n\
-        vec3 rawDir = viewDirUv * u_ellipsoidRadiiUv;\n\
-        Ray viewRayUv = Ray(viewPosUv, viewDirUv, rawDir);\n\
-    #else\n\
-        Ray viewRayUv = Ray(viewPosUv, viewDirUv, viewDirUv);\n\
-    #endif\n\
+    Ray viewRayLocal = getViewRayLocal();\n\
+    Ray viewRayEC = getViewRayEC();\n\
 \n\
     Intersections ix;\n\
-    RayShapeIntersection shapeIntersection = intersectScene(screenCoord, viewRayUv, ix);\n\
-\n\
+    vec2 screenCoord = (gl_FragCoord.xy - czm_viewport.xy) / czm_viewport.zw; // [0,1]\n\
+    RayShapeIntersection shapeIntersection = intersectScene(screenCoord, viewRayLocal, viewRayEC, ix);\n\
     // Exit early if the scene was completely missed.\n\
     if (shapeIntersection.entry.w == NO_HIT) {\n\
         discard;\n\
@@ -139,26 +155,24 @@ void main()\n\
 \n\
     float currentT = shapeIntersection.entry.w;\n\
     float endT = shapeIntersection.exit.w;\n\
-    vec3 positionUv = viewPosUv + currentT * viewDirUv;\n\
-    PointJacobianT pointJacobian = convertUvToShapeUvSpaceDerivative(positionUv);\n\
+\n\
+    vec3 positionEC = viewRayEC.pos + currentT * viewRayEC.dir;\n\
+    TileAndUvCoordinate tileAndUv = getTileAndUvCoordinate(positionEC);\n\
+    vec3 positionLocal = viewRayLocal.pos + currentT * viewRayLocal.dir;\n\
+    mat3 jacobianT = convertLocalToShapeSpaceDerivative(positionLocal);\n\
 \n\
     // Traverse the tree from the start position\n\
     TraversalData traversalData;\n\
     SampleData sampleDatas[SAMPLE_COUNT];\n\
-    traverseOctreeFromBeginning(pointJacobian.point, traversalData, sampleDatas);\n\
-    vec4 step = getStepSize(sampleDatas[0], viewRayUv, shapeIntersection, pointJacobian.jacobianT, currentT);\n\
-\n\
-    #if defined(JITTER)\n\
-        float noise = hash(screenCoord); // [0,1]\n\
-        currentT += noise * step.w;\n\
-        positionUv += noise * step.w * viewDirUv;\n\
-    #endif\n\
+    traverseOctreeFromBeginning(tileAndUv, traversalData, sampleDatas);\n\
+    vec4 step = getStepSize(sampleDatas[0], viewRayLocal, shapeIntersection, jacobianT, currentT);\n\
 \n\
     FragmentInput fragmentInput;\n\
     #if defined(STATISTICS)\n\
-        setStatistics(fragmentInput.metadata.statistics);\n\
+        setStatistics(fragmentInput.metadataStatistics);\n\
     #endif\n\
 \n\
+    czm_modelMaterial materialOutput;\n\
     vec4 colorAccum = vec4(0.0);\n\
 \n\
     for (int stepCount = 0; stepCount < STEP_COUNT_MAX; ++stepCount) {\n\
@@ -167,19 +181,20 @@ void main()\n\
 \n\
         // Prepare the custom shader inputs\n\
         copyPropertiesToMetadata(properties, fragmentInput.metadata);\n\
-        fragmentInput.voxel.positionUv = positionUv;\n\
-        fragmentInput.voxel.positionShapeUv = pointJacobian.point;\n\
-        fragmentInput.voxel.positionUvLocal = sampleDatas[0].tileUv;\n\
-        fragmentInput.voxel.viewDirUv = viewDirUv;\n\
-        fragmentInput.voxel.viewDirWorld = viewDirWorld;\n\
-        fragmentInput.voxel.surfaceNormal = step.xyz;\n\
+\n\
+        fragmentInput.attributes.positionEC = positionEC;\n\
+        // Re-normalize normals: some shape intersections may have been scaled to encode positive/negative shapes\n\
+        fragmentInput.attributes.normalEC = normalize(step.xyz);\n\
+\n\
+        fragmentInput.voxel.viewDirUv = viewRayLocal.dir;\n\
+\n\
         fragmentInput.voxel.travelDistance = step.w;\n\
         fragmentInput.voxel.stepCount = stepCount;\n\
         fragmentInput.voxel.tileIndex = sampleDatas[0].megatextureIndex;\n\
         fragmentInput.voxel.sampleIndex = getSampleIndex(sampleDatas[0]);\n\
+        fragmentInput.voxel.distanceToDepthBuffer = ix.distanceToDepthBuffer - currentT;\n\
 \n\
         // Run the custom shader\n\
-        czm_modelMaterial materialOutput;\n\
         fragmentMain(fragmentInput, materialOutput);\n\
 \n\
         // Sanitize the custom shader output\n\
@@ -199,13 +214,11 @@ void main()\n\
         if (step.w == 0.0) {\n\
             // Shape is infinitely thin. The ray may have hit the edge of a\n\
             // foreground voxel. Step ahead slightly to check for more voxels\n\
-            step.w == 0.00001;\n\
+            step.w = 0.001;\n\
         }\n\
 \n\
         // Keep raymarching\n\
         currentT += step.w;\n\
-        positionUv = viewPosUv + currentT * viewDirUv;\n\
-\n\
         // Check if there's more intersections.\n\
         if (currentT > endT) {\n\
             #if (INTERSECTION_COUNT == 1)\n\
@@ -218,16 +231,18 @@ void main()\n\
                     // Found another intersection. Resume raymarching there\n\
                     currentT = shapeIntersection.entry.w;\n\
                     endT = shapeIntersection.exit.w;\n\
-                    positionUv = viewPosUv + currentT * viewDirUv;\n\
                 }\n\
             #endif\n\
         }\n\
+        positionEC = viewRayEC.pos + currentT * viewRayEC.dir;\n\
+        tileAndUv = getTileAndUvCoordinate(positionEC);\n\
+        positionLocal = viewRayLocal.pos + currentT * viewRayLocal.dir;\n\
+        jacobianT = convertLocalToShapeSpaceDerivative(positionLocal);\n\
 \n\
         // Traverse the tree from the current ray position.\n\
         // This is similar to traverseOctreeFromBeginning but is faster when the ray is in the same tile as the previous step.\n\
-        pointJacobian = convertUvToShapeUvSpaceDerivative(positionUv);\n\
-        traverseOctreeFromExisting(pointJacobian.point, traversalData, sampleDatas);\n\
-        step = getStepSize(sampleDatas[0], viewRayUv, shapeIntersection, pointJacobian.jacobianT, currentT);\n\
+        traverseOctreeFromExisting(tileAndUv, traversalData, sampleDatas);\n\
+        step = getStepSize(sampleDatas[0], viewRayLocal, shapeIntersection, jacobianT, currentT);\n\
     }\n\
 \n\
     // Convert the alpha from [0,ALPHA_ACCUM_MAX] to [0,1]\n\

package/Source/Shaders/Voxels/VoxelUtils.js

@@ -2,22 +2,8 @@
 export default "struct Ray {\n\
     vec3 pos;\n\
     vec3 dir;\n\
-    vec3 rawDir;\n\
 };\n\
 \n\
-#if defined(JITTER)\n\
-/**\n\
- * Generate a pseudo-random value for a given 2D screen coordinate.\n\
- * Similar to https://www.shadertoy.com/view/4djSRW with a modified hashscale.\n\
- */\n\
-float hash(vec2 p)\n\
-{\n\
-    vec3 p3 = fract(vec3(p.xyx) * 50.0);\n\
-    p3 += dot(p3, p3.yzx + 19.19);\n\
-    return fract((p3.x + p3.y) * p3.z);\n\
-}\n\
-#endif\n\
-\n\
 float minComponent(in vec3 v) {\n\
     return min(min(v.x, v.y), v.z);\n\
 }\n\
@@ -25,9 +11,4 @@ float minComponent(in vec3 v) {\n\
 float maxComponent(in vec3 v) {\n\
     return max(max(v.x, v.y), v.z);\n\
 }\n\
-\n\
-struct PointJacobianT {\n\
-    vec3 point;\n\
-    mat3 jacobianT;\n\
-};\n\
 ";