@cesium/engine 20.0.1 → 21.0.0

package/Source/Shaders/Voxels/IntersectEllipsoid.glsl

@@ -26,7 +26,7 @@
 #endif
 uniform float u_eccentricitySquared;
 uniform vec2 u_ellipsoidRenderLatitudeSinMinMax;
-uniform vec2 u_clipMinMaxHeight;
+uniform vec2 u_clipMinMaxHeight; // Values are negative: clipHeight - maxShapeHeight
 
 RayShapeIntersection intersectZPlane(in Ray ray, in float z) {
     float t = -ray.pos.z / ray.dir.z;
@@ -44,11 +44,11 @@ RayShapeIntersection intersectZPlane(in Ray ray, in float z) {
     }
 }
 
-RayShapeIntersection intersectHeight(in Ray ray, in float relativeHeight, in bool convex)
+RayShapeIntersection intersectHeight(in Ray ray, in float height, in bool convex)
 {
     // Scale the ray by the ellipsoid axes to make it a unit sphere
     // Note: approximating ellipsoid + height as an ellipsoid
-    vec3 radiiCorrection = u_ellipsoidRadiiUv / (u_ellipsoidRadiiUv + relativeHeight);
+    vec3 radiiCorrection = vec3(1.0) / (u_ellipsoidRadii + height);
     vec3 position = ray.pos * radiiCorrection;
     vec3 direction = ray.dir * radiiCorrection;
 
@@ -74,10 +74,14 @@ RayShapeIntersection intersectHeight(in Ray ray, in float relativeHeight, in boo
     float tmax = max(t1, t2);
 
     float directionScale = convex ? 1.0 : -1.0;
-    vec3 d1 = directionScale * normalize(position + tmin * direction);
-    vec3 d2 = directionScale * normalize(position + tmax * direction);
+    vec3 d1 = directionScale * (position + tmin * direction);
+    vec3 d2 = directionScale * (position + tmax * direction);
 
-    return RayShapeIntersection(vec4(d1, tmin), vec4(d2, tmax));
+    // Return normals in eye coordinates. Use spherical approximation for the normal.
+    vec3 normal1 = normalize(czm_normal * d1);
+    vec3 normal2 = normalize(czm_normal * d2);
+
+    return RayShapeIntersection(vec4(normal1, tmin), vec4(normal2, tmax));
 }
 
 /**
@@ -151,16 +155,13 @@ float getLatitudeConeShift(in float sinLatitude) {
     // Find prime vertical radius of curvature: 
     // the distance along the ellipsoid normal to the intersection with the z-axis
     float x2 = u_eccentricitySquared * sinLatitude * sinLatitude;
-    float primeVerticalRadius = inversesqrt(1.0 - x2);
+    float primeVerticalRadius = u_ellipsoidRadii.x * inversesqrt(1.0 - x2);
 
     // Compute a shift from the origin to the intersection of the cone with the z-axis
     return primeVerticalRadius * u_eccentricitySquared * sinLatitude;
 }
 
 void intersectFlippedCone(in Ray ray, in float cosHalfAngle, out RayShapeIntersection intersections[2]) {
-    // Undo the scaling from ellipsoid to sphere
-    ray.pos = ray.pos * u_ellipsoidRadiiUv;
-    ray.dir = ray.dir * u_ellipsoidRadiiUv;
     // Shift the ray to account for the latitude cone not being centered at the Earth center
     ray.pos.z += getLatitudeConeShift(cosHalfAngle);
 
@@ -206,9 +207,6 @@ void intersectFlippedCone(in Ray ray, in float cosHalfAngle, out RayShapeInterse
 }
 
 RayShapeIntersection intersectRegularCone(in Ray ray, in float cosHalfAngle, in bool convex) {
-    // Undo the scaling from ellipsoid to sphere
-    ray.pos = ray.pos * u_ellipsoidRadiiUv;
-    ray.dir = ray.dir * u_ellipsoidRadiiUv;
     // Shift the ray to account for the latitude cone not being centered at the Earth center
     ray.pos.z += getLatitudeConeShift(cosHalfAngle);
 
@@ -245,13 +243,7 @@ RayShapeIntersection intersectRegularCone(in Ray ray, in float cosHalfAngle, in
     }
 }
 
-void intersectShape(in Ray ray, inout Intersections ix) {
-    // Position is converted from [0,1] to [-1,+1] because shape intersections assume unit space is [-1,+1].
-    // Direction is scaled as well to be in sync with position.
-    ray.pos = ray.pos * 2.0 - 1.0;
-    ray.dir *= 2.0;
-
-    // Outer ellipsoid
+void intersectShape(in Ray ray, in Ray rayEC, inout Intersections ix) {    // Outer ellipsoid
     RayShapeIntersection outerIntersect = intersectHeight(ray, u_clipMinMaxHeight.y, true);
     setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MAX, outerIntersect);
 

package/Source/Shaders/Voxels/IntersectEllipsoid.js

@@ -27,7 +27,7 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT
 #endif\n\
 uniform float u_eccentricitySquared;\n\
 uniform vec2 u_ellipsoidRenderLatitudeSinMinMax;\n\
-uniform vec2 u_clipMinMaxHeight;\n\
+uniform vec2 u_clipMinMaxHeight; // Values are negative: clipHeight - maxShapeHeight\n\
 \n\
 RayShapeIntersection intersectZPlane(in Ray ray, in float z) {\n\
     float t = -ray.pos.z / ray.dir.z;\n\
@@ -45,11 +45,11 @@ RayShapeIntersection intersectZPlane(in Ray ray, in float z) {\n\
     }\n\
 }\n\
 \n\
-RayShapeIntersection intersectHeight(in Ray ray, in float relativeHeight, in bool convex)\n\
+RayShapeIntersection intersectHeight(in Ray ray, in float height, in bool convex)\n\
 {\n\
     // Scale the ray by the ellipsoid axes to make it a unit sphere\n\
     // Note: approximating ellipsoid + height as an ellipsoid\n\
-    vec3 radiiCorrection = u_ellipsoidRadiiUv / (u_ellipsoidRadiiUv + relativeHeight);\n\
+    vec3 radiiCorrection = vec3(1.0) / (u_ellipsoidRadii + height);\n\
     vec3 position = ray.pos * radiiCorrection;\n\
     vec3 direction = ray.dir * radiiCorrection;\n\
 \n\
@@ -75,10 +75,14 @@ RayShapeIntersection intersectHeight(in Ray ray, in float relativeHeight, in boo
     float tmax = max(t1, t2);\n\
 \n\
     float directionScale = convex ? 1.0 : -1.0;\n\
-    vec3 d1 = directionScale * normalize(position + tmin * direction);\n\
-    vec3 d2 = directionScale * normalize(position + tmax * direction);\n\
+    vec3 d1 = directionScale * (position + tmin * direction);\n\
+    vec3 d2 = directionScale * (position + tmax * direction);\n\
 \n\
-    return RayShapeIntersection(vec4(d1, tmin), vec4(d2, tmax));\n\
+    // Return normals in eye coordinates. Use spherical approximation for the normal.\n\
+    vec3 normal1 = normalize(czm_normal * d1);\n\
+    vec3 normal2 = normalize(czm_normal * d2);\n\
+\n\
+    return RayShapeIntersection(vec4(normal1, tmin), vec4(normal2, tmax));\n\
 }\n\
 \n\
 /**\n\
@@ -152,16 +156,13 @@ float getLatitudeConeShift(in float sinLatitude) {\n\
     // Find prime vertical radius of curvature: \n\
     // the distance along the ellipsoid normal to the intersection with the z-axis\n\
     float x2 = u_eccentricitySquared * sinLatitude * sinLatitude;\n\
-    float primeVerticalRadius = inversesqrt(1.0 - x2);\n\
+    float primeVerticalRadius = u_ellipsoidRadii.x * inversesqrt(1.0 - x2);\n\
 \n\
     // Compute a shift from the origin to the intersection of the cone with the z-axis\n\
     return primeVerticalRadius * u_eccentricitySquared * sinLatitude;\n\
 }\n\
 \n\
 void intersectFlippedCone(in Ray ray, in float cosHalfAngle, out RayShapeIntersection intersections[2]) {\n\
-    // Undo the scaling from ellipsoid to sphere\n\
-    ray.pos = ray.pos * u_ellipsoidRadiiUv;\n\
-    ray.dir = ray.dir * u_ellipsoidRadiiUv;\n\
     // Shift the ray to account for the latitude cone not being centered at the Earth center\n\
     ray.pos.z += getLatitudeConeShift(cosHalfAngle);\n\
 \n\
@@ -207,9 +208,6 @@ void intersectFlippedCone(in Ray ray, in float cosHalfAngle, out RayShapeInterse
 }\n\
 \n\
 RayShapeIntersection intersectRegularCone(in Ray ray, in float cosHalfAngle, in bool convex) {\n\
-    // Undo the scaling from ellipsoid to sphere\n\
-    ray.pos = ray.pos * u_ellipsoidRadiiUv;\n\
-    ray.dir = ray.dir * u_ellipsoidRadiiUv;\n\
     // Shift the ray to account for the latitude cone not being centered at the Earth center\n\
     ray.pos.z += getLatitudeConeShift(cosHalfAngle);\n\
 \n\
@@ -246,13 +244,7 @@ RayShapeIntersection intersectRegularCone(in Ray ray, in float cosHalfAngle, in
     }\n\
 }\n\
 \n\
-void intersectShape(in Ray ray, inout Intersections ix) {\n\
-    // Position is converted from [0,1] to [-1,+1] because shape intersections assume unit space is [-1,+1].\n\
-    // Direction is scaled as well to be in sync with position.\n\
-    ray.pos = ray.pos * 2.0 - 1.0;\n\
-    ray.dir *= 2.0;\n\
-\n\
-    // Outer ellipsoid\n\
+void intersectShape(in Ray ray, in Ray rayEC, inout Intersections ix) {    // Outer ellipsoid\n\
     RayShapeIntersection outerIntersect = intersectHeight(ray, u_clipMinMaxHeight.y, true);\n\
     setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MAX, outerIntersect);\n\
 \n\

package/Source/Shaders/Voxels/IntersectLongitude.glsl

@@ -1,6 +1,14 @@
 // See IntersectionUtils.glsl for the definitions of Ray, NO_HIT, INF_HIT,
 // RayShapeIntersection
 
+vec4 transformNormalToEC(in vec4 intersection) {
+    return vec4(normalize(czm_normal * intersection.xyz), intersection.w);
+}
+
+RayShapeIntersection transformNormalsToEC(in RayShapeIntersection ix) {
+    return RayShapeIntersection(transformNormalToEC(ix.entry), transformNormalToEC(ix.exit));
+}
+
 vec4 intersectLongitude(in Ray ray, in float angle, in bool positiveNormal) {
     float normalSign = positiveNormal ? 1.0 : -1.0;
     vec2 planeNormal = vec2(-sin(angle), cos(angle)) * normalSign;
@@ -32,8 +40,8 @@ RayShapeIntersection intersectHalfSpace(in Ray ray, in float angle, in bool posi
 
 void intersectFlippedWedge(in Ray ray, in vec2 minMaxAngle, out RayShapeIntersection intersections[2])
 {
-    intersections[0] = intersectHalfSpace(ray, minMaxAngle.x, false);
-    intersections[1] = intersectHalfSpace(ray, minMaxAngle.y, true);
+    intersections[0] = transformNormalsToEC(intersectHalfSpace(ray, minMaxAngle.x, false));
+    intersections[1] = transformNormalsToEC(intersectHalfSpace(ray, minMaxAngle.y, true));
 }
 
 bool hitPositiveHalfPlane(in Ray ray, in vec4 intersection, in bool positiveNormal) {
@@ -46,14 +54,18 @@ bool hitPositiveHalfPlane(in Ray ray, in vec4 intersection, in bool positiveNorm
 void intersectHalfPlane(in Ray ray, in float angle, out RayShapeIntersection intersections[2]) {
     vec4 intersection = intersectLongitude(ray, angle, true);
     vec4 farSide = vec4(normalize(ray.dir), INF_HIT);
+    bool hitPositiveSide = hitPositiveHalfPlane(ray, intersection, true);
+
+    farSide = transformNormalToEC(farSide);
 
-    if (hitPositiveHalfPlane(ray, intersection, true)) {
+    if (hitPositiveSide) {
+        intersection = transformNormalToEC(intersection);
         intersections[0].entry = -1.0 * farSide;
-        intersections[0].exit = vec4(-1.0 * intersection.xy, 0.0, intersection.w);
+        intersections[0].exit = vec4(-1.0 * intersection.xyz, intersection.w);
         intersections[1].entry = intersection;
         intersections[1].exit = farSide;
     } else {
-        vec4 miss = vec4(normalize(ray.dir), NO_HIT);
+        vec4 miss = vec4(normalize(czm_normal * ray.dir), NO_HIT);
         intersections[0].entry = -1.0 * farSide;
         intersections[0].exit = farSide;
         intersections[1].entry = miss;
@@ -88,15 +100,15 @@ RayShapeIntersection intersectRegularWedge(in Ray ray, in vec2 minMaxAngle)
 
     if (exitFromInside && enterFromOutside) {
         // Ray crosses both faces of negative wedge, exiting then entering the positive shape
-        return RayShapeIntersection(first, last);
+        return transformNormalsToEC(RayShapeIntersection(first, last));
     } else if (!exitFromInside && enterFromOutside) {
         // Ray starts inside wedge. last is in shadow wedge, and first is actually the entry
-        return RayShapeIntersection(-1.0 * farSide, first);
+        return transformNormalsToEC(RayShapeIntersection(-1.0 * farSide, first));
     } else if (exitFromInside && !enterFromOutside) {
         // First intersection was in the shadow wedge, so last is actually the exit
-        return RayShapeIntersection(last, farSide);
+        return transformNormalsToEC(RayShapeIntersection(last, farSide));
     } else { // !exitFromInside && !enterFromOutside
         // Both intersections were in the shadow wedge
-        return RayShapeIntersection(miss, miss);
+        return transformNormalsToEC(RayShapeIntersection(miss, miss));
     }
 }

package/Source/Shaders/Voxels/IntersectLongitude.js

@@ -2,6 +2,14 @@
 export default "// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT, INF_HIT,\n\
 // RayShapeIntersection\n\
 \n\
+vec4 transformNormalToEC(in vec4 intersection) {\n\
+    return vec4(normalize(czm_normal * intersection.xyz), intersection.w);\n\
+}\n\
+\n\
+RayShapeIntersection transformNormalsToEC(in RayShapeIntersection ix) {\n\
+    return RayShapeIntersection(transformNormalToEC(ix.entry), transformNormalToEC(ix.exit));\n\
+}\n\
+\n\
 vec4 intersectLongitude(in Ray ray, in float angle, in bool positiveNormal) {\n\
     float normalSign = positiveNormal ? 1.0 : -1.0;\n\
     vec2 planeNormal = vec2(-sin(angle), cos(angle)) * normalSign;\n\
@@ -33,8 +41,8 @@ RayShapeIntersection intersectHalfSpace(in Ray ray, in float angle, in bool posi
 \n\
 void intersectFlippedWedge(in Ray ray, in vec2 minMaxAngle, out RayShapeIntersection intersections[2])\n\
 {\n\
-    intersections[0] = intersectHalfSpace(ray, minMaxAngle.x, false);\n\
-    intersections[1] = intersectHalfSpace(ray, minMaxAngle.y, true);\n\
+    intersections[0] = transformNormalsToEC(intersectHalfSpace(ray, minMaxAngle.x, false));\n\
+    intersections[1] = transformNormalsToEC(intersectHalfSpace(ray, minMaxAngle.y, true));\n\
 }\n\
 \n\
 bool hitPositiveHalfPlane(in Ray ray, in vec4 intersection, in bool positiveNormal) {\n\
@@ -47,14 +55,18 @@ bool hitPositiveHalfPlane(in Ray ray, in vec4 intersection, in bool positiveNorm
 void intersectHalfPlane(in Ray ray, in float angle, out RayShapeIntersection intersections[2]) {\n\
     vec4 intersection = intersectLongitude(ray, angle, true);\n\
     vec4 farSide = vec4(normalize(ray.dir), INF_HIT);\n\
+    bool hitPositiveSide = hitPositiveHalfPlane(ray, intersection, true);\n\
+\n\
+    farSide = transformNormalToEC(farSide);\n\
 \n\
-    if (hitPositiveHalfPlane(ray, intersection, true)) {\n\
+    if (hitPositiveSide) {\n\
+        intersection = transformNormalToEC(intersection);\n\
         intersections[0].entry = -1.0 * farSide;\n\
-        intersections[0].exit = vec4(-1.0 * intersection.xy, 0.0, intersection.w);\n\
+        intersections[0].exit = vec4(-1.0 * intersection.xyz, intersection.w);\n\
         intersections[1].entry = intersection;\n\
         intersections[1].exit = farSide;\n\
     } else {\n\
-        vec4 miss = vec4(normalize(ray.dir), NO_HIT);\n\
+        vec4 miss = vec4(normalize(czm_normal * ray.dir), NO_HIT);\n\
         intersections[0].entry = -1.0 * farSide;\n\
         intersections[0].exit = farSide;\n\
         intersections[1].entry = miss;\n\
@@ -89,16 +101,16 @@ RayShapeIntersection intersectRegularWedge(in Ray ray, in vec2 minMaxAngle)\n\
 \n\
     if (exitFromInside && enterFromOutside) {\n\
         // Ray crosses both faces of negative wedge, exiting then entering the positive shape\n\
-        return RayShapeIntersection(first, last);\n\
+        return transformNormalsToEC(RayShapeIntersection(first, last));\n\
     } else if (!exitFromInside && enterFromOutside) {\n\
         // Ray starts inside wedge. last is in shadow wedge, and first is actually the entry\n\
-        return RayShapeIntersection(-1.0 * farSide, first);\n\
+        return transformNormalsToEC(RayShapeIntersection(-1.0 * farSide, first));\n\
     } else if (exitFromInside && !enterFromOutside) {\n\
         // First intersection was in the shadow wedge, so last is actually the exit\n\
-        return RayShapeIntersection(last, farSide);\n\
+        return transformNormalsToEC(RayShapeIntersection(last, farSide));\n\
     } else { // !exitFromInside && !enterFromOutside\n\
         // Both intersections were in the shadow wedge\n\
-        return RayShapeIntersection(miss, miss);\n\
+        return transformNormalsToEC(RayShapeIntersection(miss, miss));\n\
     }\n\
 }\n\
 ";

package/Source/Shaders/Voxels/{IntersectClippingPlanes.glsl → IntersectPlane.glsl}

@@ -22,6 +22,7 @@ vec4 intersectPlane(in Ray ray, in vec4 plane) {
     return vec4(n, t);
 }
 
+#ifdef CLIPPING_PLANES
 void intersectClippingPlanes(in Ray ray, inout Intersections ix) {
     vec4 backSide = vec4(-ray.dir, -INF_HIT);
     vec4 farSide = vec4(ray.dir, +INF_HIT);
@@ -30,7 +31,7 @@ void intersectClippingPlanes(in Ray ray, inout Intersections ix) {
     #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);
+        vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, 0);
         vec4 intersection = intersectPlane(ray, planeUv);
         bool reflects = dot(ray.dir, intersection.xyz) < 0.0;
         clippingVolume.entry = reflects ? backSide : intersection;
@@ -40,7 +41,7 @@ void intersectClippingPlanes(in Ray ray, inout Intersections ix) {
         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);
+            vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i);
             vec4 intersection = intersectPlane(ray, planeUv);
             if (dot(ray.dir, planeUv.xyz) > 0.0) {
                 firstTransmission = intersection.w <= firstTransmission.w ? intersection : firstTransmission;
@@ -58,7 +59,7 @@ void intersectClippingPlanes(in Ray ray, inout Intersections ix) {
         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);
+            vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i);
             vec4 intersection = intersectPlane(ray, planeUv);
             if (dot(ray.dir, planeUv.xyz) > 0.0) {
                 lastTransmission = intersection.w > lastTransmission.w ? intersection : lastTransmission;
@@ -76,3 +77,4 @@ void intersectClippingPlanes(in Ray ray, inout Intersections ix) {
         setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX, clippingVolume);
     #endif
 }
+#endif

package/Source/Shaders/Voxels/{IntersectClippingPlanes.js → IntersectPlane.js}

@@ -23,6 +23,7 @@ vec4 intersectPlane(in Ray ray, in vec4 plane) {\n\
     return vec4(n, t);\n\
 }\n\
 \n\
+#ifdef CLIPPING_PLANES\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\
@@ -31,7 +32,7 @@ void intersectClippingPlanes(in Ray ray, inout Intersections ix) {\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\
+        vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, 0);\n\
         vec4 intersection = intersectPlane(ray, planeUv);\n\
         bool reflects = dot(ray.dir, intersection.xyz) < 0.0;\n\
         clippingVolume.entry = reflects ? backSide : intersection;\n\
@@ -41,7 +42,7 @@ void intersectClippingPlanes(in Ray ray, inout Intersections ix) {\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\
+            vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i);\n\
             vec4 intersection = intersectPlane(ray, planeUv);\n\
             if (dot(ray.dir, planeUv.xyz) > 0.0) {\n\
                 firstTransmission = intersection.w <= firstTransmission.w ? intersection : firstTransmission;\n\
@@ -59,7 +60,7 @@ void intersectClippingPlanes(in Ray ray, inout Intersections ix) {\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\
+            vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i);\n\
             vec4 intersection = intersectPlane(ray, planeUv);\n\
             if (dot(ray.dir, planeUv.xyz) > 0.0) {\n\
                 lastTransmission = intersection.w > lastTransmission.w ? intersection : lastTransmission;\n\
@@ -77,4 +78,5 @@ void intersectClippingPlanes(in Ray ray, inout Intersections ix) {\n\
         setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX, clippingVolume);\n\
     #endif\n\
 }\n\
+#endif\n\
 ";

package/Source/Shaders/Voxels/Intersection.glsl

@@ -11,9 +11,9 @@
 #define INTERSECTION_COUNT ###
 */
 
-RayShapeIntersection intersectScene(in vec2 screenCoord, in Ray ray, out Intersections ix) {
+RayShapeIntersection intersectScene(in vec2 screenCoord, in Ray ray, in Ray rayEC, out Intersections ix) {
     // Do a ray-shape intersection to find the exact starting and ending points.
-    intersectShape(ray, ix);
+    intersectShape(ray, rayEC, ix);
 
     // Exit early if the positive shape was completely missed or behind the ray.
     RayShapeIntersection intersection = getFirstIntersection(ix);
@@ -28,7 +28,7 @@ RayShapeIntersection intersectScene(in vec2 screenCoord, in Ray ray, out Interse
     #endif
 
     // Depth
-    intersectDepth(screenCoord, ray, ix);
+    intersectDepth(screenCoord, rayEC, ix);
 
     // Find the first intersection that's in front of the ray
     #if (INTERSECTION_COUNT > 1)

package/Source/Shaders/Voxels/Intersection.js

@@ -12,9 +12,9 @@ export default "// Main intersection function for Voxel scenes.\n\
 #define INTERSECTION_COUNT ###\n\
 */\n\
 \n\
-RayShapeIntersection intersectScene(in vec2 screenCoord, in Ray ray, out Intersections ix) {\n\
+RayShapeIntersection intersectScene(in vec2 screenCoord, in Ray ray, in Ray rayEC, out Intersections ix) {\n\
     // Do a ray-shape intersection to find the exact starting and ending points.\n\
-    intersectShape(ray, ix);\n\
+    intersectShape(ray, rayEC, ix);\n\
 \n\
     // Exit early if the positive shape was completely missed or behind the ray.\n\
     RayShapeIntersection intersection = getFirstIntersection(ix);\n\
@@ -29,7 +29,7 @@ RayShapeIntersection intersectScene(in vec2 screenCoord, in Ray ray, out Interse
     #endif\n\
 \n\
     // Depth\n\
-    intersectDepth(screenCoord, ray, ix);\n\
+    intersectDepth(screenCoord, rayEC, ix);\n\
 \n\
     // Find the first intersection that's in front of the ray\n\
     #if (INTERSECTION_COUNT > 1)\n\

package/Source/Shaders/Voxels/Octree.glsl

@@ -29,6 +29,11 @@ struct TraversalData {
     int parentOctreeIndex;
 };
 
+struct TileAndUvCoordinate {
+    ivec4 tileCoords;
+    vec3 tileUv;
+};
+
 struct SampleData {
     int megatextureIndex;
     ivec4 tileCoords;
@@ -79,23 +84,20 @@ int getOctreeParentIndex(in int octreeIndex) {
     return parentOctreeIndex;
 }
 
-/**
-* Convert a position in the uv-space of the tileset bounding shape
-* into the uv-space of a tile within the tileset
-*/
-vec3 getTileUv(in vec3 shapePosition, in ivec4 octreeCoords) {
-	// PERFORMANCE_IDEA: use bit-shifting (only in WebGL2)
-    float dimAtLevel = exp2(float(octreeCoords.w));
-    return shapePosition * dimAtLevel - vec3(octreeCoords.xyz);
+vec3 getTileUv(in TileAndUvCoordinate tileAndUv, in ivec4 octreeCoords) {
+    int levelDifference = tileAndUv.tileCoords.w - octreeCoords.w;
+    float scalar = exp2(-1.0 * float(levelDifference));
+    vec3 originShift = vec3(tileAndUv.tileCoords.xyz - (octreeCoords.xyz << levelDifference)) * scalar;
+    return tileAndUv.tileUv * scalar + originShift;
 }
 
-vec3 getClampedTileUv(in vec3 shapePosition, in ivec4 octreeCoords) {
-    vec3 tileUv = getTileUv(shapePosition, octreeCoords);
+vec3 getClampedTileUv(in TileAndUvCoordinate tileAndUv, in ivec4 octreeCoords) {
+    vec3 tileUv = getTileUv(tileAndUv, octreeCoords);
     return clamp(tileUv, vec3(0.0), vec3(1.0));
 }
 
-void addSampleCoordinates(in vec3 shapePosition, inout SampleData sampleData) {
-    vec3 tileUv = getClampedTileUv(shapePosition, sampleData.tileCoords);
+void addSampleCoordinates(in TileAndUvCoordinate tileAndUv, inout SampleData sampleData) {
+    vec3 tileUv = getClampedTileUv(tileAndUv, sampleData.tileCoords);
 
     vec3 inputCoordinate = tileUv * vec3(u_dimensions);
 #if defined(PADDING)
@@ -162,32 +164,25 @@ void getOctreeLeafSampleDatas(in OctreeNodeData data, in ivec4 octreeCoords, out
 }
 #endif
 
-OctreeNodeData traverseOctreeDownwards(in vec3 shapePosition, inout TraversalData traversalData) {
-    float sizeAtLevel = exp2(-1.0 * float(traversalData.octreeCoords.w));
-    vec3 start = vec3(traversalData.octreeCoords.xyz) * sizeAtLevel;
-    vec3 end = start + vec3(sizeAtLevel);
+OctreeNodeData traverseOctreeDownwards(in ivec4 tileCoordinate, inout TraversalData traversalData) {
     OctreeNodeData childData;
 
     for (int i = 0; i < OCTREE_MAX_LEVELS; ++i) {
-        // Find out which octree child contains the position
-        // 0 if before center, 1 if after
-        vec3 center = 0.5 * (start + end);
-        vec3 childCoord = step(center, shapePosition);
-
-        // Get octree coords for the next level down
-        ivec4 octreeCoords = traversalData.octreeCoords;
-        traversalData.octreeCoords = ivec4(octreeCoords.xyz * 2 + ivec3(childCoord), octreeCoords.w + 1);
+        // tileCoordinate.xyz is defined at the level of detail tileCoordinate.w.
+        // Find the corresponding coordinate at the level traversalData.octreeCoords.w
+        int level = traversalData.octreeCoords.w + 1;
+        int levelDifference = tileCoordinate.w - level;
+        ivec3 coordinateAtLevel = tileCoordinate.xyz >> levelDifference;
+        traversalData.octreeCoords = ivec4(coordinateAtLevel, level);
 
-        childData = getOctreeChildData(traversalData.parentOctreeIndex, ivec3(childCoord));
+        ivec3 childCoordinate = coordinateAtLevel & 1;
+        childData = getOctreeChildData(traversalData.parentOctreeIndex, childCoordinate);
 
         if (childData.flag != OCTREE_FLAG_INTERNAL) {
             // leaf tile - stop traversing
             break;
         }
 
-        // interior tile - keep going deeper
-        start = mix(start, center, childCoord);
-        end = mix(center, end, childCoord);
         traversalData.parentOctreeIndex = childData.data;
     }
 
@@ -198,50 +193,50 @@ OctreeNodeData traverseOctreeDownwards(in vec3 shapePosition, inout TraversalDat
 * Transform a given position to an octree tile coordinate and a position within that tile,
 * and find the corresponding megatexture index and texture coordinates
 */
-void traverseOctreeFromBeginning(in vec3 shapePosition, out TraversalData traversalData, out SampleData sampleDatas[SAMPLE_COUNT]) {
+void traverseOctreeFromBeginning(in TileAndUvCoordinate tileAndUv, out TraversalData traversalData, out SampleData sampleDatas[SAMPLE_COUNT]) {
     traversalData.octreeCoords = ivec4(0);
     traversalData.parentOctreeIndex = 0;
 
     OctreeNodeData nodeData = getOctreeNodeData(vec2(0.0));
     if (nodeData.flag != OCTREE_FLAG_LEAF) {
-        nodeData = traverseOctreeDownwards(shapePosition, traversalData);
+        nodeData = traverseOctreeDownwards(tileAndUv.tileCoords, traversalData);
     }
 
     #if (SAMPLE_COUNT == 1)
         getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);
-        addSampleCoordinates(shapePosition, sampleDatas[0]);
+        addSampleCoordinates(tileAndUv, sampleDatas[0]);
     #else
         getOctreeLeafSampleDatas(nodeData, traversalData.octreeCoords, sampleDatas);
-        addSampleCoordinates(shapePosition, sampleDatas[0]);
-        addSampleCoordinates(shapePosition, sampleDatas[1]);
+        addSampleCoordinates(tileAndUv, sampleDatas[0]);
+        addSampleCoordinates(tileAndUv, sampleDatas[1]);
     #endif
 }
 
-bool inRange(in vec3 v, in vec3 minVal, in vec3 maxVal) {
-    return clamp(v, minVal, maxVal) == v;
-}
-
-bool insideTile(in vec3 shapePosition, in ivec4 octreeCoords) {
-    vec3 tileUv = getTileUv(shapePosition, octreeCoords);
-	bool inside = inRange(tileUv, vec3(0.0), vec3(1.0));
-	// Assume (!) the position is always inside the root tile.
-	return inside || octreeCoords.w == 0;
+bool insideTile(in ivec4 tileCoordinate, in ivec4 octreeCoords) {
+    int levelDifference = tileCoordinate.w - octreeCoords.w;
+    if (levelDifference < 0) {
+        return false;
+    }
+    ivec3 coordinateAtLevel = tileCoordinate.xyz >> levelDifference;
+    return coordinateAtLevel == octreeCoords.xyz;
 }
 
-void traverseOctreeFromExisting(in vec3 shapePosition, inout TraversalData traversalData, inout SampleData sampleDatas[SAMPLE_COUNT]) {
-    if (insideTile(shapePosition, traversalData.octreeCoords)) {
+void traverseOctreeFromExisting(in TileAndUvCoordinate tileAndUv, inout TraversalData traversalData, inout SampleData sampleDatas[SAMPLE_COUNT]) {
+    ivec4 tileCoords = tileAndUv.tileCoords;
+    if (insideTile(tileCoords, traversalData.octreeCoords)) {
         for (int i = 0; i < SAMPLE_COUNT; i++) {
-            addSampleCoordinates(shapePosition, sampleDatas[i]);
+            addSampleCoordinates(tileAndUv, sampleDatas[i]);
         }
         return;
     }
 
-    // Go up tree until we find a parent tile containing shapePosition
+    // Go up tree until we find a parent tile containing tileCoords.
+    // Assumes all parents are available all they way up to the root.
     for (int i = 0; i < OCTREE_MAX_LEVELS; ++i) {
         traversalData.octreeCoords.xyz /= 2;
         traversalData.octreeCoords.w -= 1;
 
-        if (insideTile(shapePosition, traversalData.octreeCoords)) {
+        if (insideTile(tileCoords, traversalData.octreeCoords)) {
             break;
         }
 
@@ -249,14 +244,14 @@ void traverseOctreeFromExisting(in vec3 shapePosition, inout TraversalData trave
     }
 
     // Go down tree
-    OctreeNodeData nodeData = traverseOctreeDownwards(shapePosition, traversalData);
+    OctreeNodeData nodeData = traverseOctreeDownwards(tileCoords, traversalData);
 
     #if (SAMPLE_COUNT == 1)
         getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);
-        addSampleCoordinates(shapePosition, sampleDatas[0]);
+        addSampleCoordinates(tileAndUv, sampleDatas[0]);
     #else
         getOctreeLeafSampleDatas(nodeData, traversalData.octreeCoords, sampleDatas);
-        addSampleCoordinates(shapePosition, sampleDatas[0]);
-        addSampleCoordinates(shapePosition, sampleDatas[1]);
+        addSampleCoordinates(tileAndUv, sampleDatas[0]);
+        addSampleCoordinates(tileAndUv, sampleDatas[1]);
     #endif
 }