@cesium/engine 8.0.0 → 9.1.0

package/Source/Shaders/Voxels/IntersectCylinder.glsl

@@ -1,14 +1,12 @@
-// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT,
-// setIntersection, setIntersectionPair, setShapeIntersection
+// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT, Intersections,
+// RayShapeIntersection, setSurfaceIntersection, setShapeIntersection,
+// intersectIntersections
 // See IntersectLongitude.glsl for the definitions of intersectHalfPlane,
 // intersectFlippedWedge, intersectRegularWedge
 
 /* Cylinder defines (set in Scene/VoxelCylinderShape.js)
 #define CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MIN
-#define CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MAX
 #define CYLINDER_HAS_RENDER_BOUNDS_RADIUS_FLAT
-#define CYLINDER_HAS_RENDER_BOUNDS_HEIGHT
-#define CYLINDER_HAS_RENDER_BOUNDS_HEIGHT_FLAT
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_UNDER_HALF
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_OVER_HALF
@@ -20,114 +18,87 @@
 */
 
 // Cylinder uniforms
-#if defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MAX) || defined(CYLINDER_HAS_RENDER_BOUNDS_HEIGHT)
-    uniform vec3 u_cylinderUvToRenderBoundsScale;
-    uniform vec3 u_cylinderUvToRenderBoundsTranslate;
-#endif
-#if defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MIN) && !defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_FLAT)
-    uniform float u_cylinderUvToRenderRadiusMin;
-#endif
+uniform vec2 u_cylinderRenderRadiusMinMax;
+uniform vec2 u_cylinderRenderHeightMinMax;
 #if defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE)
     uniform vec2 u_cylinderRenderAngleMinMax;
 #endif
 
-vec2 intersectUnitCylinder(Ray ray)
+/**
+ * Find the intersection of a ray with the volume defined by two planes of constant z
+ */
+RayShapeIntersection intersectHeightBounds(in Ray ray, in vec2 minMaxHeight, in bool convex)
 {
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
+    float zPosition = ray.pos.z;
+    float zDirection = ray.dir.z;
 
-    float a = dot(d.xy, d.xy);
-    float b = dot(o.xy, d.xy);
-    float c = dot(o.xy, o.xy) - 1.0;
-    float det = b * b - a * c;
+    float tmin = (minMaxHeight.x - zPosition) / zDirection;
+    float tmax = (minMaxHeight.y - zPosition) / zDirection;
 
-    if (det < 0.0) {
-        return vec2(NO_HIT);
-    }
+    // Normals point outside the volume
+    float signFlip = convex ? 1.0 : -1.0;
+    vec4 intersectMin = vec4(0.0, 0.0, -1.0 * signFlip, tmin);
+    vec4 intersectMax = vec4(0.0, 0.0, 1.0 * signFlip, tmax);
 
-    det = sqrt(det);
-    float ta = (-b - det) / a;
-    float tb = (-b + det) / a;
-    float t1 = min(ta, tb);
-    float t2 = max(ta, tb);
+    bool topEntry = zDirection < 0.0;
+    vec4 entry = topEntry ? intersectMax : intersectMin;
+    vec4 exit = topEntry ? intersectMin : intersectMax;
 
-    float z1 = o.z + t1 * d.z;
-    float z2 = o.z + t2 * d.z;
-
-    if (abs(z1) >= 1.0)
-    {
-        float tCap = (sign(z1) - o.z) / d.z;
-        t1 = abs(b + a * tCap) < det ? tCap : NO_HIT;
-    }
-
-    if (abs(z2) >= 1.0)
-    {
-        float tCap = (sign(z2) - o.z) / d.z;
-        t2 = abs(b + a * tCap) < det ? tCap : NO_HIT;
-    }
-
-    return vec2(t1, t2);
+    return RayShapeIntersection(entry, exit);
 }
 
