@cesium/engine 2.0.0 → 2.2.0

package/Source/Scene/processVoxelProperties.js

@@ -151,6 +151,7 @@ function processVoxelProperties(renderResources, primitive) {
   shaderBuilder.addStructField(voxelStructId, "vec3", "positionUvLocal");
   shaderBuilder.addStructField(voxelStructId, "vec3", "viewDirUv");
   shaderBuilder.addStructField(voxelStructId, "vec3", "viewDirWorld");
+  shaderBuilder.addStructField(voxelStructId, "vec3", "surfaceNormal");
   shaderBuilder.addStructField(voxelStructId, "float", "travelDistance");
 
   // FragmentInput struct
@@ -355,7 +356,7 @@ function processVoxelProperties(renderResources, primitive) {
  * @function
  *
  * @param {MetadataType} type The {@link MetadataType}.
- * @returns {String} The GLSL type.
+ * @returns {string} The GLSL type.
  *
  * @private
  */
@@ -377,7 +378,7 @@ function getGlslType(type) {
  * @function
  *
  * @param {MetadataType} type The {@link MetadataType}.
- * @returns {String} The GLSL swizzle.
+ * @returns {string} The GLSL swizzle.
  *
  * @private
  */
@@ -399,7 +400,7 @@ function getGlslTextureSwizzle(type) {
  * @function
  *
  * @param {MetadataType} type The {@link MetadataType}.
- * @returns {String} The GLSL type.
+ * @returns {string} The GLSL type.
  *
  * @private
  */
@@ -421,8 +422,8 @@ function getGlslPartialDerivativeType(type) {
  *
  * @function
  *
- * @param {Number} number The number to convert.
- * @returns {String} The number as floating point in GLSL.
+ * @param {number} number The number to convert.
+ * @returns {string} The number as floating point in GLSL.
  *
  * @private
  */
@@ -440,8 +441,8 @@ function getGlslNumberAsFloat(number) {
  * @function
  *
  * @param {MetadataType} type
- * @param {Number} index
- * @returns {String}
+ * @param {number} index
+ * @returns {string}
  *
  * @private
  */

package/Source/Shaders/Voxels/IntersectBox.glsl

@@ -1,79 +1,73 @@
 // See IntersectionUtils.glsl for the definitions of Ray and NO_HIT
+// See convertUvToBox.glsl for the definition of convertShapeUvToUvSpace
 
 /* Box defines (set in Scene/VoxelBoxShape.js)
 #define BOX_INTERSECTION_INDEX ### // always 0
-#define BOX_HAS_RENDER_BOUNDS
-#define BOX_IS_2D
 */
 
-#if defined(BOX_HAS_RENDER_BOUNDS)
-    #if defined(BOX_IS_2D)
-        // This matrix bakes in an axis conversion so that the math works for XY plane.
-        uniform mat4 u_boxUvToRenderBoundsTransform;
-    #else
-        // Similar to u_boxTransformUvToBounds but fewer instructions needed.
-        uniform vec3 u_boxUvToRenderBoundsScale;
-        uniform vec3 u_boxUvToRenderBoundsTranslate;
-    #endif
-#endif
+uniform vec3 u_renderMinBounds;
+uniform vec3 u_renderMaxBounds;
 
-vec2 intersectUnitCube(Ray ray) // Unit cube from [-1, +1]
+struct Box {
+    vec3 p0;
+    vec3 p1;
+};
+
+Box constructVoxelBox(in ivec4 octreeCoords, in vec3 tileUv)
 {
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
+    // Find the min/max cornerpoints of the voxel in tile coordinates
+    vec3 tileOrigin = vec3(octreeCoords.xyz);
+    vec3 numSamples = vec3(u_dimensions);
+    vec3 voxelSize = 1.0 / numSamples;
+    vec3 coordP0 = floor(tileUv * numSamples) * voxelSize + tileOrigin;
+    vec3 coordP1 = coordP0 + voxelSize;
 
-    vec3 dInv = 1.0 / d;
-    vec3 od = -o * dInv;
-    vec3 t0 = od - dInv;
-    vec3 t1 = od + dInv;
-    vec3 m0 = min(t0, t1);
-    vec3 m1 = max(t0, t1);
-    float tMin = max(max(m0.x, m0.y), m0.z);
-    float tMax = min(min(m1.x, m1.y), m1.z);
+    // Transform to the UV coordinates of the scaled tileset
+    float tileSize = 1.0 / pow(2.0, float(octreeCoords.w));
+    vec3 p0 = convertShapeUvToUvSpace(coordP0 * tileSize);
+    vec3 p1 = convertShapeUvToUvSpace(coordP1 * tileSize);
 
-    if (tMin >= tMax) {
-        return vec2(NO_HIT);
-    }
+    return Box(p0, p1);
+}
 
-    return vec2(tMin, tMax);
+vec3 getBoxNormal(in Box box, in Ray ray, in float t)
+{
+    vec3 hitPoint = ray.pos + t * ray.dir;
+    vec3 lower = step(hitPoint, box.p0);
+    vec3 upper = step(box.p1, hitPoint);
+    return normalize(upper - lower);
 }
 
-vec2 intersectUnitSquare(Ray ray) // Unit square from [-1, +1]
+// Find the distances along a ray at which the ray intersects an axis-aligned box
+// See https://tavianator.com/2011/ray_box.html
+RayShapeIntersection intersectBox(in Ray ray, in Box box)
 {
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
+    // 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 = (box.p0 - ray.pos) * ray.dInv;
+    vec3 t1 = (box.p1 - ray.pos) * ray.dInv;
 
-    float t = -o.z / d.z;
-    vec2 planePos = o.xy + d.xy * t;
-    if (any(greaterThan(abs(planePos), vec2(1.0)))) {
-        return vec2(NO_HIT);
+    // Identify candidate entries/exits based on distance from ray.pos
+    vec3 entries = min(t0, t1);
+    vec3 exits = max(t0, t1);
+
+    // The actual box intersection points are the furthest entry and the closest exit
+    float entryT = max(max(entries.x, entries.y), entries.z);
+    float exitT = min(min(exits.x, exits.y), exits.z);
+
+    vec3 entryNormal = getBoxNormal(box, ray, entryT - RAY_SHIFT);
+    vec3 exitNormal = getBoxNormal(box, ray, exitT + RAY_SHIFT);
+
+    if (entryT > exitT) {
+        entryT = NO_HIT;
+        exitT = NO_HIT;
     }
 
-    return vec2(t, t);
+    return RayShapeIntersection(vec4(entryNormal, entryT), vec4(exitNormal, exitT));
 }
 
-void intersectShape(Ray ray, inout Intersections ix)
+void intersectShape(in Ray ray, inout Intersections ix)
 {
-    #if defined(BOX_HAS_RENDER_BOUNDS)
-        #if defined(BOX_IS_2D)
-            // Transform the ray into unit square space on Z plane
-            // This matrix bakes in an axis conversion so that the math works for XY plane.
-            ray.pos = vec3(u_boxUvToRenderBoundsTransform * vec4(ray.pos, 1.0));
-            ray.dir = vec3(u_boxUvToRenderBoundsTransform * vec4(ray.dir, 0.0));
-            vec2 entryExit = intersectUnitSquare(ray);
-        #else
-            // Transform the ray into unit cube space
-            ray.pos = ray.pos * u_boxUvToRenderBoundsScale + u_boxUvToRenderBoundsTranslate;
-            ray.dir *= u_boxUvToRenderBoundsScale;
-            vec2 entryExit = intersectUnitCube(ray);
-        #endif
-    #else
-        // 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 = ray.dir * 2.0;
-        vec2 entryExit = intersectUnitCube(ray);
-    #endif
-
-    setIntersectionPair(ix, BOX_INTERSECTION_INDEX, entryExit);
+    RayShapeIntersection intersection = intersectBox(ray, Box(u_renderMinBounds, u_renderMaxBounds));
+    setShapeIntersection(ix, BOX_INTERSECTION_INDEX, intersection);
 }

package/Source/Shaders/Voxels/IntersectBox.js

@@ -1,81 +1,75 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "// See IntersectionUtils.glsl for the definitions of Ray and NO_HIT\n\
+// See convertUvToBox.glsl for the definition of convertShapeUvToUvSpace\n\
 \n\
 /* Box defines (set in Scene/VoxelBoxShape.js)\n\
 #define BOX_INTERSECTION_INDEX ### // always 0\n\
-#define BOX_HAS_RENDER_BOUNDS\n\
-#define BOX_IS_2D\n\
 */\n\
 \n\
-#if defined(BOX_HAS_RENDER_BOUNDS)\n\
-    #if defined(BOX_IS_2D)\n\
-        // This matrix bakes in an axis conversion so that the math works for XY plane.\n\
-        uniform mat4 u_boxUvToRenderBoundsTransform;\n\
-    #else\n\
-        // Similar to u_boxTransformUvToBounds but fewer instructions needed.\n\
-        uniform vec3 u_boxUvToRenderBoundsScale;\n\
-        uniform vec3 u_boxUvToRenderBoundsTranslate;\n\
-    #endif\n\
-#endif\n\
+uniform vec3 u_renderMinBounds;\n\
+uniform vec3 u_renderMaxBounds;\n\
 \n\
-vec2 intersectUnitCube(Ray ray) // Unit cube from [-1, +1]\n\
+struct Box {\n\
+    vec3 p0;\n\
+    vec3 p1;\n\
+};\n\
+\n\
+Box constructVoxelBox(in ivec4 octreeCoords, in vec3 tileUv)\n\
 {\n\
-    vec3 o = ray.pos;\n\
-    vec3 d = ray.dir;\n\
+    // Find the min/max cornerpoints of the voxel in tile coordinates\n\
+    vec3 tileOrigin = vec3(octreeCoords.xyz);\n\
+    vec3 numSamples = vec3(u_dimensions);\n\
+    vec3 voxelSize = 1.0 / numSamples;\n\
+    vec3 coordP0 = floor(tileUv * numSamples) * voxelSize + tileOrigin;\n\
+    vec3 coordP1 = coordP0 + voxelSize;\n\
 \n\
-    vec3 dInv = 1.0 / d;\n\
-    vec3 od = -o * dInv;\n\
-    vec3 t0 = od - dInv;\n\
-    vec3 t1 = od + dInv;\n\
-    vec3 m0 = min(t0, t1);\n\
-    vec3 m1 = max(t0, t1);\n\
-    float tMin = max(max(m0.x, m0.y), m0.z);\n\
-    float tMax = min(min(m1.x, m1.y), m1.z);\n\
+    // Transform to the UV coordinates of the scaled tileset\n\
+    float tileSize = 1.0 / pow(2.0, float(octreeCoords.w));\n\
+    vec3 p0 = convertShapeUvToUvSpace(coordP0 * tileSize);\n\
+    vec3 p1 = convertShapeUvToUvSpace(coordP1 * tileSize);\n\
 \n\
-    if (tMin >= tMax) {\n\
-        return vec2(NO_HIT);\n\
-    }\n\
+    return Box(p0, p1);\n\
+}\n\
 \n\
-    return vec2(tMin, tMax);\n\
+vec3 getBoxNormal(in Box box, in Ray ray, in float t)\n\
+{\n\
+    vec3 hitPoint = ray.pos + t * ray.dir;\n\
+    vec3 lower = step(hitPoint, box.p0);\n\
+    vec3 upper = step(box.p1, hitPoint);\n\
+    return normalize(upper - lower);\n\
 }\n\
 \n\
-vec2 intersectUnitSquare(Ray ray) // Unit square from [-1, +1]\n\
+// Find the distances along a ray at which the ray intersects an axis-aligned box\n\
+// See https://tavianator.com/2011/ray_box.html\n\
+RayShapeIntersection intersectBox(in Ray ray, in Box box)\n\
 {\n\
-    vec3 o = ray.pos;\n\
-    vec3 d = ray.dir;\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 = (box.p0 - ray.pos) * ray.dInv;\n\
+    vec3 t1 = (box.p1 - ray.pos) * ray.dInv;\n\
 \n\
-    float t = -o.z / d.z;\n\
-    vec2 planePos = o.xy + d.xy * t;\n\
-    if (any(greaterThan(abs(planePos), vec2(1.0)))) {\n\
-        return vec2(NO_HIT);\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\
+    // The actual box intersection points are the furthest entry and the closest exit\n\
+    float entryT = max(max(entries.x, entries.y), entries.z);\n\
+    float exitT = min(min(exits.x, exits.y), exits.z);\n\
+\n\
+    vec3 entryNormal = getBoxNormal(box, ray, entryT - RAY_SHIFT);\n\
+    vec3 exitNormal = getBoxNormal(box, ray, exitT + RAY_SHIFT);\n\
+\n\
+    if (entryT > exitT) {\n\
+        entryT = NO_HIT;\n\
+        exitT = NO_HIT;\n\
     }\n\
 \n\
-    return vec2(t, t);\n\
+    return RayShapeIntersection(vec4(entryNormal, entryT), vec4(exitNormal, exitT));\n\
 }\n\
 \n\
-void intersectShape(Ray ray, inout Intersections ix)\n\
+void intersectShape(in Ray ray, inout Intersections ix)\n\
 {\n\
-    #if defined(BOX_HAS_RENDER_BOUNDS)\n\
-        #if defined(BOX_IS_2D)\n\
-            // Transform the ray into unit square space on Z plane\n\
-            // This matrix bakes in an axis conversion so that the math works for XY plane.\n\
-            ray.pos = vec3(u_boxUvToRenderBoundsTransform * vec4(ray.pos, 1.0));\n\
-            ray.dir = vec3(u_boxUvToRenderBoundsTransform * vec4(ray.dir, 0.0));\n\
-            vec2 entryExit = intersectUnitSquare(ray);\n\
-        #else\n\
-            // Transform the ray into unit cube space\n\
-            ray.pos = ray.pos * u_boxUvToRenderBoundsScale + u_boxUvToRenderBoundsTranslate;\n\
-            ray.dir *= u_boxUvToRenderBoundsScale;\n\
-            vec2 entryExit = intersectUnitCube(ray);\n\
-        #endif\n\
-    #else\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 = ray.dir * 2.0;\n\
-        vec2 entryExit = intersectUnitCube(ray);\n\
-    #endif\n\
-\n\
-    setIntersectionPair(ix, BOX_INTERSECTION_INDEX, entryExit);\n\
+    RayShapeIntersection intersection = intersectBox(ray, Box(u_renderMinBounds, u_renderMaxBounds));\n\
+    setShapeIntersection(ix, BOX_INTERSECTION_INDEX, intersection);\n\
 }\n\
 ";

package/Source/Shaders/Voxels/IntersectClippingPlanes.glsl

@@ -11,60 +11,68 @@ uniform sampler2D u_clippingPlanesTexture;
 uniform mat4 u_clippingPlanesMatrix;
 
 // Plane is in Hessian Normal Form
-vec2 intersectPlane(Ray ray, vec4 plane) {
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
+vec4 intersectPlane(in Ray ray, in vec4 plane) {
     vec3 n = plane.xyz; // normal
     float w = plane.w; // -dot(pointOnPlane, normal)
 
-    float a = dot(o, n);
-    float b = dot(d, n);
+    float a = dot(ray.pos, n);
+    float b = dot(ray.dir, n);
     float t = -(w + a) / b;
 
-    if (dot(d, n) > 0.0) {
-        return vec2(t, +INF_HIT);
-    } else {
-        return vec2(-INF_HIT, t);
-    }
+    return vec4(n, t);
 }
 
-void intersectClippingPlanes(Ray ray, inout Intersections ix) {
+void intersectClippingPlanes(in Ray ray, inout Intersections ix) {
+    vec4 backSide = vec4(-ray.dir, -INF_HIT);
+    vec4 farSide = vec4(ray.dir, +INF_HIT);
+    RayShapeIntersection clippingVolume;
+
     #if (CLIPPING_PLANES_COUNT == 1)
         // Union and intersection are the same when there's one clipping plane, and the code
         // is more simplified.
         vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, 0, u_clippingPlanesMatrix);
-        vec2 intersection = intersectPlane(ray, planeUv);
-        setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, intersection);
+        vec4 intersection = intersectPlane(ray, planeUv);
+        bool reflects = dot(ray.dir, intersection.xyz) < 0.0;
+        clippingVolume.entry = reflects ? backSide : intersection;
+        clippingVolume.exit = reflects ? intersection : farSide;
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX, clippingVolume);
     #elif defined(CLIPPING_PLANES_UNION)
-        float minPositiveT = +INF_HIT;
-        float maxNegativeT = -INF_HIT;
+        vec4 firstTransmission = vec4(ray.dir, +INF_HIT);
+        vec4 lastReflection = vec4(-ray.dir, -INF_HIT);
         for (int i = 0; i < CLIPPING_PLANES_COUNT; i++) {
             vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i, u_clippingPlanesMatrix);
-            vec2 intersection = intersectPlane(ray, planeUv);
-            if (intersection.y == +INF_HIT) {
-                minPositiveT = min(minPositiveT, intersection.x);
+            vec4 intersection = intersectPlane(ray, planeUv);
+            if (dot(ray.dir, planeUv.xyz) > 0.0) {
+                firstTransmission = intersection.w <= firstTransmission.w ? intersection : firstTransmission;
             } else {
-                maxNegativeT = max(maxNegativeT, intersection.y);
+                lastReflection = intersection.w >= lastReflection.w ? intersection : lastReflection;
             }
         }
-        setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 0, vec2(-INF_HIT, maxNegativeT));
-        setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 1, vec2(minPositiveT, +INF_HIT));
+        clippingVolume.entry = backSide;
+        clippingVolume.exit = lastReflection;
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 0, clippingVolume);
+        clippingVolume.entry = firstTransmission;
+        clippingVolume.exit = farSide;
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 1, clippingVolume);
     #else // intersection
-        float maxPositiveT = -INF_HIT;
-        float minNegativeT = +INF_HIT;
+        vec4 lastTransmission = vec4(ray.dir, -INF_HIT);
+        vec4 firstReflection = vec4(-ray.dir, +INF_HIT);
         for (int i = 0; i < CLIPPING_PLANES_COUNT; i++) {
             vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i, u_clippingPlanesMatrix);
-            vec2 intersection = intersectPlane(ray, planeUv);
-            if (intersection.y == +INF_HIT) {
-                maxPositiveT = max(maxPositiveT, intersection.x);
+            vec4 intersection = intersectPlane(ray, planeUv);
+            if (dot(ray.dir, planeUv.xyz) > 0.0) {
+                lastTransmission = intersection.w > lastTransmission.w ? intersection : lastTransmission;
             } else {
-                minNegativeT = min(minNegativeT, intersection.y);
+                firstReflection = intersection.w < firstReflection.w ? intersection: firstReflection;
             }
         }
-        if (maxPositiveT < minNegativeT) {
-            setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, vec2(maxPositiveT, minNegativeT));
+        if (lastTransmission.w < firstReflection.w) {
+            clippingVolume.entry = lastTransmission;
+            clippingVolume.exit = firstReflection;
         } else {
-            setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, vec2(NO_HIT));
+            clippingVolume.entry = vec4(-ray.dir, NO_HIT);
+            clippingVolume.exit = vec4(ray.dir, NO_HIT);
         }
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX, clippingVolume);
     #endif
 }

