@cesium/engine 2.0.0 → 2.1.0

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

package/Source/Shaders/Voxels/IntersectionUtils.glsl

@@ -4,59 +4,61 @@
 
 #define NO_HIT (-czm_infinity)
 #define INF_HIT (czm_infinity * 0.5)
+#define RAY_SHIFT (0.000003163)
+#define RAY_SCALE (1.003163)
 
 struct Ray {
     vec3 pos;
     vec3 dir;
+#if defined(SHAPE_BOX)
+    vec3 dInv;
+#endif
+};
+
+struct RayShapeIntersection {
+    vec4 entry;
+    vec4 exit;
 };
 
 struct Intersections {
     // Don't access these member variables directly - call the functions instead.
 
-    #if (INTERSECTION_COUNT > 1)
-        // Store an array of intersections. Each intersection is composed of:
-        //  x for the T value
-        //  y for the shape type - which encodes positive vs negative and entering vs exiting
-        // For example:
-        //  y = 0: positive shape entry
-        //  y = 1: positive shape exit
-        //  y = 2: negative shape entry
-        //  y = 3: negative shape exit
-        vec2 intersections[INTERSECTION_COUNT * 2];
+    // Store an array of ray-surface intersections. Each intersection is composed of:
+    //  .xyz for the surface normal at the intersection point
+    //  .w for the T value
+    // The scale of the normal encodes the shape intersection type:
+    //  length(intersection.xyz) = 1: positive shape entry
+    //  length(intersection.xyz) = 2: positive shape exit
+    //  length(intersection.xyz) = 3: negative shape entry
+    //  length(intersection.xyz) = 4: negative shape exit
+    // INTERSECTION_COUNT is the number of ray-*shape* (volume) intersections,
+    // so we need twice as many to track ray-*surface* intersections
+    vec4 intersections[INTERSECTION_COUNT * 2];
 
+    #if (INTERSECTION_COUNT > 1)
         // Maintain state for future nextIntersection calls
         int index;
         int surroundCount;
         bool surroundIsPositive;
-    #else
-        // When there's only one positive shape intersection none of the extra stuff is needed.
-        float intersections[2];
     #endif
 };
 
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.
-#if (INTERSECTION_COUNT > 1)
-    #define getIntersection(/*inout Intersections*/ ix, /*int*/ index) (ix).intersections[(index)].x
-#else
-    #define getIntersection(/*inout Intersections*/ ix, /*int*/ index) (ix).intersections[(index)]
-#endif
-
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.
-#define getIntersectionPair(/*inout Intersections*/ ix, /*int*/ index) vec2(getIntersection((ix), (index) * 2 + 0), getIntersection((ix), (index) * 2 + 1))
+RayShapeIntersection getFirstIntersection(in Intersections ix) 
+{
+    return RayShapeIntersection(ix.intersections[0], ix.intersections[1]);
+}
 
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.
-#if (INTERSECTION_COUNT > 1)
-    #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*enter*/ enter) (ix).intersections[(index)] = vec2((t), float(!positive) * 2.0 + float(!enter))
-#else
-    #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*enter*/ enter) (ix).intersections[(index)] = (t)
-#endif
+vec4 encodeIntersectionType(vec4 intersection, int index, bool entry)
+{
+    float scale = float(index > 0) * 2.0 + float(!entry) + 1.0;
+    return vec4(intersection.xyz * scale, intersection.w);
+}
 
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.
-#if (INTERSECTION_COUNT > 1)
-    #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec2((entryExit).x, float((index) > 0) * 2.0 + 0.0); (ix).intersections[(index) * 2 + 1] = vec2((entryExit).y, float((index) > 0) * 2.0 + 1.0)
-#else
-    #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = (entryExit).x; (ix).intersections[(index) * 2 + 1] = (entryExit).y
-#endif
+// Use defines instead of real functions because WebGL1 cannot access array with non-constant index.
+#define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*bool*/ enter) (ix).intersections[(index)] = vec4(0.0, float(!positive) * 2.0 + float(!enter) + 1.0, 0.0, (t))
+#define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec4(0.0, float((index) > 0) * 2.0 + 1.0, 0.0, (entryExit).x); (ix).intersections[(index) * 2 + 1] = vec4(0.0, float((index) > 0) * 2.0 + 2.0, 0.0, (entryExit).y)
+#define setSurfaceIntersection(/*inout Intersections*/ ix, /*int*/ index, /*vec4*/ intersection) (ix).intersections[(index)] = intersection;
+#define setShapeIntersection(/*inout Intersections*/ ix, /*int*/ index, /*RayShapeIntersection*/ intersection) (ix).intersections[(index) * 2 + 0] = encodeIntersectionType((intersection).entry, (index), true); (ix).intersections[(index) * 2 + 1] = encodeIntersectionType((intersection).exit, (index), false)
 
 #if (INTERSECTION_COUNT > 1)
 void initializeIntersections(inout Intersections ix) {
@@ -70,21 +72,13 @@ void initializeIntersections(inout Intersections ix) {
             // loop with non-constant condition, so it has to break early instead
             if (i >= n) { break; }
 
-            vec2 intersect0 = ix.intersections[i + 0];
-            vec2 intersect1 = ix.intersections[i + 1];
-
-            float t0 = intersect0.x;
-            float t1 = intersect1.x;
-            float b0 = intersect0.y;
-            float b1 = intersect1.y;
+            vec4 intersect0 = ix.intersections[i + 0];
+            vec4 intersect1 = ix.intersections[i + 1];
 
-            float tmin = min(t0, t1);
-            float tmax = max(t0, t1);
-            float bmin = tmin == t0 ? b0 : b1;
-            float bmax = tmin == t0 ? b1 : b0;
+            bool inOrder = intersect0.w <= intersect1.w;
 
-            ix.intersections[i + 0] = vec2(tmin, bmin);
-            ix.intersections[i + 1] = vec2(tmax, bmax);
+            ix.intersections[i + 0] = inOrder ? intersect0 : intersect1;
+            ix.intersections[i + 1] = inOrder ? intersect1 : intersect0;
         }
     }
 