-vec2 intersectUnitCircle(Ray ray) {
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
+/**
+ * Find the intersection of a ray with a right cylindrical surface of a given radius
+ * about the z-axis.
+ */
+RayShapeIntersection intersectCylinder(in Ray ray, in float radius, in bool convex)
+{
+    vec2 position = ray.pos.xy;
+    vec2 direction = ray.dir.xy;
 
-    float t = -o.z / d.z;
-    vec2 zPlanePos = o.xy + d.xy * t;
-    float distSqr = dot(zPlanePos, zPlanePos);
+    float a = dot(direction, direction);
+    float b = dot(position, direction);
+    float c = dot(position, position) - radius * radius;
+    float determinant = b * b - a * c;
 
-    if (distSqr > 1.0) {
-        return vec2(NO_HIT);
+    if (determinant < 0.0) {
+        vec4 miss = vec4(normalize(ray.dir), NO_HIT);
+        return RayShapeIntersection(miss, miss);
     }
 
-    return vec2(t, t);
+    determinant = sqrt(determinant);
+    float t1 = (-b - determinant) / a;
+    float t2 = (-b + determinant) / a;
+    float signFlip = convex ? 1.0 : -1.0;
+    vec4 intersect1 = vec4(normalize(position + t1 * direction) * signFlip, 0.0, t1);
+    vec4 intersect2 = vec4(normalize(position + t2 * direction) * signFlip, 0.0, t2);
+
+    return RayShapeIntersection(intersect1, intersect2);
 }
 
-vec2 intersectInfiniteUnitCylinder(Ray ray)
+/**
+ * Find the intersection of a ray with a right cylindrical solid of given
+ * radius and height bounds. NOTE: The shape is assumed to be convex.
+ */
+RayShapeIntersection intersectBoundedCylinder(in Ray ray, in float radius, in vec2 minMaxHeight)
 {
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
-
-    float a = dot(d.xy, d.xy);
-    float b = dot(o.xy, d.xy);
-    float c = dot(o.xy, o.xy) - 1.0;
-    float det = b * b - a * c;
-
-    if (det < 0.0) {
-        return vec2(NO_HIT);
-    }
-
-    det = sqrt(det);
-    float t1 = (-b - det) / a;
-    float t2 = (-b + det) / a;
-    float tmin = min(t1, t2);
-    float tmax = max(t1, t2);
-
-    return vec2(tmin, tmax);
+    RayShapeIntersection cylinderIntersection = intersectCylinder(ray, radius, true);
+    RayShapeIntersection heightBoundsIntersection = intersectHeightBounds(ray, minMaxHeight, true);
+    return intersectIntersections(ray, cylinderIntersection, heightBoundsIntersection);
 }
 
 void intersectShape(Ray ray, inout Intersections ix)
 {
-    #if defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MAX) || defined(CYLINDER_HAS_RENDER_BOUNDS_HEIGHT)
-        ray.pos = ray.pos * u_cylinderUvToRenderBoundsScale + u_cylinderUvToRenderBoundsTranslate;
-        ray.dir *= u_cylinderUvToRenderBoundsScale;
-    #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 *= 2.0;
-    #endif
+    // 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;
 
-    #if defined(CYLINDER_HAS_RENDER_BOUNDS_HEIGHT_FLAT)
-        vec2 outerIntersect = intersectUnitCircle(ray);
-    #else
-        vec2 outerIntersect = intersectUnitCylinder(ray);
-    #endif
+    RayShapeIntersection outerIntersect = intersectBoundedCylinder(ray, u_cylinderRenderRadiusMinMax.y, u_cylinderRenderHeightMinMax);
 
-    setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MAX, outerIntersect);
+    setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MAX, outerIntersect);
 
-    if (outerIntersect.x == NO_HIT) {
+    if (outerIntersect.entry.w == NO_HIT) {
         return;
     }
 
@@ -148,15 +119,14 @@ void intersectShape(Ray ray, inout Intersections ix)
 
         // Note: If initializeIntersections() changes its sorting function
         // from bubble sort to something else, this code may need to change.
-        vec2 innerIntersect = intersectInfiniteUnitCylinder(ray);
-        setIntersection(ix, 0, outerIntersect.x, true, true);   // positive, enter
-        setIntersection(ix, 1, innerIntersect.x, false, true);  // negative, enter
-        setIntersection(ix, 2, innerIntersect.y, false, false); // negative, exit
-        setIntersection(ix, 3, outerIntersect.y, true, false);  // positive, exit
+        RayShapeIntersection innerIntersect = intersectCylinder(ray, 1.0, false);
+        setSurfaceIntersection(ix, 0, outerIntersect.entry, true, true);  // positive, enter
+        setSurfaceIntersection(ix, 1, innerIntersect.entry, false, true); // negative, enter
+        setSurfaceIntersection(ix, 2, innerIntersect.exit, false, false); // negative, exit
+        setSurfaceIntersection(ix, 3, outerIntersect.exit, true, false);  // positive, exit
     #elif defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MIN)
-        Ray innerRay = Ray(ray.pos * u_cylinderUvToRenderRadiusMin, ray.dir * u_cylinderUvToRenderRadiusMin);
-        vec2 innerIntersect = intersectInfiniteUnitCylinder(innerRay);
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MIN, innerIntersect);
+        RayShapeIntersection innerIntersect = intersectCylinder(ray, u_cylinderRenderRadiusMinMax.x, false);
+        setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MIN, innerIntersect);
     #endif
 
     #if defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_UNDER_HALF)

