@cesium/engine 20.0.1 → 21.0.0

package/Source/Scene/getClippingFunction.js

@@ -38,66 +38,61 @@ function getClippingFunction(clippingPlaneCollection, context) {
 }
 
 function clippingFunctionUnion(clippingPlanesLength) {
-  const functionString =
-    `${
-      "float clip(vec4 fragCoord, sampler2D clippingPlanes, mat4 clippingPlanesMatrix)\n" +
-      "{\n" +
-      "    vec4 position = czm_windowToEyeCoordinates(fragCoord);\n" +
-      "    vec3 clipNormal = vec3(0.0);\n" +
-      "    vec3 clipPosition = vec3(0.0);\n" +
-      "    float clipAmount;\n" + // For union planes, we want to get the min distance. So we set the initial value to the first plane distance in the loop below.
-      "    float pixelWidth = czm_metersPerPixel(position);\n" +
-      "    bool breakAndDiscard = false;\n" +
-      "    for (int i = 0; i < "
-    }${clippingPlanesLength}; ++i)\n` +
-    `    {\n` +
-    `        vec4 clippingPlane = getClippingPlane(clippingPlanes, i, clippingPlanesMatrix);\n` +
-    `        clipNormal = clippingPlane.xyz;\n` +
-    `        clipPosition = -clippingPlane.w * clipNormal;\n` +
-    `        float amount = dot(clipNormal, (position.xyz - clipPosition)) / pixelWidth;\n` +
-    `        clipAmount = czm_branchFreeTernary(i == 0, amount, min(amount, clipAmount));\n` +
-    `        if (amount <= 0.0)\n` +
-    `        {\n` +
-    `           breakAndDiscard = true;\n` +
-    `           break;\n` + // HLSL compiler bug if we discard here: https://bugs.chromium.org/p/angleproject/issues/detail?id=1945#c6
-    `        }\n` +
-    `    }\n` +
-    `    if (breakAndDiscard) {\n` +
-    `        discard;\n` +
-    `    }\n` +
-    `    return clipAmount;\n` +
-    `}\n`;
-  return functionString;
+  return `float clip(vec4 fragCoord, sampler2D clippingPlanes, mat4 clippingPlanesMatrix)
+{
+    vec4 position = czm_windowToEyeCoordinates(fragCoord);
+    vec3 clipNormal = vec3(0.0);
+    vec3 clipPosition = vec3(0.0);
+    float clipAmount;
+    float pixelWidth = czm_metersPerPixel(position);
+    bool breakAndDiscard = false;
+    for (int i = 0; i < ${clippingPlanesLength}; ++i)
+    {
+        vec4 clippingPlane = getClippingPlane(clippingPlanes, i, clippingPlanesMatrix);
+        clipNormal = clippingPlane.xyz;
+        clipPosition = -clippingPlane.w * clipNormal;
+        float amount = dot(clipNormal, (position.xyz - clipPosition)) / pixelWidth;
+        clipAmount = czm_branchFreeTernary(i == 0, amount, min(amount, clipAmount));
+        if (amount <= 0.0)
+        {
+            breakAndDiscard = true;
+            // HLSL compiler bug if we discard here: https://bugs.chromium.org/p/angleproject/issues/detail?id=1945#c6
+            break;
+         }
+    }
+    if (breakAndDiscard) {
+        discard;
+    }
+    return clipAmount;
+}
+`;
 }
 
 function clippingFunctionIntersect(clippingPlanesLength) {
-  const functionString =
-    `${
-      "float clip(vec4 fragCoord, sampler2D clippingPlanes, mat4 clippingPlanesMatrix)\n" +
-      "{\n" +
-      "    bool clipped = true;\n" +
-      "    vec4 position = czm_windowToEyeCoordinates(fragCoord);\n" +
-      "    vec3 clipNormal = vec3(0.0);\n" +
-      "    vec3 clipPosition = vec3(0.0);\n" +
-      "    float clipAmount = 0.0;\n" +
-      "    float pixelWidth = czm_metersPerPixel(position);\n" +
-      "    for (int i = 0; i < "
-    }${clippingPlanesLength}; ++i)\n` +
-    `    {\n` +
-    `        vec4 clippingPlane = getClippingPlane(clippingPlanes, i, clippingPlanesMatrix);\n` +
-    `        clipNormal = clippingPlane.xyz;\n` +
-    `        clipPosition = -clippingPlane.w * clipNormal;\n` +
-    `        float amount = dot(clipNormal, (position.xyz - clipPosition)) / pixelWidth;\n` +
-    `        clipAmount = max(amount, clipAmount);\n` +
-    `        clipped = clipped && (amount <= 0.0);\n` +
-    `    }\n` +
-    `    if (clipped)\n` +
-    `    {\n` +
-    `        discard;\n` +
-    `    }\n` +
-    `    return clipAmount;\n` +
-    `}\n`;
-  return functionString;
+  return `float clip(vec4 fragCoord, sampler2D clippingPlanes, mat4 clippingPlanesMatrix)
+{
+    bool clipped = true;
+    vec4 position = czm_windowToEyeCoordinates(fragCoord);
+    vec3 clipNormal = vec3(0.0);
+    vec3 clipPosition = vec3(0.0);
+    float clipAmount = 0.0;
+    float pixelWidth = czm_metersPerPixel(position);
+    for (int i = 0; i < ${clippingPlanesLength}; ++i)
+    {
+        vec4 clippingPlane = getClippingPlane(clippingPlanes, i, clippingPlanesMatrix);
+        clipNormal = clippingPlane.xyz;
+        clipPosition = -clippingPlane.w * clipNormal;
+        float amount = dot(clipNormal, (position.xyz - clipPosition)) / pixelWidth;
+        clipAmount = max(amount, clipAmount);
+        clipped = clipped && (amount <= 0.0);
+    }
+    if (clipped)
+    {
+        discard;
+    }
+    return clipAmount;
+ }
+`;
 }
 
 function getClippingPlaneFloat(width, height) {
@@ -113,19 +108,17 @@ function getClippingPlaneFloat(width, height) {
     pixelHeightString += ".0";
   }
 
-  const functionString =
-    `${
-      "vec4 getClippingPlane(highp sampler2D packedClippingPlanes, int clippingPlaneNumber, mat4 transform)\n" +
-      "{\n" +
-      "    int pixY = clippingPlaneNumber / "
-    }${width};\n` +
-    `    int pixX = clippingPlaneNumber - (pixY * ${width});\n` +
-    `    float u = (float(pixX) + 0.5) * ${pixelWidthString};\n` + // sample from center of pixel
-    `    float v = (float(pixY) + 0.5) * ${pixelHeightString};\n` +
-    `    vec4 plane = texture(packedClippingPlanes, vec2(u, v));\n` +
-    `    return czm_transformPlane(plane, transform);\n` +
-    `}\n`;
-  return functionString;
+  return `vec4 getClippingPlane(highp sampler2D packedClippingPlanes, int clippingPlaneNumber, mat4 transform)
+{
+    int pixY = clippingPlaneNumber / ${width};
+    int pixX = clippingPlaneNumber - (pixY * ${width});
+    // Sample from center of pixel
+    float u = (float(pixX) + 0.5) * ${pixelWidthString};
+    float v = (float(pixY) + 0.5) * ${pixelHeightString};
+    vec4 plane = texture(packedClippingPlanes, vec2(u, v));
+    return czm_transformPlane(plane, transform);
+}
+`;
 }
 
 function getClippingPlaneUint8(width, height) {
@@ -141,23 +134,21 @@ function getClippingPlaneUint8(width, height) {
     pixelHeightString += ".0";
   }
 
-  const functionString =
-    `${
-      "vec4 getClippingPlane(highp sampler2D packedClippingPlanes, int clippingPlaneNumber, mat4 transform)\n" +
-      "{\n" +
-      "    int clippingPlaneStartIndex = clippingPlaneNumber * 2;\n" + // clipping planes are two pixels each
-      "    int pixY = clippingPlaneStartIndex / "
-    }${width};\n` +
-    `    int pixX = clippingPlaneStartIndex - (pixY * ${width});\n` +
-    `    float u = (float(pixX) + 0.5) * ${pixelWidthString};\n` + // sample from center of pixel
-    `    float v = (float(pixY) + 0.5) * ${pixelHeightString};\n` +
-    `    vec4 oct32 = texture(packedClippingPlanes, vec2(u, v)) * 255.0;\n` +
-    `    vec2 oct = vec2(oct32.x * 256.0 + oct32.y, oct32.z * 256.0 + oct32.w);\n` +
-    `    vec4 plane;\n` +
-    `    plane.xyz = czm_octDecode(oct, 65535.0);\n` +
-    `    plane.w = czm_unpackFloat(texture(packedClippingPlanes, vec2(u + ${pixelWidthString}, v)));\n` +
-    `    return czm_transformPlane(plane, transform);\n` +
-    `}\n`;
-  return functionString;
+  return `vec4 getClippingPlane(highp sampler2D packedClippingPlanes, int clippingPlaneNumber, mat4 transform)
+{
+    int clippingPlaneStartIndex = clippingPlaneNumber * 2;
+    int pixY = clippingPlaneStartIndex / ${width};
+    int pixX = clippingPlaneStartIndex - (pixY * ${width});
+    // Sample from center of pixel
+    float u = (float(pixX) + 0.5) * ${pixelWidthString};
+    float v = (float(pixY) + 0.5) * ${pixelHeightString};
+    vec4 oct32 = texture(packedClippingPlanes, vec2(u, v)) * 255.0;
+    vec2 oct = vec2(oct32.x * 256.0 + oct32.y, oct32.z * 256.0 + oct32.w);
+    vec4 plane;
+    plane.xyz = czm_octDecode(oct, 65535.0);
+    plane.w = czm_unpackFloat(texture(packedClippingPlanes, vec2(u + ${pixelWidthString}, v)));
+    return czm_transformPlane(plane, transform);
+}
+`;
 }
 export default getClippingFunction;

