@cesium/engine 20.0.2-ion.0 → 21.0.0

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\
@@ -80,23 +85,20 @@ 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\
@@ -163,32 +165,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 +194,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 +245,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.glsl

@@ -1,9 +1,9 @@
 // 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 convertLocalToBoxUv.glsl, convertLocalToCylinderUv.glsl, or convertLocalToEllipsoidUv.glsl
+// for the definitions of convertLocalToShapeSpaceDerivative and getTileAndUvCoordinate. 
+// The appropriate functions are 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
@@ -15,10 +15,10 @@
     #define ALPHA_ACCUM_MAX 0.98 // Must be > 0.0 and <= 1.0
 #endif
 
-uniform mat4 u_transformPositionUvToView;
+uniform mat4 u_transformPositionViewToLocal;
 uniform mat3 u_transformDirectionViewToLocal;
-uniform vec3 u_cameraPositionUv;
-uniform vec3 u_cameraDirectionUv;
+uniform vec3 u_cameraPositionLocal;
+uniform vec3 u_cameraDirectionLocal;
 uniform float u_stepSize;
 
 #if defined(PICKING)
@@ -63,16 +63,15 @@ RayShapeIntersection getVoxelIntersection(in vec3 tileUv, in vec3 sampleSizeAlon
 }
 
 vec4 getStepSize(in SampleData sampleData, in Ray viewRay, in RayShapeIntersection shapeIntersection, in mat3 jacobianT, in float currentT) {
-    // The Jacobian is computed in a space where the shape spans [-1, 1].
-    // But the ray is marched in a space where the shape fills [0, 1].
-    // So we need to scale the Jacobian by 2.
-    vec3 gradient = 2.0 * viewRay.rawDir * jacobianT;
+    vec3 gradient = viewRay.dir * jacobianT;
     vec3 sampleSizeAlongRay = getSampleSize(sampleData.tileCoords.w) / gradient;
 
     RayShapeIntersection voxelIntersection = getVoxelIntersection(sampleData.tileUv, sampleSizeAlongRay);
 
-    // Transform normal from shape space to Cartesian space
-    vec3 voxelNormal = normalize(jacobianT * voxelIntersection.entry.xyz);
+    // Transform normal from shape space to Cartesian space to eye space
+    vec3 voxelNormal = jacobianT * voxelIntersection.entry.xyz;
+    voxelNormal = normalize(czm_normal * voxelNormal);
+
     // Compare with the shape intersection, to choose the appropriate normal
     vec4 voxelEntry = vec4(voxelNormal, currentT + voxelIntersection.entry.w);
     vec4 entry = intersectionMax(shapeIntersection.entry, voxelEntry);
@@ -114,37 +113,40 @@ int getSampleIndex(in SampleData sampleData) {
 }
 
 /**
- * Compute the view ray at the current fragment, in the local UV coordinates of the shape.
+ * Compute the view ray at the current fragment, in the local coordinates of the shape.
  */
-Ray getViewRayUv() {
+Ray getViewRayLocal() {
     vec4 eyeCoordinates = czm_windowToEyeCoordinates(gl_FragCoord);
-    vec3 viewDirUv;
-    vec3 viewPosUv;
+    vec3 origin;
+    vec3 direction;
     if (czm_orthographicIn3D == 1.0) {
         eyeCoordinates.z = 0.0;
-        viewPosUv = (u_transformPositionViewToUv * eyeCoordinates).xyz;
-        viewDirUv = normalize(u_cameraDirectionUv);
+        origin = (u_transformPositionViewToLocal * eyeCoordinates).xyz;
+        direction = u_cameraDirectionLocal;
     } else {
-        viewPosUv = u_cameraPositionUv;
-        viewDirUv = normalize(u_transformDirectionViewToLocal * eyeCoordinates.xyz);
+        origin = u_cameraPositionLocal;
+        direction = u_transformDirectionViewToLocal * normalize(eyeCoordinates.xyz);
     }
-    #if defined(SHAPE_ELLIPSOID)
-        // viewDirUv has been scaled to a space where the ellipsoid is a sphere.
-        // Undo this scaling to get the raw direction.
-        vec3 rawDir = viewDirUv * u_ellipsoidRadiiUv;
-        return Ray(viewPosUv, viewDirUv, rawDir);
-    #else
-        return Ray(viewPosUv, viewDirUv, viewDirUv);
-    #endif
+    return Ray(origin, direction);
+}
+
+Ray getViewRayEC() {
+    vec4 eyeCoordinates = czm_windowToEyeCoordinates(gl_FragCoord);
+    vec3 viewPosEC = (czm_orthographicIn3D == 1.0)
+        ? vec3(eyeCoordinates.xy, 0.0)
+        : vec3(0.0);
+    vec3 viewDirEC = normalize(eyeCoordinates.xyz);
+    return Ray(viewPosEC, viewDirEC);
 }
 
 void main()
 {
-    Ray viewRayUv = getViewRayUv();
+    Ray viewRayLocal = getViewRayLocal();
+    Ray viewRayEC = getViewRayEC();
 
     Intersections ix;
     vec2 screenCoord = (gl_FragCoord.xy - czm_viewport.xy) / czm_viewport.zw; // [0,1]
-    RayShapeIntersection shapeIntersection = intersectScene(screenCoord, viewRayUv, ix);
+    RayShapeIntersection shapeIntersection = intersectScene(screenCoord, viewRayLocal, viewRayEC, ix);
     // Exit early if the scene was completely missed.
     if (shapeIntersection.entry.w == NO_HIT) {
         discard;
@@ -152,20 +154,17 @@ void main()
 
     float currentT = shapeIntersection.entry.w;
     float endT = shapeIntersection.exit.w;
-    vec3 positionUv = viewRayUv.pos + currentT * viewRayUv.dir;
-    PointJacobianT pointJacobian = convertUvToShapeUvSpaceDerivative(positionUv);
+
+    vec3 positionEC = viewRayEC.pos + currentT * viewRayEC.dir;
+    TileAndUvCoordinate tileAndUv = getTileAndUvCoordinate(positionEC);
+    vec3 positionLocal = viewRayLocal.pos + currentT * viewRayLocal.dir;
+    mat3 jacobianT = convertLocalToShapeSpaceDerivative(positionLocal);
 
     // Traverse the tree from the start position
     TraversalData traversalData;
     SampleData sampleDatas[SAMPLE_COUNT];
-    traverseOctreeFromBeginning(pointJacobian.point, traversalData, sampleDatas);
-    vec4 step = getStepSize(sampleDatas[0], viewRayUv, shapeIntersection, pointJacobian.jacobianT, currentT);
-
-    #if defined(JITTER)
-        float noise = hash(screenCoord); // [0,1]
-        currentT += noise * step.w;
-        positionUv += noise * step.w * viewRayUv.dir;
-    #endif
+    traverseOctreeFromBeginning(tileAndUv, traversalData, sampleDatas);
+    vec4 step = getStepSize(sampleDatas[0], viewRayLocal, shapeIntersection, jacobianT, currentT);
 
     FragmentInput fragmentInput;
     #if defined(STATISTICS)
@@ -182,10 +181,11 @@ void main()
         // Prepare the custom shader inputs
         copyPropertiesToMetadata(properties, fragmentInput.metadata);
 
-        fragmentInput.attributes.positionEC = vec3(u_transformPositionUvToView * vec4(positionUv, 1.0));
-        fragmentInput.attributes.normalEC = normalize(czm_normal * step.xyz);
+        fragmentInput.attributes.positionEC = positionEC;
+        // Re-normalize normals: some shape intersections may have been scaled to encode positive/negative shapes
+        fragmentInput.attributes.normalEC = normalize(step.xyz);
 
-        fragmentInput.voxel.viewDirUv = viewRayUv.dir;
+        fragmentInput.voxel.viewDirUv = viewRayLocal.dir;
 
         fragmentInput.voxel.travelDistance = step.w;
         fragmentInput.voxel.stepCount = stepCount;
@@ -233,13 +233,15 @@ void main()
                 }
             #endif
         }
-        positionUv = viewRayUv.pos + currentT * viewRayUv.dir;
+        positionEC = viewRayEC.pos + currentT * viewRayEC.dir;
+        tileAndUv = getTileAndUvCoordinate(positionEC);
+        positionLocal = viewRayLocal.pos + currentT * viewRayLocal.dir;
+        jacobianT = convertLocalToShapeSpaceDerivative(positionLocal);
 
         // Traverse the tree from the current ray position.
         // This is similar to traverseOctreeFromBeginning but is faster when the ray is in the same tile as the previous step.
-        pointJacobian = convertUvToShapeUvSpaceDerivative(positionUv);
-        traverseOctreeFromExisting(pointJacobian.point, traversalData, sampleDatas);
-        step = getStepSize(sampleDatas[0], viewRayUv, shapeIntersection, pointJacobian.jacobianT, currentT);
+        traverseOctreeFromExisting(tileAndUv, traversalData, sampleDatas);
+        step = getStepSize(sampleDatas[0], viewRayLocal, shapeIntersection, jacobianT, currentT);
     }
 
     // Convert the alpha from [0,ALPHA_ACCUM_MAX] to [0,1]

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,10 +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_transformPositionUvToView;\n\
+uniform mat4 u_transformPositionViewToLocal;\n\
 uniform mat3 u_transformDirectionViewToLocal;\n\
-uniform vec3 u_cameraPositionUv;\n\
-uniform vec3 u_cameraDirectionUv;\n\
+uniform vec3 u_cameraPositionLocal;\n\
+uniform vec3 u_cameraDirectionLocal;\n\
 uniform float u_stepSize;\n\
 \n\
 #if defined(PICKING)\n\
@@ -64,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\
@@ -115,37 +114,40 @@ int getSampleIndex(in SampleData sampleData) {\n\
 }\n\
 \n\
 /**\n\
- * Compute the view ray at the current fragment, in the local UV coordinates of the shape.\n\
+ * Compute the view ray at the current fragment, in the local coordinates of the shape.\n\
  */\n\
-Ray getViewRayUv() {\n\
+Ray getViewRayLocal() {\n\
     vec4 eyeCoordinates = czm_windowToEyeCoordinates(gl_FragCoord);\n\
-    vec3 viewDirUv;\n\
-    vec3 viewPosUv;\n\
+    vec3 origin;\n\
+    vec3 direction;\n\
     if (czm_orthographicIn3D == 1.0) {\n\
         eyeCoordinates.z = 0.0;\n\
-        viewPosUv = (u_transformPositionViewToUv * eyeCoordinates).xyz;\n\
-        viewDirUv = normalize(u_cameraDirectionUv);\n\
+        origin = (u_transformPositionViewToLocal * eyeCoordinates).xyz;\n\
+        direction = u_cameraDirectionLocal;\n\
     } else {\n\
-        viewPosUv = u_cameraPositionUv;\n\
-        viewDirUv = normalize(u_transformDirectionViewToLocal * eyeCoordinates.xyz);\n\
+        origin = u_cameraPositionLocal;\n\
+        direction = u_transformDirectionViewToLocal * normalize(eyeCoordinates.xyz);\n\
     }\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\
-        return Ray(viewPosUv, viewDirUv, rawDir);\n\
-    #else\n\
-        return Ray(viewPosUv, viewDirUv, viewDirUv);\n\
-    #endif\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\
-    Ray viewRayUv = getViewRayUv();\n\
+    Ray viewRayLocal = getViewRayLocal();\n\
+    Ray viewRayEC = getViewRayEC();\n\
 \n\
     Intersections ix;\n\
     vec2 screenCoord = (gl_FragCoord.xy - czm_viewport.xy) / czm_viewport.zw; // [0,1]\n\
-    RayShapeIntersection shapeIntersection = intersectScene(screenCoord, viewRayUv, ix);\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\
@@ -153,20 +155,17 @@ void main()\n\
 \n\
     float currentT = shapeIntersection.entry.w;\n\
     float endT = shapeIntersection.exit.w;\n\
-    vec3 positionUv = viewRayUv.pos + currentT * viewRayUv.dir;\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 * viewRayUv.dir;\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\
@@ -183,10 +182,11 @@ void main()\n\
         // Prepare the custom shader inputs\n\
         copyPropertiesToMetadata(properties, fragmentInput.metadata);\n\
 \n\
-        fragmentInput.attributes.positionEC = vec3(u_transformPositionUvToView * vec4(positionUv, 1.0));\n\
-        fragmentInput.attributes.normalEC = normalize(czm_normal * step.xyz);\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 = viewRayUv.dir;\n\
+        fragmentInput.voxel.viewDirUv = viewRayLocal.dir;\n\
 \n\
         fragmentInput.voxel.travelDistance = step.w;\n\
         fragmentInput.voxel.stepCount = stepCount;\n\
@@ -234,13 +234,15 @@ void main()\n\
                 }\n\
             #endif\n\
         }\n\
-        positionUv = viewRayUv.pos + currentT * viewRayUv.dir;\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.glsl

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

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\
 ";

package/Source/Shaders/Voxels/convertLocalToBoxUv.glsl

@@ -0,0 +1,30 @@
+uniform vec3 u_boxLocalToShapeUvScale;
+uniform vec3 u_boxLocalToShapeUvTranslate;
+
+uniform ivec4 u_cameraTileCoordinates;
+uniform vec3 u_cameraTileUv;
+uniform mat3 u_boxEcToXyz;
+
+mat3 convertLocalToShapeSpaceDerivative(in vec3 positionLocal) {
+    // For BOX, local space = shape space, so the Jacobian is the identity matrix.
+    return mat3(1.0);
+}
+
+vec3 scaleShapeUvToShapeSpace(in vec3 shapeUv) {
+    return shapeUv / u_boxLocalToShapeUvScale;
+}
+
+vec3 convertEcToDeltaTile(in vec3 positionEC) {
+    vec3 dPosition = u_boxEcToXyz * positionEC;
+    return u_boxLocalToShapeUvScale * dPosition * float(1 << u_cameraTileCoordinates.w);
+}
+
+TileAndUvCoordinate getTileAndUvCoordinate(in vec3 positionEC) {
+    vec3 deltaTileCoordinate = convertEcToDeltaTile(positionEC);
+    vec3 tileUvSum = u_cameraTileUv + deltaTileCoordinate;
+    ivec3 tileCoordinate = u_cameraTileCoordinates.xyz + ivec3(floor(tileUvSum));
+    tileCoordinate = min(max(ivec3(0), tileCoordinate), ivec3((1 << u_cameraTileCoordinates.w) - 1));
+    ivec3 tileCoordinateChange = tileCoordinate - u_cameraTileCoordinates.xyz;
+    vec3 tileUv = clamp(tileUvSum - vec3(tileCoordinateChange), 0.0, 1.0);
+    return TileAndUvCoordinate(ivec4(tileCoordinate, u_cameraTileCoordinates.w), tileUv);
+}

package/Source/Shaders/Voxels/convertLocalToBoxUv.js

@@ -0,0 +1,32 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec3 u_boxLocalToShapeUvScale;\n\
+uniform vec3 u_boxLocalToShapeUvTranslate;\n\
+\n\
+uniform ivec4 u_cameraTileCoordinates;\n\
+uniform vec3 u_cameraTileUv;\n\
+uniform mat3 u_boxEcToXyz;\n\
+\n\
+mat3 convertLocalToShapeSpaceDerivative(in vec3 positionLocal) {\n\
+    // For BOX, local space = shape space, so the Jacobian is the identity matrix.\n\
+    return mat3(1.0);\n\
+}\n\
+\n\
+vec3 scaleShapeUvToShapeSpace(in vec3 shapeUv) {\n\
+    return shapeUv / u_boxLocalToShapeUvScale;\n\
+}\n\
+\n\
+vec3 convertEcToDeltaTile(in vec3 positionEC) {\n\
+    vec3 dPosition = u_boxEcToXyz * positionEC;\n\
+    return u_boxLocalToShapeUvScale * dPosition * float(1 << u_cameraTileCoordinates.w);\n\
+}\n\
+\n\
+TileAndUvCoordinate getTileAndUvCoordinate(in vec3 positionEC) {\n\
+    vec3 deltaTileCoordinate = convertEcToDeltaTile(positionEC);\n\
+    vec3 tileUvSum = u_cameraTileUv + deltaTileCoordinate;\n\
+    ivec3 tileCoordinate = u_cameraTileCoordinates.xyz + ivec3(floor(tileUvSum));\n\
+    tileCoordinate = min(max(ivec3(0), tileCoordinate), ivec3((1 << u_cameraTileCoordinates.w) - 1));\n\
+    ivec3 tileCoordinateChange = tileCoordinate - u_cameraTileCoordinates.xyz;\n\
+    vec3 tileUv = clamp(tileUvSum - vec3(tileCoordinateChange), 0.0, 1.0);\n\
+    return TileAndUvCoordinate(ivec4(tileCoordinate, u_cameraTileCoordinates.w), tileUv);\n\
+}\n\
+";