package/Source/Shaders/Voxels/IntersectClippingPlanes.js

@@ -12,61 +12,69 @@ uniform sampler2D u_clippingPlanesTexture;\n\
 uniform mat4 u_clippingPlanesMatrix;\n\
 \n\
 // Plane is in Hessian Normal Form\n\
-vec2 intersectPlane(Ray ray, vec4 plane) {\n\
-    vec3 o = ray.pos;\n\
-    vec3 d = ray.dir;\n\
+vec4 intersectPlane(in Ray ray, in vec4 plane) {\n\
     vec3 n = plane.xyz; // normal\n\
     float w = plane.w; // -dot(pointOnPlane, normal)\n\
 \n\
-    float a = dot(o, n);\n\
-    float b = dot(d, n);\n\
+    float a = dot(ray.pos, n);\n\
+    float b = dot(ray.dir, n);\n\
     float t = -(w + a) / b;\n\
 \n\
-    if (dot(d, n) > 0.0) {\n\
-        return vec2(t, +INF_HIT);\n\
-    } else {\n\
-        return vec2(-INF_HIT, t);\n\
-    }\n\
+    return vec4(n, t);\n\
 }\n\
 \n\
-void intersectClippingPlanes(Ray ray, inout Intersections ix) {\n\
+void intersectClippingPlanes(in Ray ray, inout Intersections ix) {\n\
+    vec4 backSide = vec4(-ray.dir, -INF_HIT);\n\
+    vec4 farSide = vec4(ray.dir, +INF_HIT);\n\
+    RayShapeIntersection clippingVolume;\n\
+\n\
     #if (CLIPPING_PLANES_COUNT == 1)\n\
         // Union and intersection are the same when there's one clipping plane, and the code\n\
         // is more simplified.\n\
         vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, 0, u_clippingPlanesMatrix);\n\
-        vec2 intersection = intersectPlane(ray, planeUv);\n\
-        setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, intersection);\n\
+        vec4 intersection = intersectPlane(ray, planeUv);\n\
+        bool reflects = dot(ray.dir, intersection.xyz) < 0.0;\n\
+        clippingVolume.entry = reflects ? backSide : intersection;\n\
+        clippingVolume.exit = reflects ? intersection : farSide;\n\
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX, clippingVolume);\n\
     #elif defined(CLIPPING_PLANES_UNION)\n\
