@cesium/engine 1.1.0 → 2.1.0

package/Source/Shaders/Vector3DTileClampedPolylinesVS.glsl

@@ -1,19 +1,19 @@
-attribute vec3 startEllipsoidNormal;
-attribute vec3 endEllipsoidNormal;
-attribute vec4 startPositionAndHeight;
-attribute vec4 endPositionAndHeight;
-attribute vec4 startFaceNormalAndVertexCorner;
-attribute vec4 endFaceNormalAndHalfWidth;
-attribute float a_batchId;
+in vec3 startEllipsoidNormal;
+in vec3 endEllipsoidNormal;
+in vec4 startPositionAndHeight;
+in vec4 endPositionAndHeight;
+in vec4 startFaceNormalAndVertexCorner;
+in vec4 endFaceNormalAndHalfWidth;
+in float a_batchId;
 
 uniform mat4 u_modifiedModelView;
 uniform vec2 u_minimumMaximumVectorHeights;
 
-varying vec4 v_startPlaneEC;
-varying vec4 v_endPlaneEC;
-varying vec4 v_rightPlaneEC;
-varying float v_halfWidth;
-varying vec3 v_volumeUpEC;
+out vec4 v_startPlaneEC;
+out vec4 v_endPlaneEC;
+out vec4 v_rightPlaneEC;
+out float v_halfWidth;
+out vec3 v_volumeUpEC;
 
 void main()
 {

package/Source/Shaders/Vector3DTileClampedPolylinesVS.js

@@ -1,20 +1,20 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "attribute vec3 startEllipsoidNormal;\n\
-attribute vec3 endEllipsoidNormal;\n\
-attribute vec4 startPositionAndHeight;\n\
-attribute vec4 endPositionAndHeight;\n\
-attribute vec4 startFaceNormalAndVertexCorner;\n\
-attribute vec4 endFaceNormalAndHalfWidth;\n\
-attribute float a_batchId;\n\
+export default "in vec3 startEllipsoidNormal;\n\
+in vec3 endEllipsoidNormal;\n\
+in vec4 startPositionAndHeight;\n\
+in vec4 endPositionAndHeight;\n\
+in vec4 startFaceNormalAndVertexCorner;\n\
+in vec4 endFaceNormalAndHalfWidth;\n\
+in float a_batchId;\n\
 \n\
 uniform mat4 u_modifiedModelView;\n\
 uniform vec2 u_minimumMaximumVectorHeights;\n\
 \n\
-varying vec4 v_startPlaneEC;\n\
-varying vec4 v_endPlaneEC;\n\
-varying vec4 v_rightPlaneEC;\n\
-varying float v_halfWidth;\n\
-varying vec3 v_volumeUpEC;\n\
+out vec4 v_startPlaneEC;\n\
+out vec4 v_endPlaneEC;\n\
+out vec4 v_rightPlaneEC;\n\
+out float v_halfWidth;\n\
+out vec3 v_volumeUpEC;\n\
 \n\
 void main()\n\
 {\n\

package/Source/Shaders/Vector3DTilePolylinesVS.glsl

@@ -1,8 +1,8 @@
-attribute vec4 currentPosition;
-attribute vec4 previousPosition;
-attribute vec4 nextPosition;
-attribute vec2 expandAndWidth;
-attribute float a_batchId;
+in vec4 currentPosition;
+in vec4 previousPosition;
+in vec4 nextPosition;
+in vec2 expandAndWidth;
+in float a_batchId;
 
 uniform mat4 u_modifiedModelView;
 

package/Source/Shaders/Vector3DTilePolylinesVS.js

@@ -1,9 +1,9 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "attribute vec4 currentPosition;\n\
-attribute vec4 previousPosition;\n\
-attribute vec4 nextPosition;\n\
-attribute vec2 expandAndWidth;\n\
-attribute float a_batchId;\n\
+export default "in vec4 currentPosition;\n\
+in vec4 previousPosition;\n\
+in vec4 nextPosition;\n\
+in vec2 expandAndWidth;\n\
+in float a_batchId;\n\
 \n\
 uniform mat4 u_modifiedModelView;\n\
 \n\

package/Source/Shaders/VectorTileVS.glsl

@@ -1,5 +1,5 @@
-attribute vec3 position;
-attribute float a_batchId;
+in vec3 position;
+in float a_batchId;
 
 uniform mat4 u_modifiedModelViewProjection;
 

package/Source/Shaders/VectorTileVS.js

@@ -1,6 +1,6 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "attribute vec3 position;\n\
-attribute float a_batchId;\n\
+export default "in vec3 position;\n\
+in float a_batchId;\n\
 \n\
 uniform mat4 u_modifiedModelViewProjection;\n\
 \n\

package/Source/Shaders/ViewportQuadFS.glsl

@@ -1,5 +1,5 @@
 
-varying vec2 v_textureCoordinates;
+in vec2 v_textureCoordinates;
 
 void main()
 {
@@ -12,5 +12,5 @@ void main()
     
     czm_material material = czm_getMaterial(materialInput);
 
-    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);
+    out_FragColor = vec4(material.diffuse + material.emission, material.alpha);
 }

package/Source/Shaders/ViewportQuadFS.js

@@ -1,6 +1,6 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "\n\
-varying vec2 v_textureCoordinates;\n\
+in vec2 v_textureCoordinates;\n\
 \n\
 void main()\n\
 {\n\
@@ -13,6 +13,6 @@ void main()\n\
     \n\
     czm_material material = czm_getMaterial(materialInput);\n\
 \n\
-    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n\
+    out_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n\
 }\n\
 ";

package/Source/Shaders/ViewportQuadVS.glsl

@@ -1,7 +1,7 @@
-attribute vec4 position;
-attribute vec2 textureCoordinates;
+in vec4 position;
+in vec2 textureCoordinates;
 
-varying vec2 v_textureCoordinates;
+out vec2 v_textureCoordinates;
 
 void main() 
 {

package/Source/Shaders/ViewportQuadVS.js

@@ -1,8 +1,8 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "attribute vec4 position;\n\
-attribute vec2 textureCoordinates;\n\
+export default "in vec4 position;\n\
+in vec2 textureCoordinates;\n\
 \n\
-varying vec2 v_textureCoordinates;\n\
+out vec2 v_textureCoordinates;\n\
 \n\
 void main() \n\
 {\n\

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