package/Source/Shaders/BillboardCollectionVS.glsl

@@ -165,9 +165,11 @@ void main()
 
     temp = compressedAttribute0.z * SHIFT_RIGHT8;
     translate.x = floor(temp) - UPPER_BOUND;
+    translate.x *= SHIFT_RIGHT2; // undo translateX scaling (helps preserve subpixel precision, see BillboardCollection.js attribute writer for more info)
 
     translate.y += (temp - floor(temp)) * SHIFT_LEFT8;
     translate.y -= UPPER_BOUND;
+    translate.y *= SHIFT_RIGHT2;
 
     temp = compressedAttribute1.x * SHIFT_RIGHT8;
     float temp2 = floor(compressedAttribute2.w * SHIFT_RIGHT2);

package/Source/Shaders/BillboardCollectionVS.js

@@ -166,9 +166,11 @@ void main()\n\
 \n\
     temp = compressedAttribute0.z * SHIFT_RIGHT8;\n\
     translate.x = floor(temp) - UPPER_BOUND;\n\
+    translate.x *= SHIFT_RIGHT2; // undo translateX scaling (helps preserve subpixel precision, see BillboardCollection.js attribute writer for more info)\n\
 \n\
     translate.y += (temp - floor(temp)) * SHIFT_LEFT8;\n\
     translate.y -= UPPER_BOUND;\n\