-        float minPositiveT = +INF_HIT;\n\
-        float maxNegativeT = -INF_HIT;\n\
+        vec4 firstTransmission = vec4(ray.dir, +INF_HIT);\n\
+        vec4 lastReflection = vec4(-ray.dir, -INF_HIT);\n\
         for (int i = 0; i < CLIPPING_PLANES_COUNT; i++) {\n\
             vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i, u_clippingPlanesMatrix);\n\
-            vec2 intersection = intersectPlane(ray, planeUv);\n\
-            if (intersection.y == +INF_HIT) {\n\
-                minPositiveT = min(minPositiveT, intersection.x);\n\
+            vec4 intersection = intersectPlane(ray, planeUv);\n\
+            if (dot(ray.dir, planeUv.xyz) > 0.0) {\n\
+                firstTransmission = intersection.w <= firstTransmission.w ? intersection : firstTransmission;\n\
             } else {\n\
-                maxNegativeT = max(maxNegativeT, intersection.y);\n\
+                lastReflection = intersection.w >= lastReflection.w ? intersection : lastReflection;\n\
             }\n\
         }\n\
-        setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 0, vec2(-INF_HIT, maxNegativeT));\n\
-        setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 1, vec2(minPositiveT, +INF_HIT));\n\
+        clippingVolume.entry = backSide;\n\
+        clippingVolume.exit = lastReflection;\n\
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 0, clippingVolume);\n\
+        clippingVolume.entry = firstTransmission;\n\
+        clippingVolume.exit = farSide;\n\
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 1, clippingVolume);\n\
     #else // intersection\n\