package/Source/Shaders/Voxels/IntersectCylinder.js

@@ -1,15 +1,13 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT,\n\
-// setIntersection, setIntersectionPair, setShapeIntersection\n\
+export default "// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT, Intersections,\n\
+// RayShapeIntersection, setSurfaceIntersection, setShapeIntersection,\n\
+// intersectIntersections\n\
 // See IntersectLongitude.glsl for the definitions of intersectHalfPlane,\n\
 // intersectFlippedWedge, intersectRegularWedge\n\
 \n\
 /* Cylinder defines (set in Scene/VoxelCylinderShape.js)\n\
 #define CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MIN\n\
-#define CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MAX\n\
 #define CYLINDER_HAS_RENDER_BOUNDS_RADIUS_FLAT\n\
-#define CYLINDER_HAS_RENDER_BOUNDS_HEIGHT\n\
-#define CYLINDER_HAS_RENDER_BOUNDS_HEIGHT_FLAT\n\
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE\n\
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_UNDER_HALF\n\
 #define CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_OVER_HALF\n\
@@ -21,114 +19,87 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT
 */\n\
 \n\
 // Cylinder uniforms\n\
-#if defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MAX) || defined(CYLINDER_HAS_RENDER_BOUNDS_HEIGHT)\n\
-    uniform vec3 u_cylinderUvToRenderBoundsScale;\n\
-    uniform vec3 u_cylinderUvToRenderBoundsTranslate;\n\
-#endif\n\
-#if defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MIN) && !defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_FLAT)\n\
-    uniform float u_cylinderUvToRenderRadiusMin;\n\
-#endif\n\
+uniform vec2 u_cylinderRenderRadiusMinMax;\n\
+uniform vec2 u_cylinderRenderHeightMinMax;\n\
 #if defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE)\n\
     uniform vec2 u_cylinderRenderAngleMinMax;\n\
 #endif\n\
 \n\