+    translate.y *= SHIFT_RIGHT2;\n\
 \n\
     temp = compressedAttribute1.x * SHIFT_RIGHT8;\n\
     float temp2 = floor(compressedAttribute2.w * SHIFT_RIGHT2);\n\

package/Source/Shaders/Voxels/IntersectBox.glsl

@@ -5,43 +5,30 @@
 #define BOX_INTERSECTION_INDEX ### // always 0
 */
 
-uniform vec3 u_renderMinBounds;
-uniform vec3 u_renderMaxBounds;
-
-RayShapeIntersection intersectBox(in Ray ray, in vec3 minBound, in vec3 maxBound)
-{
-    // Consider the box as the intersection of the space between 3 pairs of parallel planes
-    // Compute the distance along the ray to each plane
-    vec3 t0 = (minBound - ray.pos) / ray.dir;
-    vec3 t1 = (maxBound - ray.pos) / ray.dir;
-
-    // Identify candidate entries/exits based on distance from ray.pos
-    vec3 entries = min(t0, t1);
-    vec3 exits = max(t0, t1);
-
-    vec3 directions = sign(ray.dir);
-
-    // The actual intersection points are the furthest entry and the closest exit
-    float lastEntry = maxComponent(entries);
-    bvec3 isLastEntry = equal(entries, vec3(lastEntry));
-    vec3 entryNormal = -1.0 * vec3(isLastEntry) * directions;
-    vec4 entry = vec4(entryNormal, lastEntry);
-
-    float firstExit = minComponent(exits);
-    bvec3 isFirstExit = equal(exits, vec3(firstExit));
-    vec3 exitNormal = vec3(isLastEntry) * directions;
-    vec4 exit = vec4(exitNormal, firstExit);
-
-    if (entry.w > exit.w) {
-        entry.w = NO_HIT;
-        exit.w = NO_HIT;
+uniform sampler2D u_renderBoundPlanesTexture;
+
+RayShapeIntersection intersectBoundPlanes(in Ray ray) {
+    vec4 lastEntry = vec4(ray.dir, -INF_HIT);
+    vec4 firstExit = vec4(-ray.dir, +INF_HIT);
+    for (int i = 0; i < 6; i++) {
+        vec4 boundPlane = getBoundPlane(u_renderBoundPlanesTexture, i);
+        vec4 intersection = intersectPlane(ray, boundPlane);
+        if (dot(ray.dir, boundPlane.xyz) < 0.0) {
+            lastEntry = intersection.w > lastEntry.w ? intersection : lastEntry;
+        } else {
+            firstExit = intersection.w < firstExit.w ? intersection: firstExit;
+        }
     }
 
-    return RayShapeIntersection(entry, exit);
+    if (lastEntry.w < firstExit.w) {
+        return RayShapeIntersection(lastEntry, firstExit);
+    } else {
+        return RayShapeIntersection(vec4(-ray.dir, NO_HIT), vec4(ray.dir, NO_HIT));
+    }
 }
 
-void intersectShape(in Ray ray, inout Intersections ix)
+void intersectShape(in Ray rayUV, in  Ray rayEC, inout Intersections ix)
 {
-    RayShapeIntersection intersection = intersectBox(ray, u_renderMinBounds, u_renderMaxBounds);
+    RayShapeIntersection intersection = intersectBoundPlanes(rayEC);
     setShapeIntersection(ix, BOX_INTERSECTION_INDEX, intersection);
 }

package/Source/Shaders/Voxels/IntersectBox.js

@@ -6,44 +6,31 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, RaySha
 #define BOX_INTERSECTION_INDEX ### // always 0\n\
 */\n\
 \n\
-uniform vec3 u_renderMinBounds;\n\
-uniform vec3 u_renderMaxBounds;\n\
-\n\
-RayShapeIntersection intersectBox(in Ray ray, in vec3 minBound, in vec3 maxBound)\n\
-{\n\
-    // Consider the box as the intersection of the space between 3 pairs of parallel planes\n\
-    // Compute the distance along the ray to each plane\n\
-    vec3 t0 = (minBound - ray.pos) / ray.dir;\n\
-    vec3 t1 = (maxBound - ray.pos) / ray.dir;\n\
-\n\
-    // Identify candidate entries/exits based on distance from ray.pos\n\
-    vec3 entries = min(t0, t1);\n\
-    vec3 exits = max(t0, t1);\n\
-\n\
-    vec3 directions = sign(ray.dir);\n\
-\n\
-    // The actual intersection points are the furthest entry and the closest exit\n\
-    float lastEntry = maxComponent(entries);\n\
-    bvec3 isLastEntry = equal(entries, vec3(lastEntry));\n\
-    vec3 entryNormal = -1.0 * vec3(isLastEntry) * directions;\n\
-    vec4 entry = vec4(entryNormal, lastEntry);\n\
-\n\
-    float firstExit = minComponent(exits);\n\
-    bvec3 isFirstExit = equal(exits, vec3(firstExit));\n\
-    vec3 exitNormal = vec3(isLastEntry) * directions;\n\
-    vec4 exit = vec4(exitNormal, firstExit);\n\
-\n\
-    if (entry.w > exit.w) {\n\
-        entry.w = NO_HIT;\n\
-        exit.w = NO_HIT;\n\
+uniform sampler2D u_renderBoundPlanesTexture;\n\
+\n\
+RayShapeIntersection intersectBoundPlanes(in Ray ray) {\n\
+    vec4 lastEntry = vec4(ray.dir, -INF_HIT);\n\
+    vec4 firstExit = vec4(-ray.dir, +INF_HIT);\n\
+    for (int i = 0; i < 6; i++) {\n\
+        vec4 boundPlane = getBoundPlane(u_renderBoundPlanesTexture, i);\n\
+        vec4 intersection = intersectPlane(ray, boundPlane);\n\
+        if (dot(ray.dir, boundPlane.xyz) < 0.0) {\n\
+            lastEntry = intersection.w > lastEntry.w ? intersection : lastEntry;\n\
+        } else {\n\
+            firstExit = intersection.w < firstExit.w ? intersection: firstExit;\n\
+        }\n\
     }\n\
 \n\
-    return RayShapeIntersection(entry, exit);\n\
+    if (lastEntry.w < firstExit.w) {\n\
+        return RayShapeIntersection(lastEntry, firstExit);\n\
+    } else {\n\
+        return RayShapeIntersection(vec4(-ray.dir, NO_HIT), vec4(ray.dir, NO_HIT));\n\
+    }\n\
 }\n\
 \n\
-void intersectShape(in Ray ray, inout Intersections ix)\n\
+void intersectShape(in Ray rayUV, in  Ray rayEC, inout Intersections ix)\n\
 {\n\
-    RayShapeIntersection intersection = intersectBox(ray, u_renderMinBounds, u_renderMaxBounds);\n\
+    RayShapeIntersection intersection = intersectBoundPlanes(rayEC);\n\
     setShapeIntersection(ix, BOX_INTERSECTION_INDEX, intersection);\n\
 }\n\
 ";

package/Source/Shaders/Voxels/IntersectCylinder.glsl

@@ -19,32 +19,30 @@
 
 // Cylinder uniforms
 uniform vec2 u_cylinderRenderRadiusMinMax;
-uniform vec2 u_cylinderRenderHeightMinMax;
 #if defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE)
     uniform vec2 u_cylinderRenderAngleMinMax;
 #endif
 
-/**
- * Find the intersection of a ray with the volume defined by two planes of constant z
- */
-RayShapeIntersection intersectHeightBounds(in Ray ray, in vec2 minMaxHeight, in bool convex)
-{
-    float zPosition = ray.pos.z;
-    float zDirection = ray.dir.z;
-
-    float tmin = (minMaxHeight.x - zPosition) / zDirection;
-    float tmax = (minMaxHeight.y - zPosition) / zDirection;
-
-    // Normals point outside the volume
-    float signFlip = convex ? 1.0 : -1.0;
-    vec4 intersectMin = vec4(0.0, 0.0, -1.0 * signFlip, tmin);
-    vec4 intersectMax = vec4(0.0, 0.0, 1.0 * signFlip, tmax);
-
-    bool topEntry = zDirection < 0.0;
-    vec4 entry = topEntry ? intersectMax : intersectMin;
-    vec4 exit = topEntry ? intersectMin : intersectMax;
+uniform sampler2D u_renderBoundPlanesTexture;
+
+RayShapeIntersection intersectBoundPlanes(in Ray ray) {
+    vec4 lastEntry = vec4(ray.dir, -INF_HIT);
+    vec4 firstExit = vec4(-ray.dir, +INF_HIT);
+    for (int i = 0; i < 2; i++) {
+        vec4 boundPlane = getBoundPlane(u_renderBoundPlanesTexture, i);
+        vec4 intersection = intersectPlane(ray, boundPlane);
+        if (dot(ray.dir, boundPlane.xyz) < 0.0) {
+            lastEntry = intersection.w > lastEntry.w ? intersection : lastEntry;
+        } else {
+            firstExit = intersection.w < firstExit.w ? intersection: firstExit;
+        }
+    }
 
-    return RayShapeIntersection(entry, exit);
+    if (lastEntry.w < firstExit.w) {
+        return RayShapeIntersection(lastEntry, firstExit);
+    } else {
+        return RayShapeIntersection(vec4(-ray.dir, NO_HIT), vec4(ray.dir, NO_HIT));
+    }
 }
 
 /**
@@ -70,8 +68,11 @@ RayShapeIntersection intersectCylinder(in Ray ray, in float radius, in bool conv
     float t1 = (-b - determinant) / a;
     float t2 = (-b + determinant) / a;
     float signFlip = convex ? 1.0 : -1.0;
-    vec4 intersect1 = vec4(normalize(position + t1 * direction) * signFlip, 0.0, t1);
-    vec4 intersect2 = vec4(normalize(position + t2 * direction) * signFlip, 0.0, t2);
+    vec3 normal1 = vec3((position + t1 * direction) * signFlip, 0.0);
+    vec3 normal2 = vec3((position + t2 * direction) * signFlip, 0.0);
+    // Return normals in eye coordinates
+    vec4 intersect1 = vec4(normalize(czm_normal * normal1), t1);
+    vec4 intersect2 = vec4(normalize(czm_normal * normal2), t2);
 
     return RayShapeIntersection(intersect1, intersect2);
 }
@@ -80,21 +81,16 @@ RayShapeIntersection intersectCylinder(in Ray ray, in float radius, in bool conv
  * Find the intersection of a ray with a right cylindrical solid of given
  * radius and height bounds. NOTE: The shape is assumed to be convex.
  */
-RayShapeIntersection intersectBoundedCylinder(in Ray ray, in float radius, in vec2 minMaxHeight)
+RayShapeIntersection intersectBoundedCylinder(in Ray ray, in Ray rayEC, in float radius)
 {
     RayShapeIntersection cylinderIntersection = intersectCylinder(ray, radius, true);
-    RayShapeIntersection heightBoundsIntersection = intersectHeightBounds(ray, minMaxHeight, true);
+    RayShapeIntersection heightBoundsIntersection = intersectBoundPlanes(rayEC);
     return intersectIntersections(ray, cylinderIntersection, heightBoundsIntersection);
 }
 
-void intersectShape(Ray ray, inout Intersections ix)
+void intersectShape(in Ray ray, in Ray rayEC, inout Intersections ix)
 {
-    // Position is converted from [0,1] to [-1,+1] because shape intersections assume unit space is [-1,+1].
-    // Direction is scaled as well to be in sync with position.
-    ray.pos = ray.pos * 2.0 - 1.0;
-    ray.dir *= 2.0;
-
-    RayShapeIntersection outerIntersect = intersectBoundedCylinder(ray, u_cylinderRenderRadiusMinMax.y, u_cylinderRenderHeightMinMax);
+    RayShapeIntersection outerIntersect = intersectBoundedCylinder(ray, rayEC, u_cylinderRenderRadiusMinMax.y);
 
     setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MAX, outerIntersect);
 

package/Source/Shaders/Voxels/IntersectCylinder.js

@@ -20,32 +20,30 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT
 \n\
 // Cylinder uniforms\n\
 uniform vec2 u_cylinderRenderRadiusMinMax;\n\
-uniform vec2 u_cylinderRenderHeightMinMax;\n\
 #if defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE)\n\
     uniform vec2 u_cylinderRenderAngleMinMax;\n\
 #endif\n\
 \n\
-/**\n\
- * Find the intersection of a ray with the volume defined by two planes of constant z\n\
- */\n\
-RayShapeIntersection intersectHeightBounds(in Ray ray, in vec2 minMaxHeight, in bool convex)\n\
-{\n\
-    float zPosition = ray.pos.z;\n\
-    float zDirection = ray.dir.z;\n\
-\n\
-    float tmin = (minMaxHeight.x - zPosition) / zDirection;\n\
-    float tmax = (minMaxHeight.y - zPosition) / zDirection;\n\
-\n\
-    // Normals point outside the volume\n\
-    float signFlip = convex ? 1.0 : -1.0;\n\
-    vec4 intersectMin = vec4(0.0, 0.0, -1.0 * signFlip, tmin);\n\
-    vec4 intersectMax = vec4(0.0, 0.0, 1.0 * signFlip, tmax);\n\
-\n\
-    bool topEntry = zDirection < 0.0;\n\
-    vec4 entry = topEntry ? intersectMax : intersectMin;\n\
-    vec4 exit = topEntry ? intersectMin : intersectMax;\n\
+uniform sampler2D u_renderBoundPlanesTexture;\n\
+\n\
+RayShapeIntersection intersectBoundPlanes(in Ray ray) {\n\
+    vec4 lastEntry = vec4(ray.dir, -INF_HIT);\n\
+    vec4 firstExit = vec4(-ray.dir, +INF_HIT);\n\
+    for (int i = 0; i < 2; i++) {\n\
+        vec4 boundPlane = getBoundPlane(u_renderBoundPlanesTexture, i);\n\
+        vec4 intersection = intersectPlane(ray, boundPlane);\n\
+        if (dot(ray.dir, boundPlane.xyz) < 0.0) {\n\
+            lastEntry = intersection.w > lastEntry.w ? intersection : lastEntry;\n\
+        } else {\n\
+            firstExit = intersection.w < firstExit.w ? intersection: firstExit;\n\
+        }\n\
+    }\n\
 \n\
-    return RayShapeIntersection(entry, exit);\n\
+    if (lastEntry.w < firstExit.w) {\n\
+        return RayShapeIntersection(lastEntry, firstExit);\n\
+    } else {\n\
+        return RayShapeIntersection(vec4(-ray.dir, NO_HIT), vec4(ray.dir, NO_HIT));\n\
+    }\n\
 }\n\
 \n\
 /**\n\
@@ -71,8 +69,11 @@ RayShapeIntersection intersectCylinder(in Ray ray, in float radius, in bool conv
     float t1 = (-b - determinant) / a;\n\
     float t2 = (-b + determinant) / a;\n\
     float signFlip = convex ? 1.0 : -1.0;\n\
-    vec4 intersect1 = vec4(normalize(position + t1 * direction) * signFlip, 0.0, t1);\n\
-    vec4 intersect2 = vec4(normalize(position + t2 * direction) * signFlip, 0.0, t2);\n\
+    vec3 normal1 = vec3((position + t1 * direction) * signFlip, 0.0);\n\
+    vec3 normal2 = vec3((position + t2 * direction) * signFlip, 0.0);\n\
+    // Return normals in eye coordinates\n\
+    vec4 intersect1 = vec4(normalize(czm_normal * normal1), t1);\n\
+    vec4 intersect2 = vec4(normalize(czm_normal * normal2), t2);\n\
 \n\
     return RayShapeIntersection(intersect1, intersect2);\n\
 }\n\
@@ -81,21 +82,16 @@ RayShapeIntersection intersectCylinder(in Ray ray, in float radius, in bool conv
  * Find the intersection of a ray with a right cylindrical solid of given\n\
  * radius and height bounds. NOTE: The shape is assumed to be convex.\n\
  */\n\
-RayShapeIntersection intersectBoundedCylinder(in Ray ray, in float radius, in vec2 minMaxHeight)\n\
+RayShapeIntersection intersectBoundedCylinder(in Ray ray, in Ray rayEC, in float radius)\n\
 {\n\
     RayShapeIntersection cylinderIntersection = intersectCylinder(ray, radius, true);\n\
-    RayShapeIntersection heightBoundsIntersection = intersectHeightBounds(ray, minMaxHeight, true);\n\
+    RayShapeIntersection heightBoundsIntersection = intersectBoundPlanes(rayEC);\n\
     return intersectIntersections(ray, cylinderIntersection, heightBoundsIntersection);\n\
 }\n\
 \n\
-void intersectShape(Ray ray, inout Intersections ix)\n\
+void intersectShape(in Ray ray, in Ray rayEC, inout Intersections ix)\n\
 {\n\
-    // Position is converted from [0,1] to [-1,+1] because shape intersections assume unit space is [-1,+1].\n\
-    // Direction is scaled as well to be in sync with position.\n\
-    ray.pos = ray.pos * 2.0 - 1.0;\n\
-    ray.dir *= 2.0;\n\
-\n\
-    RayShapeIntersection outerIntersect = intersectBoundedCylinder(ray, u_cylinderRenderRadiusMinMax.y, u_cylinderRenderHeightMinMax);\n\
+    RayShapeIntersection outerIntersect = intersectBoundedCylinder(ray, rayEC, u_cylinderRenderRadiusMinMax.y);\n\
 \n\
     setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MAX, outerIntersect);\n\
 \n\

package/Source/Shaders/Voxels/IntersectDepth.glsl

@@ -5,8 +5,6 @@
 #define DEPTH_INTERSECTION_INDEX ###
 */
 
-uniform mat4 u_transformPositionViewToUv;
-
 void intersectDepth(in vec2 screenCoord, in Ray ray, inout Intersections ix) {
     float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, screenCoord));
     float entry;
@@ -15,8 +13,7 @@ void intersectDepth(in vec2 screenCoord, in Ray ray, inout Intersections ix) {
         // Calculate how far the ray must travel before it hits the depth buffer.
         vec4 eyeCoordinateDepth = czm_screenToEyeCoordinates(screenCoord, logDepthOrDepth);
         eyeCoordinateDepth /= eyeCoordinateDepth.w;
-        vec3 depthPositionUv = vec3(u_transformPositionViewToUv * eyeCoordinateDepth);
-        entry = dot(depthPositionUv - ray.pos, ray.dir);
+        entry = dot(eyeCoordinateDepth.xyz - ray.pos, ray.dir);
         exit = +INF_HIT;
     } else {
         // There's no depth at this location.

package/Source/Shaders/Voxels/IntersectDepth.js

@@ -6,8 +6,6 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, Inters
 #define DEPTH_INTERSECTION_INDEX ###\n\
 */\n\
 \n\
-uniform mat4 u_transformPositionViewToUv;\n\
-\n\
 void intersectDepth(in vec2 screenCoord, in Ray ray, inout Intersections ix) {\n\
     float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, screenCoord));\n\
     float entry;\n\
@@ -16,8 +14,7 @@ void intersectDepth(in vec2 screenCoord, in Ray ray, inout Intersections ix) {\n
         // Calculate how far the ray must travel before it hits the depth buffer.\n\
         vec4 eyeCoordinateDepth = czm_screenToEyeCoordinates(screenCoord, logDepthOrDepth);\n\
         eyeCoordinateDepth /= eyeCoordinateDepth.w;\n\
-        vec3 depthPositionUv = vec3(u_transformPositionViewToUv * eyeCoordinateDepth);\n\
-        entry = dot(depthPositionUv - ray.pos, ray.dir);\n\
+        entry = dot(eyeCoordinateDepth.xyz - ray.pos, ray.dir);\n\
         exit = +INF_HIT;\n\
     } else {\n\
         // There's no depth at this location.\n\