-        float maxPositiveT = -INF_HIT;\n\
-        float minNegativeT = +INF_HIT;\n\
+        vec4 lastTransmission = vec4(ray.dir, -INF_HIT);\n\
+        vec4 firstReflection = vec4(-ray.dir, +INF_HIT);\n\
         for (int i = 0; i < CLIPPING_PLANES_COUNT; i++) {\n\
             vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i, u_clippingPlanesMatrix);\n\
-            vec2 intersection = intersectPlane(ray, planeUv);\n\
-            if (intersection.y == +INF_HIT) {\n\
-                maxPositiveT = max(maxPositiveT, intersection.x);\n\
+            vec4 intersection = intersectPlane(ray, planeUv);\n\
+            if (dot(ray.dir, planeUv.xyz) > 0.0) {\n\
+                lastTransmission = intersection.w > lastTransmission.w ? intersection : lastTransmission;\n\
             } else {\n\
-                minNegativeT = min(minNegativeT, intersection.y);\n\
+                firstReflection = intersection.w < firstReflection.w ? intersection: firstReflection;\n\
             }\n\
         }\n\
-        if (maxPositiveT < minNegativeT) {\n\
-            setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, vec2(maxPositiveT, minNegativeT));\n\
+        if (lastTransmission.w < firstReflection.w) {\n\
+            clippingVolume.entry = lastTransmission;\n\
+            clippingVolume.exit = firstReflection;\n\
         } else {\n\
-            setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, vec2(NO_HIT));\n\
+            clippingVolume.entry = vec4(-ray.dir, NO_HIT);\n\
+            clippingVolume.exit = vec4(ray.dir, NO_HIT);\n\
         }\n\
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX, clippingVolume);\n\
     #endif\n\
 }\n\
 ";