-vec2 intersectUnitCylinder(Ray ray)\n\
+/**\n\
+ * Find the intersection of a ray with the volume defined by two planes of constant z\n\
+ */\n\
+RayShapeIntersection intersectHeightBounds(in Ray ray, in vec2 minMaxHeight, in bool convex)\n\
 {\n\
-    vec3 o = ray.pos;\n\
-    vec3 d = ray.dir;\n\
+    float zPosition = ray.pos.z;\n\
+    float zDirection = ray.dir.z;\n\
 \n\
-    float a = dot(d.xy, d.xy);\n\
-    float b = dot(o.xy, d.xy);\n\
-    float c = dot(o.xy, o.xy) - 1.0;\n\
-    float det = b * b - a * c;\n\
+    float tmin = (minMaxHeight.x - zPosition) / zDirection;\n\
+    float tmax = (minMaxHeight.y - zPosition) / zDirection;\n\
 \n\
-    if (det < 0.0) {\n\
-        return vec2(NO_HIT);\n\
-    }\n\
+    // Normals point outside the volume\n\
+    float signFlip = convex ? 1.0 : -1.0;\n\
+    vec4 intersectMin = vec4(0.0, 0.0, -1.0 * signFlip, tmin);\n\
+    vec4 intersectMax = vec4(0.0, 0.0, 1.0 * signFlip, tmax);\n\
 \n\
-    det = sqrt(det);\n\
-    float ta = (-b - det) / a;\n\
-    float tb = (-b + det) / a;\n\
-    float t1 = min(ta, tb);\n\
-    float t2 = max(ta, tb);\n\
+    bool topEntry = zDirection < 0.0;\n\
+    vec4 entry = topEntry ? intersectMax : intersectMin;\n\
+    vec4 exit = topEntry ? intersectMin : intersectMax;\n\
 \n\
-    float z1 = o.z + t1 * d.z;\n\
-    float z2 = o.z + t2 * d.z;\n\
-\n\
-    if (abs(z1) >= 1.0)\n\
-    {\n\
-        float tCap = (sign(z1) - o.z) / d.z;\n\
-        t1 = abs(b + a * tCap) < det ? tCap : NO_HIT;\n\
-    }\n\
-\n\
-    if (abs(z2) >= 1.0)\n\
-    {\n\
-        float tCap = (sign(z2) - o.z) / d.z;\n\
-        t2 = abs(b + a * tCap) < det ? tCap : NO_HIT;\n\
-    }\n\
-\n\
-    return vec2(t1, t2);\n\
+    return RayShapeIntersection(entry, exit);\n\
 }\n\
 \n\
