@cesium/engine 1.1.0 → 2.1.0

package/Source/Shaders/Voxels/IntersectDepth.glsl

@@ -7,8 +7,8 @@
 
 uniform mat4 u_transformPositionViewToUv;
 
-void intersectDepth(vec2 screenCoord, Ray ray, inout Intersections ix) {
-    float logDepthOrDepth = czm_unpackDepth(texture2D(czm_globeDepthTexture, screenCoord));
+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.
         vec4 eyeCoordinateDepth = czm_screenToEyeCoordinates(screenCoord, logDepthOrDepth);

package/Source/Shaders/Voxels/IntersectDepth.js

@@ -8,8 +8,8 @@ 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\
-    float logDepthOrDepth = czm_unpackDepth(texture2D(czm_globeDepthTexture, screenCoord));\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\
         vec4 eyeCoordinateDepth = czm_screenToEyeCoordinates(screenCoord, logDepthOrDepth);\n\

package/Source/Shaders/Voxels/IntersectEllipsoid.glsl

@@ -14,6 +14,7 @@
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_EQUAL_HALF
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_OVER_HALF
+#define ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX
 #define ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN
 #define ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_FLAT
 #define ELLIPSOID_INTERSECTION_INDEX_LONGITUDE
@@ -29,6 +30,9 @@
 #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_OVER_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_UNDER_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_OVER_HALF)
     uniform vec2 u_ellipsoidRenderLatitudeCosSqrHalfMinMax;
 #endif
+#if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX)
+    uniform float u_ellipsoidInverseOuterScaleUv;
+#endif
 #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN)
     uniform float u_ellipsoidInverseInnerScaleUv;
 #endif
@@ -230,8 +234,14 @@ void intersectShape(in Ray ray, inout Intersections ix) {
     ray.pos = ray.pos * 2.0 - 1.0;
     ray.dir *= 2.0;
 
+    #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX)
+        Ray outerRay = Ray(ray.pos * u_ellipsoidInverseOuterScaleUv, ray.dir * u_ellipsoidInverseOuterScaleUv);
+    #else
+        Ray outerRay = ray;
+    #endif
+
     // Outer ellipsoid
-    vec2 outerIntersect = intersectUnitSphereUnnormalizedDirection(ray);
+    vec2 outerIntersect = intersectUnitSphereUnnormalizedDirection(outerRay);
     setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MAX, outerIntersect);
 
     // Exit early if the outer ellipsoid was missed.
@@ -287,7 +297,7 @@ void intersectShape(in Ray ray, inout Intersections ix) {
 
     // Flip the ray because the intersection function expects a cone growing towards +Z.
     #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_EQUAL_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_UNDER_HALF)
-        Ray flippedRay = ray;
+        Ray flippedRay = outerRay;
         flippedRay.dir.z *= -1.0;
         flippedRay.pos.z *= -1.0;
     #endif

package/Source/Shaders/Voxels/IntersectEllipsoid.js

@@ -15,6 +15,7 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, Inters
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_EQUAL_HALF\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_OVER_HALF\n\
+#define ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN\n\
 #define ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_FLAT\n\
 #define ELLIPSOID_INTERSECTION_INDEX_LONGITUDE\n\
@@ -30,6 +31,9 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, Inters
 #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_OVER_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_UNDER_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_OVER_HALF)\n\
     uniform vec2 u_ellipsoidRenderLatitudeCosSqrHalfMinMax;\n\
 #endif\n\
+#if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX)\n\
+    uniform float u_ellipsoidInverseOuterScaleUv;\n\
+#endif\n\
 #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN)\n\
     uniform float u_ellipsoidInverseInnerScaleUv;\n\
 #endif\n\
@@ -230,9 +234,15 @@ void intersectShape(in Ray ray, inout Intersections ix) {\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\
+    #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX)\n\
+        Ray outerRay = Ray(ray.pos * u_ellipsoidInverseOuterScaleUv, ray.dir * u_ellipsoidInverseOuterScaleUv);\n\
+    #else\n\
+        Ray outerRay = ray;\n\
+    #endif\n\
 \n\
     // Outer ellipsoid\n\
-    vec2 outerIntersect = intersectUnitSphereUnnormalizedDirection(ray);\n\
+    vec2 outerIntersect = intersectUnitSphereUnnormalizedDirection(outerRay);\n\
     setIntersectionPair(ix, ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MAX, outerIntersect);\n\
 \n\
     // Exit early if the outer ellipsoid was missed.\n\
@@ -288,7 +298,7 @@ void intersectShape(in Ray ray, inout Intersections ix) {\n\
 \n\
     // Flip the ray because the intersection function expects a cone growing towards +Z.\n\
     #if defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_EQUAL_HALF) || defined(ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_UNDER_HALF)\n\
-        Ray flippedRay = ray;\n\
+        Ray flippedRay = outerRay;\n\
         flippedRay.dir.z *= -1.0;\n\
         flippedRay.pos.z *= -1.0;\n\
     #endif\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\
 ";

package/Source/Shaders/Voxels/Megatexture.glsl

@@ -83,7 +83,7 @@ Properties getPropertiesFromMegatexture(in SampleData sampleData) {
 
     #if defined(NEAREST_SAMPLING)
         // Round to the center of the nearest voxel
-        voxelCoord = floor(voxelCoord + vec3(0.5));
+        voxelCoord = floor(voxelCoord) + vec3(0.5);
     #endif
 
     // Tile location

package/Source/Shaders/Voxels/Megatexture.js

@@ -84,7 +84,7 @@ Properties getPropertiesFromMegatexture(in SampleData sampleData) {\n\
 \n\
     #if defined(NEAREST_SAMPLING)\n\
         // Round to the center of the nearest voxel\n\
-        voxelCoord = floor(voxelCoord + vec3(0.5));\n\
+        voxelCoord = floor(voxelCoord) + vec3(0.5);\n\
     #endif\n\
 \n\
     // Tile location\n\