package/Source/Shaders/Voxels/IntersectDepth.glsl

@@ -7,7 +7,7 @@
 
 uniform mat4 u_transformPositionViewToUv;
 
-void intersectDepth(vec2 screenCoord, Ray ray, inout Intersections ix) {
+void intersectDepth(in vec2 screenCoord, in Ray ray, inout Intersections ix) {
     float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, screenCoord));
     if (logDepthOrDepth != 0.0) {
         // Calculate how far the ray must travel before it hits the depth buffer.

package/Source/Shaders/Voxels/IntersectDepth.js

@@ -8,7 +8,7 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, Inters
 \n\
 uniform mat4 u_transformPositionViewToUv;\n\
 \n\
-void intersectDepth(vec2 screenCoord, Ray ray, inout Intersections ix) {\n\
+void intersectDepth(in vec2 screenCoord, in Ray ray, inout Intersections ix) {\n\
     float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, screenCoord));\n\
     if (logDepthOrDepth != 0.0) {\n\
         // Calculate how far the ray must travel before it hits the depth buffer.\n\

package/Source/Shaders/Voxels/Intersection.glsl

@@ -5,23 +5,21 @@
 // Scene/VoxelRenderResources.js.
 // See also IntersectClippingPlane.glsl and IntersectDepth.glsl.
 // See IntersectionUtils.glsl for the definitions of Ray, NO_HIT,
-// getIntersectionPair, initializeIntersections, nextIntersection.
+// getFirstIntersection, initializeIntersections, nextIntersection.
 
 /* Intersection defines (set in Scene/VoxelRenderResources.js)
 #define INTERSECTION_COUNT ###
 */
 
-vec2 intersectScene(vec2 screenCoord, vec3 positionUv, vec3 directionUv, out Intersections ix) {
-    Ray ray = Ray(positionUv, directionUv);
-
+RayShapeIntersection intersectScene(in vec2 screenCoord, in Ray ray, out Intersections ix) {
     // Do a ray-shape intersection to find the exact starting and ending points.
     intersectShape(ray, ix);
 
     // Exit early if the positive shape was completely missed or behind the ray.
-    vec2 entryExitT = getIntersectionPair(ix, 0);
-    if (entryExitT.x == NO_HIT) {
+    RayShapeIntersection intersection = getFirstIntersection(ix);
+    if (intersection.entry.w == NO_HIT) {
         // Positive shape was completely missed - so exit early.
-        return vec2(NO_HIT);
+        return intersection;
     }
 
     // Clipping planes
@@ -38,17 +36,17 @@ vec2 intersectScene(vec2 screenCoord, vec3 positionUv, vec3 directionUv, out Int
     #if (INTERSECTION_COUNT > 1)
         initializeIntersections(ix);
         for (int i = 0; i < INTERSECTION_COUNT; ++i) {
-            entryExitT = nextIntersection(ix);
-            if (entryExitT.y > 0.0) {
+            intersection = nextIntersection(ix);
+            if (intersection.exit.w > 0.0) {
                 // Set start to 0.0 when ray is inside the shape.
-                entryExitT.x = max(entryExitT.x, 0.0);
+                intersection.entry.w = max(intersection.entry.w, 0.0);
                 break;
             }
         }
     #else
         // Set start to 0.0 when ray is inside the shape.
-        entryExitT.x = max(entryExitT.x, 0.0);
+        intersection.entry.w = max(intersection.entry.w, 0.0);
     #endif
 
-    return entryExitT;
+    return intersection;
 }

package/Source/Shaders/Voxels/Intersection.js

@@ -6,23 +6,21 @@ export default "// Main intersection function for Voxel scenes.\n\
 // Scene/VoxelRenderResources.js.\n\
 // See also IntersectClippingPlane.glsl and IntersectDepth.glsl.\n\
 // See IntersectionUtils.glsl for the definitions of Ray, NO_HIT,\n\
-// getIntersectionPair, initializeIntersections, nextIntersection.\n\
+// getFirstIntersection, initializeIntersections, nextIntersection.\n\
 \n\
 /* Intersection defines (set in Scene/VoxelRenderResources.js)\n\
 #define INTERSECTION_COUNT ###\n\
 */\n\
 \n\
-vec2 intersectScene(vec2 screenCoord, vec3 positionUv, vec3 directionUv, out Intersections ix) {\n\
-    Ray ray = Ray(positionUv, directionUv);\n\
-\n\
+RayShapeIntersection intersectScene(in vec2 screenCoord, in Ray ray, out Intersections ix) {\n\
     // Do a ray-shape intersection to find the exact starting and ending points.\n\
     intersectShape(ray, ix);\n\
 \n\
     // Exit early if the positive shape was completely missed or behind the ray.\n\
-    vec2 entryExitT = getIntersectionPair(ix, 0);\n\
-    if (entryExitT.x == NO_HIT) {\n\
+    RayShapeIntersection intersection = getFirstIntersection(ix);\n\
+    if (intersection.entry.w == NO_HIT) {\n\
         // Positive shape was completely missed - so exit early.\n\
-        return vec2(NO_HIT);\n\
+        return intersection;\n\
     }\n\
 \n\
     // Clipping planes\n\
@@ -39,18 +37,18 @@ vec2 intersectScene(vec2 screenCoord, vec3 positionUv, vec3 directionUv, out Int
     #if (INTERSECTION_COUNT > 1)\n\
         initializeIntersections(ix);\n\
         for (int i = 0; i < INTERSECTION_COUNT; ++i) {\n\
-            entryExitT = nextIntersection(ix);\n\
-            if (entryExitT.y > 0.0) {\n\
+            intersection = nextIntersection(ix);\n\
+            if (intersection.exit.w > 0.0) {\n\
                 // Set start to 0.0 when ray is inside the shape.\n\
-                entryExitT.x = max(entryExitT.x, 0.0);\n\
+                intersection.entry.w = max(intersection.entry.w, 0.0);\n\
                 break;\n\
             }\n\
         }\n\
     #else\n\
         // Set start to 0.0 when ray is inside the shape.\n\
-        entryExitT.x = max(entryExitT.x, 0.0);\n\
+        intersection.entry.w = max(intersection.entry.w, 0.0);\n\
     #endif\n\
 \n\
-    return entryExitT;\n\
+    return intersection;\n\
 }\n\
 ";