-vec2 intersectUnitCircle(Ray ray) {\n\
-    vec3 o = ray.pos;\n\
-    vec3 d = ray.dir;\n\
+/**\n\
+ * Find the intersection of a ray with a right cylindrical surface of a given radius\n\
+ * about the z-axis.\n\
+ */\n\
+RayShapeIntersection intersectCylinder(in Ray ray, in float radius, in bool convex)\n\
+{\n\
+    vec2 position = ray.pos.xy;\n\
+    vec2 direction = ray.dir.xy;\n\
 \n\
-    float t = -o.z / d.z;\n\
-    vec2 zPlanePos = o.xy + d.xy * t;\n\
-    float distSqr = dot(zPlanePos, zPlanePos);\n\
+    float a = dot(direction, direction);\n\
+    float b = dot(position, direction);\n\
+    float c = dot(position, position) - radius * radius;\n\
+    float determinant = b * b - a * c;\n\
 \n\
-    if (distSqr > 1.0) {\n\
-        return vec2(NO_HIT);\n\
+    if (determinant < 0.0) {\n\
+        vec4 miss = vec4(normalize(ray.dir), NO_HIT);\n\
+        return RayShapeIntersection(miss, miss);\n\
     }\n\
 \n\
-    return vec2(t, t);\n\
+    determinant = sqrt(determinant);\n\
+    float t1 = (-b - determinant) / a;\n\
+    float t2 = (-b + determinant) / a;\n\
+    float signFlip = convex ? 1.0 : -1.0;\n\
+    vec4 intersect1 = vec4(normalize(position + t1 * direction) * signFlip, 0.0, t1);\n\
+    vec4 intersect2 = vec4(normalize(position + t2 * direction) * signFlip, 0.0, t2);\n\
+\n\
+    return RayShapeIntersection(intersect1, intersect2);\n\
 }\n\
 \n\
-vec2 intersectInfiniteUnitCylinder(Ray ray)\n\
+/**\n\
+ * Find the intersection of a ray with a right cylindrical solid of given\n\
+ * radius and height bounds. NOTE: The shape is assumed to be convex.\n\
+ */\n\
+RayShapeIntersection intersectBoundedCylinder(in Ray ray, in float radius, in vec2 minMaxHeight)\n\
 {\n\
-    vec3 o = ray.pos;\n\
-    vec3 d = ray.dir;\n\
-\n\
-    float a = dot(d.xy, d.xy);\n\
-    float b = dot(o.xy, d.xy);\n\
-    float c = dot(o.xy, o.xy) - 1.0;\n\
-    float det = b * b - a * c;\n\
-\n\
-    if (det < 0.0) {\n\
-        return vec2(NO_HIT);\n\
-    }\n\
-\n\
-    det = sqrt(det);\n\
-    float t1 = (-b - det) / a;\n\
-    float t2 = (-b + det) / a;\n\
-    float tmin = min(t1, t2);\n\
-    float tmax = max(t1, t2);\n\
-\n\
-    return vec2(tmin, tmax);\n\
+    RayShapeIntersection cylinderIntersection = intersectCylinder(ray, radius, true);\n\
+    RayShapeIntersection heightBoundsIntersection = intersectHeightBounds(ray, minMaxHeight, true);\n\
+    return intersectIntersections(ray, cylinderIntersection, heightBoundsIntersection);\n\
 }\n\
 \n\
 void intersectShape(Ray ray, inout Intersections ix)\n\
 {\n\
-    #if defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MAX) || defined(CYLINDER_HAS_RENDER_BOUNDS_HEIGHT)\n\
-        ray.pos = ray.pos * u_cylinderUvToRenderBoundsScale + u_cylinderUvToRenderBoundsTranslate;\n\
-        ray.dir *= u_cylinderUvToRenderBoundsScale;\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 *= 2.0;\n\
-    #endif\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\
-    #if defined(CYLINDER_HAS_RENDER_BOUNDS_HEIGHT_FLAT)\n\
-        vec2 outerIntersect = intersectUnitCircle(ray);\n\
-    #else\n\
-        vec2 outerIntersect = intersectUnitCylinder(ray);\n\
-    #endif\n\
+    RayShapeIntersection outerIntersect = intersectBoundedCylinder(ray, u_cylinderRenderRadiusMinMax.y, u_cylinderRenderHeightMinMax);\n\
 \n\
-    setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MAX, outerIntersect);\n\
+    setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MAX, outerIntersect);\n\
 \n\
-    if (outerIntersect.x == NO_HIT) {\n\
+    if (outerIntersect.entry.w == NO_HIT) {\n\
         return;\n\
     }\n\
 \n\
@@ -149,15 +120,14 @@ void intersectShape(Ray ray, inout Intersections ix)\n\
 \n\
         // Note: If initializeIntersections() changes its sorting function\n\
         // from bubble sort to something else, this code may need to change.\n\
-        vec2 innerIntersect = intersectInfiniteUnitCylinder(ray);\n\
-        setIntersection(ix, 0, outerIntersect.x, true, true);   // positive, enter\n\
-        setIntersection(ix, 1, innerIntersect.x, false, true);  // negative, enter\n\
-        setIntersection(ix, 2, innerIntersect.y, false, false); // negative, exit\n\
-        setIntersection(ix, 3, outerIntersect.y, true, false);  // positive, exit\n\
+        RayShapeIntersection innerIntersect = intersectCylinder(ray, 1.0, false);\n\
+        setSurfaceIntersection(ix, 0, outerIntersect.entry, true, true);  // positive, enter\n\
+        setSurfaceIntersection(ix, 1, innerIntersect.entry, false, true); // negative, enter\n\
+        setSurfaceIntersection(ix, 2, innerIntersect.exit, false, false); // negative, exit\n\
+        setSurfaceIntersection(ix, 3, outerIntersect.exit, true, false);  // positive, exit\n\
     #elif defined(CYLINDER_HAS_RENDER_BOUNDS_RADIUS_MIN)\n\
-        Ray innerRay = Ray(ray.pos * u_cylinderUvToRenderRadiusMin, ray.dir * u_cylinderUvToRenderRadiusMin);\n\
-        vec2 innerIntersect = intersectInfiniteUnitCylinder(innerRay);\n\
-        setIntersectionPair(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MIN, innerIntersect);\n\
+        RayShapeIntersection innerIntersect = intersectCylinder(ray, u_cylinderRenderRadiusMinMax.x, false);\n\
+        setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MIN, innerIntersect);\n\
     #endif\n\
 \n\
     #if defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_UNDER_HALF)\n\