@@ -96,13 +90,14 @@ void initializeIntersections(inout Intersections ix) {
 #endif
 
 #if (INTERSECTION_COUNT > 1)
-vec2 nextIntersection(inout Intersections ix) {
-    vec2 entryExitT = vec2(NO_HIT);
+RayShapeIntersection nextIntersection(inout Intersections ix) {
+    vec4 surfaceIntersection = vec4(0.0, 0.0, 0.0, NO_HIT);
+    RayShapeIntersection shapeIntersection = RayShapeIntersection(surfaceIntersection, surfaceIntersection);
 
     const int passCount = INTERSECTION_COUNT * 2;
 
     if (ix.index == passCount) {
-        return entryExitT;
+        return shapeIntersection;
     }
 
     for (int i = 0; i < passCount; ++i) {
@@ -114,25 +109,24 @@ vec2 nextIntersection(inout Intersections ix) {
 
         ix.index = i + 1;
 
-        vec2 intersect = ix.intersections[i];
-        float t = intersect.x;
-        bool currShapeIsPositive = intersect.y < 2.0;
-        bool enter = mod(intersect.y, 2.0) == 0.0;
+        surfaceIntersection = ix.intersections[i];
+        int intersectionType = int(length(surfaceIntersection.xyz) - 0.5);
+        bool currShapeIsPositive = intersectionType < 2;
+        bool enter = intMod(intersectionType, 2) == 0;
 
         ix.surroundCount += enter ? +1 : -1;
         ix.surroundIsPositive = currShapeIsPositive ? enter : ix.surroundIsPositive;
 
         // entering positive or exiting negative
         if (ix.surroundCount == 1 && ix.surroundIsPositive && enter == currShapeIsPositive) {
-            entryExitT.x = t;
+            shapeIntersection.entry = surfaceIntersection;
         }
 
         // exiting positive or entering negative after being inside positive
-        // TODO: Can this be simplified?
         bool exitPositive = !enter && currShapeIsPositive && ix.surroundCount == 0;
         bool enterNegativeFromPositive = enter && !currShapeIsPositive && ix.surroundCount == 2 && ix.surroundIsPositive;
         if (exitPositive || enterNegativeFromPositive) {
-            entryExitT.y = t;
+            shapeIntersection.exit = surfaceIntersection;
 
             // entry and exit have been found, so the loop can stop
             if (exitPositive) {
@@ -143,9 +137,8 @@ vec2 nextIntersection(inout Intersections ix) {
         }
     }
 
-    return entryExitT;
+    return shapeIntersection;
 }
 #endif
 
 // NOTE: initializeIntersections, nextIntersection aren't even declared unless INTERSECTION_COUNT > 1
-// export { NO_HIT, INF_HIT, Ray, Intersections, getIntersectionPair, setIntersectionPair, initializeIntersections, nextIntersection };

package/Source/Shaders/Voxels/IntersectionUtils.js

@@ -5,59 +5,61 @@ export default "/* Intersection defines\n\
 \n\
 #define NO_HIT (-czm_infinity)\n\
 #define INF_HIT (czm_infinity * 0.5)\n\
+#define RAY_SHIFT (0.000003163)\n\
+#define RAY_SCALE (1.003163)\n\
 \n\
 struct Ray {\n\
     vec3 pos;\n\
     vec3 dir;\n\
+#if defined(SHAPE_BOX)\n\
+    vec3 dInv;\n\
+#endif\n\
+};\n\
+\n\
+struct RayShapeIntersection {\n\
+    vec4 entry;\n\
+    vec4 exit;\n\
 };\n\
 \n\
 struct Intersections {\n\
     // Don't access these member variables directly - call the functions instead.\n\
 \n\
-    #if (INTERSECTION_COUNT > 1)\n\
-        // Store an array of intersections. Each intersection is composed of:\n\
-        //  x for the T value\n\
-        //  y for the shape type - which encodes positive vs negative and entering vs exiting\n\
-        // For example:\n\
-        //  y = 0: positive shape entry\n\
-        //  y = 1: positive shape exit\n\
-        //  y = 2: negative shape entry\n\
-        //  y = 3: negative shape exit\n\
-        vec2 intersections[INTERSECTION_COUNT * 2];\n\
+    // Store an array of ray-surface intersections. Each intersection is composed of:\n\
+    //  .xyz for the surface normal at the intersection point\n\
+    //  .w for the T value\n\
+    // The scale of the normal encodes the shape intersection type:\n\
+    //  length(intersection.xyz) = 1: positive shape entry\n\
+    //  length(intersection.xyz) = 2: positive shape exit\n\
+    //  length(intersection.xyz) = 3: negative shape entry\n\
+    //  length(intersection.xyz) = 4: negative shape exit\n\
+    // INTERSECTION_COUNT is the number of ray-*shape* (volume) intersections,\n\
+    // so we need twice as many to track ray-*surface* intersections\n\
+    vec4 intersections[INTERSECTION_COUNT * 2];\n\
 \n\
+    #if (INTERSECTION_COUNT > 1)\n\
         // Maintain state for future nextIntersection calls\n\
         int index;\n\
         int surroundCount;\n\
         bool surroundIsPositive;\n\
-    #else\n\
-        // When there's only one positive shape intersection none of the extra stuff is needed.\n\
-        float intersections[2];\n\
     #endif\n\
 };\n\
 \n\
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.\n\
-#if (INTERSECTION_COUNT > 1)\n\
-    #define getIntersection(/*inout Intersections*/ ix, /*int*/ index) (ix).intersections[(index)].x\n\
-#else\n\
-    #define getIntersection(/*inout Intersections*/ ix, /*int*/ index) (ix).intersections[(index)]\n\
-#endif\n\
-\n\
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.\n\
-#define getIntersectionPair(/*inout Intersections*/ ix, /*int*/ index) vec2(getIntersection((ix), (index) * 2 + 0), getIntersection((ix), (index) * 2 + 1))\n\
+RayShapeIntersection getFirstIntersection(in Intersections ix) \n\
+{\n\
+    return RayShapeIntersection(ix.intersections[0], ix.intersections[1]);\n\
+}\n\
 \n\
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.\n\
-#if (INTERSECTION_COUNT > 1)\n\
-    #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*enter*/ enter) (ix).intersections[(index)] = vec2((t), float(!positive) * 2.0 + float(!enter))\n\
-#else\n\
-    #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*enter*/ enter) (ix).intersections[(index)] = (t)\n\
-#endif\n\
+vec4 encodeIntersectionType(vec4 intersection, int index, bool entry)\n\
+{\n\
+    float scale = float(index > 0) * 2.0 + float(!entry) + 1.0;\n\
+    return vec4(intersection.xyz * scale, intersection.w);\n\
+}\n\
 \n\
-// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.\n\
-#if (INTERSECTION_COUNT > 1)\n\
-    #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec2((entryExit).x, float((index) > 0) * 2.0 + 0.0); (ix).intersections[(index) * 2 + 1] = vec2((entryExit).y, float((index) > 0) * 2.0 + 1.0)\n\
-#else\n\
-    #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = (entryExit).x; (ix).intersections[(index) * 2 + 1] = (entryExit).y\n\
-#endif\n\
+// Use defines instead of real functions because WebGL1 cannot access array with non-constant index.\n\
+#define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*bool*/ enter) (ix).intersections[(index)] = vec4(0.0, float(!positive) * 2.0 + float(!enter) + 1.0, 0.0, (t))\n\
+#define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec4(0.0, float((index) > 0) * 2.0 + 1.0, 0.0, (entryExit).x); (ix).intersections[(index) * 2 + 1] = vec4(0.0, float((index) > 0) * 2.0 + 2.0, 0.0, (entryExit).y)\n\
+#define setSurfaceIntersection(/*inout Intersections*/ ix, /*int*/ index, /*vec4*/ intersection) (ix).intersections[(index)] = intersection;\n\
+#define setShapeIntersection(/*inout Intersections*/ ix, /*int*/ index, /*RayShapeIntersection*/ intersection) (ix).intersections[(index) * 2 + 0] = encodeIntersectionType((intersection).entry, (index), true); (ix).intersections[(index) * 2 + 1] = encodeIntersectionType((intersection).exit, (index), false)\n\
 \n\
 #if (INTERSECTION_COUNT > 1)\n\
 void initializeIntersections(inout Intersections ix) {\n\
@@ -71,21 +73,13 @@ void initializeIntersections(inout Intersections ix) {\n\
             // loop with non-constant condition, so it has to break early instead\n\
             if (i >= n) { break; }\n\
 \n\
-            vec2 intersect0 = ix.intersections[i + 0];\n\
-            vec2 intersect1 = ix.intersections[i + 1];\n\
-\n\
-            float t0 = intersect0.x;\n\
-            float t1 = intersect1.x;\n\
-            float b0 = intersect0.y;\n\
-            float b1 = intersect1.y;\n\
+            vec4 intersect0 = ix.intersections[i + 0];\n\
+            vec4 intersect1 = ix.intersections[i + 1];\n\
 \n\
-            float tmin = min(t0, t1);\n\
-            float tmax = max(t0, t1);\n\
-            float bmin = tmin == t0 ? b0 : b1;\n\
-            float bmax = tmin == t0 ? b1 : b0;\n\
+            bool inOrder = intersect0.w <= intersect1.w;\n\
 \n\
-            ix.intersections[i + 0] = vec2(tmin, bmin);\n\
-            ix.intersections[i + 1] = vec2(tmax, bmax);\n\
+            ix.intersections[i + 0] = inOrder ? intersect0 : intersect1;\n\
+            ix.intersections[i + 1] = inOrder ? intersect1 : intersect0;\n\
         }\n\
     }\n\
 \n\
@@ -97,13 +91,14 @@ void initializeIntersections(inout Intersections ix) {\n\
 #endif\n\
 \n\
 #if (INTERSECTION_COUNT > 1)\n\
-vec2 nextIntersection(inout Intersections ix) {\n\
-    vec2 entryExitT = vec2(NO_HIT);\n\
+RayShapeIntersection nextIntersection(inout Intersections ix) {\n\
+    vec4 surfaceIntersection = vec4(0.0, 0.0, 0.0, NO_HIT);\n\
+    RayShapeIntersection shapeIntersection = RayShapeIntersection(surfaceIntersection, surfaceIntersection);\n\
 \n\
     const int passCount = INTERSECTION_COUNT * 2;\n\
 \n\
     if (ix.index == passCount) {\n\
-        return entryExitT;\n\
+        return shapeIntersection;\n\
     }\n\
 \n\
     for (int i = 0; i < passCount; ++i) {\n\
@@ -115,25 +110,24 @@ vec2 nextIntersection(inout Intersections ix) {\n\
 \n\
         ix.index = i + 1;\n\
 \n\
-        vec2 intersect = ix.intersections[i];\n\
-        float t = intersect.x;\n\
-        bool currShapeIsPositive = intersect.y < 2.0;\n\
-        bool enter = mod(intersect.y, 2.0) == 0.0;\n\
+        surfaceIntersection = ix.intersections[i];\n\
+        int intersectionType = int(length(surfaceIntersection.xyz) - 0.5);\n\
+        bool currShapeIsPositive = intersectionType < 2;\n\
+        bool enter = intMod(intersectionType, 2) == 0;\n\
 \n\
         ix.surroundCount += enter ? +1 : -1;\n\
         ix.surroundIsPositive = currShapeIsPositive ? enter : ix.surroundIsPositive;\n\
 \n\
         // entering positive or exiting negative\n\
         if (ix.surroundCount == 1 && ix.surroundIsPositive && enter == currShapeIsPositive) {\n\
-            entryExitT.x = t;\n\
+            shapeIntersection.entry = surfaceIntersection;\n\
         }\n\
 \n\
         // exiting positive or entering negative after being inside positive\n\
-        // TODO: Can this be simplified?\n\
         bool exitPositive = !enter && currShapeIsPositive && ix.surroundCount == 0;\n\
         bool enterNegativeFromPositive = enter && !currShapeIsPositive && ix.surroundCount == 2 && ix.surroundIsPositive;\n\
         if (exitPositive || enterNegativeFromPositive) {\n\
-            entryExitT.y = t;\n\
+            shapeIntersection.exit = surfaceIntersection;\n\
 \n\
             // entry and exit have been found, so the loop can stop\n\
             if (exitPositive) {\n\
@@ -144,10 +138,9 @@ vec2 nextIntersection(inout Intersections ix) {\n\
         }\n\
     }\n\
 \n\
-    return entryExitT;\n\
+    return shapeIntersection;\n\
 }\n\
 #endif\n\
 \n\
 // NOTE: initializeIntersections, nextIntersection aren't even declared unless INTERSECTION_COUNT > 1\n\
-// export { NO_HIT, INF_HIT, Ray, Intersections, getIntersectionPair, setIntersectionPair, initializeIntersections, nextIntersection };\n\
 ";