@cesium/engine 0.1.0 → 1.1.0

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -22,6 +22,7 @@ import czm_passOpaque from './Constants/passOpaque.js'
 import czm_passOverlay from './Constants/passOverlay.js'
 import czm_passTerrainClassification from './Constants/passTerrainClassification.js'
 import czm_passTranslucent from './Constants/passTranslucent.js'
+import czm_passVoxels from './Constants/passVoxels.js'
 import czm_pi from './Constants/pi.js'
 import czm_piOverFour from './Constants/piOverFour.js'
 import czm_piOverSix from './Constants/piOverSix.js'
@@ -153,6 +154,7 @@ export default {
     czm_passOverlay : czm_passOverlay,
     czm_passTerrainClassification : czm_passTerrainClassification,
     czm_passTranslucent : czm_passTranslucent,
+    czm_passVoxels : czm_passVoxels,
     czm_pi : czm_pi,
     czm_piOverFour : czm_piOverFour,
     czm_piOverSix : czm_piOverSix,

package/Source/Shaders/Builtin/Functions/windowToEyeCoordinates.glsl

@@ -1,38 +1,13 @@
-/**
- * Transforms a position from window to eye coordinates.
- * The transform from window to normalized device coordinates is done using components
- * of (@link czm_viewport} and {@link czm_viewportTransformation} instead of calculating
- * the inverse of <code>czm_viewportTransformation</code>. The transformation from
- * normalized device coordinates to clip coordinates is done using <code>fragmentCoordinate.w</code>,
- * which is expected to be the scalar used in the perspective divide. The transformation
- * from clip to eye coordinates is done using {@link czm_inverseProjection}.
- *
- * @name czm_windowToEyeCoordinates
- * @glslFunction
- *
- * @param {vec4} fragmentCoordinate The position in window coordinates to transform.
- *
- * @returns {vec4} The transformed position in eye coordinates.
- *
- * @see czm_modelToWindowCoordinates
- * @see czm_eyeToWindowCoordinates
- * @see czm_inverseProjection
- * @see czm_viewport
- * @see czm_viewportTransformation
- *
- * @example
- * vec4 positionEC = czm_windowToEyeCoordinates(gl_FragCoord);
- */
-vec4 czm_windowToEyeCoordinates(vec4 fragmentCoordinate)
+vec4 czm_screenToEyeCoordinates(vec4 screenCoordinate)
 {
     // Reconstruct NDC coordinates
-    float x = 2.0 * (fragmentCoordinate.x - czm_viewport.x) / czm_viewport.z - 1.0;
-    float y = 2.0 * (fragmentCoordinate.y - czm_viewport.y) / czm_viewport.w - 1.0;
-    float z = (fragmentCoordinate.z - czm_viewportTransformation[3][2]) / czm_viewportTransformation[2][2];
+    float x = 2.0 * screenCoordinate.x - 1.0;
+    float y = 2.0 * screenCoordinate.y - 1.0;
+    float z = (screenCoordinate.z - czm_viewportTransformation[3][2]) / czm_viewportTransformation[2][2];
     vec4 q = vec4(x, y, z, 1.0);
 
     // Reverse the perspective division to obtain clip coordinates.
-    q /= fragmentCoordinate.w;
+    q /= screenCoordinate.w;
 
     // Reverse the projection transformation to obtain eye coordinates.
     if (!(czm_inverseProjection == mat4(0.0))) // IE and Edge sometimes do something weird with != between mat4s
@@ -59,16 +34,20 @@ vec4 czm_windowToEyeCoordinates(vec4 fragmentCoordinate)
 }
 
 /**
- * Transforms a position given as window x/y and a depth or a log depth from window to eye coordinates.
- * This function produces more accurate results for window positions with log depth than
- * conventionally unpacking the log depth using czm_reverseLogDepth and using the standard version
- * of czm_windowToEyeCoordinates.
+ * Transforms a position from window to eye coordinates.
+ * The transform from window to normalized device coordinates is done using components
+ * of (@link czm_viewport} and {@link czm_viewportTransformation} instead of calculating
+ * the inverse of <code>czm_viewportTransformation</code>. The transformation from
+ * normalized device coordinates to clip coordinates is done using <code>fragmentCoordinate.w</code>,
+ * which is expected to be the scalar used in the perspective divide. The transformation
+ * from clip to eye coordinates is done using {@link czm_inverseProjection}.
  *
  * @name czm_windowToEyeCoordinates
  * @glslFunction
  *
- * @param {vec2} fragmentCoordinateXY The XY position in window coordinates to transform.
- * @param {float} depthOrLogDepth A depth or log depth for the fragment.
+ * @param {vec4} fragmentCoordinate The position in window coordinates to transform.
+ *
+ * @returns {vec4} The transformed position in eye coordinates.
  *
  * @see czm_modelToWindowCoordinates
  * @see czm_eyeToWindowCoordinates
@@ -76,24 +55,57 @@ vec4 czm_windowToEyeCoordinates(vec4 fragmentCoordinate)
  * @see czm_viewport
  * @see czm_viewportTransformation
  *
- * @returns {vec4} The transformed position in eye coordinates.
+ * @example
+ * vec4 positionEC = czm_windowToEyeCoordinates(gl_FragCoord);
  */
-vec4 czm_windowToEyeCoordinates(vec2 fragmentCoordinateXY, float depthOrLogDepth)
+vec4 czm_windowToEyeCoordinates(vec4 fragmentCoordinate)
+{
+    vec2 screenCoordXY = (fragmentCoordinate.xy - czm_viewport.xy) / czm_viewport.zw;
+    return czm_screenToEyeCoordinates(vec4(screenCoordXY, fragmentCoordinate.zw));
+}
+
+vec4 czm_screenToEyeCoordinates(vec2 screenCoordinateXY, float depthOrLogDepth)
 {
     // See reverseLogDepth.glsl. This is separate to re-use the pow.
-#ifdef LOG_DEPTH
+#if defined(LOG_DEPTH) || defined(LOG_DEPTH_READ_ONLY)
     float near = czm_currentFrustum.x;
     float far = czm_currentFrustum.y;
     float log2Depth = depthOrLogDepth * czm_log2FarDepthFromNearPlusOne;
     float depthFromNear = pow(2.0, log2Depth) - 1.0;
     float depthFromCamera = depthFromNear + near;
-    vec4 windowCoord = vec4(fragmentCoordinateXY, far * (1.0 - near / depthFromCamera) / (far - near), 1.0);
-    vec4 eyeCoordinate = czm_windowToEyeCoordinates(windowCoord);
+    vec4 screenCoord = vec4(screenCoordinateXY, far * (1.0 - near / depthFromCamera) / (far - near), 1.0);
+    vec4 eyeCoordinate = czm_screenToEyeCoordinates(screenCoord);
     eyeCoordinate.w = 1.0 / depthFromCamera; // Better precision
     return eyeCoordinate;
 #else
-    vec4 windowCoord = vec4(fragmentCoordinateXY, depthOrLogDepth, 1.0);
-    vec4 eyeCoordinate = czm_windowToEyeCoordinates(windowCoord);
+    vec4 screenCoord = vec4(screenCoordinateXY, depthOrLogDepth, 1.0);
+    vec4 eyeCoordinate = czm_screenToEyeCoordinates(screenCoord);
 #endif
     return eyeCoordinate;
 }
+
+/**
+ * Transforms a position given as window x/y and a depth or a log depth from window to eye coordinates.
+ * This function produces more accurate results for window positions with log depth than
+ * conventionally unpacking the log depth using czm_reverseLogDepth and using the standard version
+ * of czm_windowToEyeCoordinates.
+ *
+ * @name czm_windowToEyeCoordinates
+ * @glslFunction
+ *
+ * @param {vec2} fragmentCoordinateXY The XY position in window coordinates to transform.
+ * @param {float} depthOrLogDepth A depth or log depth for the fragment.
+ *
+ * @see czm_modelToWindowCoordinates
+ * @see czm_eyeToWindowCoordinates
+ * @see czm_inverseProjection
+ * @see czm_viewport
+ * @see czm_viewportTransformation
+ *
+ * @returns {vec4} The transformed position in eye coordinates.
+ */
+vec4 czm_windowToEyeCoordinates(vec2 fragmentCoordinateXY, float depthOrLogDepth)
+{
+    vec2 screenCoordXY = (fragmentCoordinateXY.xy - czm_viewport.xy) / czm_viewport.zw;
+    return czm_screenToEyeCoordinates(screenCoordXY, depthOrLogDepth);
+}

package/Source/Shaders/Builtin/Functions/windowToEyeCoordinates.js

@@ -1,39 +1,14 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "/**\n\
- * Transforms a position from window to eye coordinates.\n\
- * The transform from window to normalized device coordinates is done using components\n\
- * of (@link czm_viewport} and {@link czm_viewportTransformation} instead of calculating\n\
- * the inverse of <code>czm_viewportTransformation</code>. The transformation from\n\
- * normalized device coordinates to clip coordinates is done using <code>fragmentCoordinate.w</code>,\n\
- * which is expected to be the scalar used in the perspective divide. The transformation\n\
- * from clip to eye coordinates is done using {@link czm_inverseProjection}.\n\
- *\n\
- * @name czm_windowToEyeCoordinates\n\
- * @glslFunction\n\
- *\n\
- * @param {vec4} fragmentCoordinate The position in window coordinates to transform.\n\
- *\n\
- * @returns {vec4} The transformed position in eye coordinates.\n\
- *\n\
- * @see czm_modelToWindowCoordinates\n\
- * @see czm_eyeToWindowCoordinates\n\
- * @see czm_inverseProjection\n\
- * @see czm_viewport\n\
- * @see czm_viewportTransformation\n\
- *\n\
- * @example\n\
- * vec4 positionEC = czm_windowToEyeCoordinates(gl_FragCoord);\n\
- */\n\
-vec4 czm_windowToEyeCoordinates(vec4 fragmentCoordinate)\n\
+export default "vec4 czm_screenToEyeCoordinates(vec4 screenCoordinate)\n\
 {\n\
     // Reconstruct NDC coordinates\n\
-    float x = 2.0 * (fragmentCoordinate.x - czm_viewport.x) / czm_viewport.z - 1.0;\n\
-    float y = 2.0 * (fragmentCoordinate.y - czm_viewport.y) / czm_viewport.w - 1.0;\n\
-    float z = (fragmentCoordinate.z - czm_viewportTransformation[3][2]) / czm_viewportTransformation[2][2];\n\
+    float x = 2.0 * screenCoordinate.x - 1.0;\n\
+    float y = 2.0 * screenCoordinate.y - 1.0;\n\
+    float z = (screenCoordinate.z - czm_viewportTransformation[3][2]) / czm_viewportTransformation[2][2];\n\
     vec4 q = vec4(x, y, z, 1.0);\n\
 \n\
     // Reverse the perspective division to obtain clip coordinates.\n\
-    q /= fragmentCoordinate.w;\n\
+    q /= screenCoordinate.w;\n\
 \n\
     // Reverse the projection transformation to obtain eye coordinates.\n\
     if (!(czm_inverseProjection == mat4(0.0))) // IE and Edge sometimes do something weird with != between mat4s\n\
@@ -60,16 +35,20 @@ vec4 czm_windowToEyeCoordinates(vec4 fragmentCoordinate)\n\
 }\n\
 \n\
 /**\n\
- * Transforms a position given as window x/y and a depth or a log depth from window to eye coordinates.\n\
- * This function produces more accurate results for window positions with log depth than\n\
- * conventionally unpacking the log depth using czm_reverseLogDepth and using the standard version\n\
- * of czm_windowToEyeCoordinates.\n\
+ * Transforms a position from window to eye coordinates.\n\
+ * The transform from window to normalized device coordinates is done using components\n\
+ * of (@link czm_viewport} and {@link czm_viewportTransformation} instead of calculating\n\
+ * the inverse of <code>czm_viewportTransformation</code>. The transformation from\n\
+ * normalized device coordinates to clip coordinates is done using <code>fragmentCoordinate.w</code>,\n\
+ * which is expected to be the scalar used in the perspective divide. The transformation\n\
+ * from clip to eye coordinates is done using {@link czm_inverseProjection}.\n\
  *\n\
  * @name czm_windowToEyeCoordinates\n\
  * @glslFunction\n\
  *\n\
- * @param {vec2} fragmentCoordinateXY The XY position in window coordinates to transform.\n\
- * @param {float} depthOrLogDepth A depth or log depth for the fragment.\n\
+ * @param {vec4} fragmentCoordinate The position in window coordinates to transform.\n\
+ *\n\
+ * @returns {vec4} The transformed position in eye coordinates.\n\
  *\n\
  * @see czm_modelToWindowCoordinates\n\
  * @see czm_eyeToWindowCoordinates\n\
@@ -77,25 +56,58 @@ vec4 czm_windowToEyeCoordinates(vec4 fragmentCoordinate)\n\
  * @see czm_viewport\n\
  * @see czm_viewportTransformation\n\
  *\n\
- * @returns {vec4} The transformed position in eye coordinates.\n\
+ * @example\n\
+ * vec4 positionEC = czm_windowToEyeCoordinates(gl_FragCoord);\n\
  */\n\
-vec4 czm_windowToEyeCoordinates(vec2 fragmentCoordinateXY, float depthOrLogDepth)\n\
+vec4 czm_windowToEyeCoordinates(vec4 fragmentCoordinate)\n\
+{\n\
+    vec2 screenCoordXY = (fragmentCoordinate.xy - czm_viewport.xy) / czm_viewport.zw;\n\
+    return czm_screenToEyeCoordinates(vec4(screenCoordXY, fragmentCoordinate.zw));\n\
+}\n\
+\n\
+vec4 czm_screenToEyeCoordinates(vec2 screenCoordinateXY, float depthOrLogDepth)\n\
 {\n\
     // See reverseLogDepth.glsl. This is separate to re-use the pow.\n\
-#ifdef LOG_DEPTH\n\
+#if defined(LOG_DEPTH) || defined(LOG_DEPTH_READ_ONLY)\n\
     float near = czm_currentFrustum.x;\n\
     float far = czm_currentFrustum.y;\n\
     float log2Depth = depthOrLogDepth * czm_log2FarDepthFromNearPlusOne;\n\
     float depthFromNear = pow(2.0, log2Depth) - 1.0;\n\
     float depthFromCamera = depthFromNear + near;\n\
-    vec4 windowCoord = vec4(fragmentCoordinateXY, far * (1.0 - near / depthFromCamera) / (far - near), 1.0);\n\
-    vec4 eyeCoordinate = czm_windowToEyeCoordinates(windowCoord);\n\
+    vec4 screenCoord = vec4(screenCoordinateXY, far * (1.0 - near / depthFromCamera) / (far - near), 1.0);\n\
+    vec4 eyeCoordinate = czm_screenToEyeCoordinates(screenCoord);\n\
     eyeCoordinate.w = 1.0 / depthFromCamera; // Better precision\n\
     return eyeCoordinate;\n\
 #else\n\
-    vec4 windowCoord = vec4(fragmentCoordinateXY, depthOrLogDepth, 1.0);\n\
-    vec4 eyeCoordinate = czm_windowToEyeCoordinates(windowCoord);\n\
+    vec4 screenCoord = vec4(screenCoordinateXY, depthOrLogDepth, 1.0);\n\
+    vec4 eyeCoordinate = czm_screenToEyeCoordinates(screenCoord);\n\
 #endif\n\
     return eyeCoordinate;\n\
 }\n\
+\n\
+/**\n\
+ * Transforms a position given as window x/y and a depth or a log depth from window to eye coordinates.\n\
+ * This function produces more accurate results for window positions with log depth than\n\
+ * conventionally unpacking the log depth using czm_reverseLogDepth and using the standard version\n\
+ * of czm_windowToEyeCoordinates.\n\
+ *\n\
+ * @name czm_windowToEyeCoordinates\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {vec2} fragmentCoordinateXY The XY position in window coordinates to transform.\n\
+ * @param {float} depthOrLogDepth A depth or log depth for the fragment.\n\
+ *\n\
+ * @see czm_modelToWindowCoordinates\n\
+ * @see czm_eyeToWindowCoordinates\n\
+ * @see czm_inverseProjection\n\
+ * @see czm_viewport\n\
+ * @see czm_viewportTransformation\n\
+ *\n\
+ * @returns {vec4} The transformed position in eye coordinates.\n\
+ */\n\
+vec4 czm_windowToEyeCoordinates(vec2 fragmentCoordinateXY, float depthOrLogDepth)\n\
+{\n\
+    vec2 screenCoordXY = (fragmentCoordinateXY.xy - czm_viewport.xy) / czm_viewport.zw;\n\
+    return czm_screenToEyeCoordinates(screenCoordXY, depthOrLogDepth);\n\
+}\n\
 ";

package/Source/Shaders/GlobeFS.glsl

@@ -102,6 +102,7 @@ uniform vec4 u_undergroundColorAlphaByDistance;
 
 #ifdef ENABLE_VERTEX_LIGHTING
 uniform float u_lambertDiffuseMultiplier;
+uniform float u_vertexShadowDarkness;
 #endif
 
 varying vec3 v_positionMC;
@@ -405,7 +406,7 @@ void main()
 #endif
 
 #ifdef ENABLE_VERTEX_LIGHTING
-    float diffuseIntensity = clamp(czm_getLambertDiffuse(czm_lightDirectionEC, normalize(v_normalEC)) * u_lambertDiffuseMultiplier + 0.3, 0.0, 1.0);
+    float diffuseIntensity = clamp(czm_getLambertDiffuse(czm_lightDirectionEC, normalize(v_normalEC)) * u_lambertDiffuseMultiplier + u_vertexShadowDarkness, 0.0, 1.0);
     vec4 finalColor = vec4(color.rgb * czm_lightColor * diffuseIntensity, color.a);
 #elif defined(ENABLE_DAYNIGHT_SHADING)
     float diffuseIntensity = clamp(czm_getLambertDiffuse(czm_lightDirectionEC, normalEC) * 5.0 + 0.3, 0.0, 1.0);

package/Source/Shaders/GlobeFS.js

@@ -103,6 +103,7 @@ uniform vec4 u_undergroundColorAlphaByDistance;\n\
 \n\
 #ifdef ENABLE_VERTEX_LIGHTING\n\
 uniform float u_lambertDiffuseMultiplier;\n\
+uniform float u_vertexShadowDarkness;\n\
 #endif\n\
 \n\
 varying vec3 v_positionMC;\n\
@@ -406,7 +407,7 @@ void main()\n\
 #endif\n\
 \n\
 #ifdef ENABLE_VERTEX_LIGHTING\n\
-    float diffuseIntensity = clamp(czm_getLambertDiffuse(czm_lightDirectionEC, normalize(v_normalEC)) * u_lambertDiffuseMultiplier + 0.3, 0.0, 1.0);\n\
+    float diffuseIntensity = clamp(czm_getLambertDiffuse(czm_lightDirectionEC, normalize(v_normalEC)) * u_lambertDiffuseMultiplier + u_vertexShadowDarkness, 0.0, 1.0);\n\
     vec4 finalColor = vec4(color.rgb * czm_lightColor * diffuseIntensity, color.a);\n\
 #elif defined(ENABLE_DAYNIGHT_SHADING)\n\
     float diffuseIntensity = clamp(czm_getLambertDiffuse(czm_lightDirectionEC, normalEC) * 5.0 + 0.3, 0.0, 1.0);\n\

package/Source/Shaders/PointPrimitiveCollectionVS.glsl

@@ -28,8 +28,6 @@ void main()
     float outlinePercent = outlineWidthBothSides / totalSize;
     // Scale in response to browser-zoom.
     totalSize *= czm_pixelRatio;
-    // Add padding for anti-aliasing on both sides.
-    totalSize += 3.0;
 
     float temp = compressedAttribute1.x * SHIFT_RIGHT8;
     float show = floor(temp);
@@ -111,6 +109,11 @@ void main()
 #ifdef EYE_DISTANCE_SCALING
     totalSize *= czm_nearFarScalar(scaleByDistance, lengthSq);
 #endif
+    if (totalSize > 0.0) {
+        // Add padding for anti-aliasing on both sides.
+        totalSize += 3.0;
+    }
+
     // Clamp to max point size.
     totalSize = min(totalSize, u_maxTotalPointSize);
     // If size is too small, push vertex behind near plane for clipping.

package/Source/Shaders/PointPrimitiveCollectionVS.js

@@ -29,8 +29,6 @@ void main()\n\
     float outlinePercent = outlineWidthBothSides / totalSize;\n\
     // Scale in response to browser-zoom.\n\
     totalSize *= czm_pixelRatio;\n\
-    // Add padding for anti-aliasing on both sides.\n\
-    totalSize += 3.0;\n\
 \n\
     float temp = compressedAttribute1.x * SHIFT_RIGHT8;\n\
     float show = floor(temp);\n\
@@ -112,6 +110,11 @@ void main()\n\
 #ifdef EYE_DISTANCE_SCALING\n\
     totalSize *= czm_nearFarScalar(scaleByDistance, lengthSq);\n\
 #endif\n\
+    if (totalSize > 0.0) {\n\
+        // Add padding for anti-aliasing on both sides.\n\
+        totalSize += 3.0;\n\
+    }\n\
+\n\
     // Clamp to max point size.\n\
     totalSize = min(totalSize, u_maxTotalPointSize);\n\
     // If size is too small, push vertex behind near plane for clipping.\n\

package/Source/Shaders/Voxels/IntersectBox.glsl

@@ -0,0 +1,79 @@
+// See IntersectionUtils.glsl for the definitions of Ray and NO_HIT
+
+/* Box defines (set in Scene/VoxelBoxShape.js)
+#define BOX_INTERSECTION_INDEX ### // always 0
+#define BOX_HAS_RENDER_BOUNDS
+#define BOX_IS_2D
+*/
+
+#if defined(BOX_HAS_RENDER_BOUNDS)
+    #if defined(BOX_IS_2D)
+        // This matrix bakes in an axis conversion so that the math works for XY plane.
+        uniform mat4 u_boxUvToRenderBoundsTransform;
+    #else
+        // Similar to u_boxTransformUvToBounds but fewer instructions needed.
+        uniform vec3 u_boxUvToRenderBoundsScale;
+        uniform vec3 u_boxUvToRenderBoundsTranslate;
+    #endif
+#endif
+
+vec2 intersectUnitCube(Ray ray) // Unit cube from [-1, +1]
+{
+    vec3 o = ray.pos;
+    vec3 d = ray.dir;
+
+    vec3 dInv = 1.0 / d;
+    vec3 od = -o * dInv;
+    vec3 t0 = od - dInv;
+    vec3 t1 = od + dInv;
+    vec3 m0 = min(t0, t1);
+    vec3 m1 = max(t0, t1);
+    float tMin = max(max(m0.x, m0.y), m0.z);
+    float tMax = min(min(m1.x, m1.y), m1.z);
+
+    if (tMin >= tMax) {
+        return vec2(NO_HIT);
+    }
+
+    return vec2(tMin, tMax);
+}
+
+vec2 intersectUnitSquare(Ray ray) // Unit square from [-1, +1]
+{
+    vec3 o = ray.pos;
+    vec3 d = ray.dir;
+
+    float t = -o.z / d.z;
+    vec2 planePos = o.xy + d.xy * t;
+    if (any(greaterThan(abs(planePos), vec2(1.0)))) {
+        return vec2(NO_HIT);
+    }
+
+    return vec2(t, t);
+}
+
+void intersectShape(Ray ray, inout Intersections ix)
+{
+    #if defined(BOX_HAS_RENDER_BOUNDS)
+        #if defined(BOX_IS_2D)
+            // Transform the ray into unit square space on Z plane
+            // This matrix bakes in an axis conversion so that the math works for XY plane.
+            ray.pos = vec3(u_boxUvToRenderBoundsTransform * vec4(ray.pos, 1.0));
+            ray.dir = vec3(u_boxUvToRenderBoundsTransform * vec4(ray.dir, 0.0));
+            vec2 entryExit = intersectUnitSquare(ray);
+        #else
+            // Transform the ray into unit cube space
+            ray.pos = ray.pos * u_boxUvToRenderBoundsScale + u_boxUvToRenderBoundsTranslate;
+            ray.dir *= u_boxUvToRenderBoundsScale;
+            vec2 entryExit = intersectUnitCube(ray);
+        #endif
+    #else
+        // Position is converted from [0,1] to [-1,+1] because shape intersections assume unit space is [-1,+1].
+        // Direction is scaled as well to be in sync with position.
+        ray.pos = ray.pos * 2.0 - 1.0;
+        ray.dir = ray.dir * 2.0;
+        vec2 entryExit = intersectUnitCube(ray);
+    #endif
+
+    setIntersectionPair(ix, BOX_INTERSECTION_INDEX, entryExit);
+}

package/Source/Shaders/Voxels/IntersectBox.js

@@ -0,0 +1,81 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// See IntersectionUtils.glsl for the definitions of Ray and NO_HIT\n\
+\n\
+/* Box defines (set in Scene/VoxelBoxShape.js)\n\
+#define BOX_INTERSECTION_INDEX ### // always 0\n\
+#define BOX_HAS_RENDER_BOUNDS\n\
+#define BOX_IS_2D\n\
+*/\n\
+\n\
+#if defined(BOX_HAS_RENDER_BOUNDS)\n\
+    #if defined(BOX_IS_2D)\n\
+        // This matrix bakes in an axis conversion so that the math works for XY plane.\n\
+        uniform mat4 u_boxUvToRenderBoundsTransform;\n\
+    #else\n\
+        // Similar to u_boxTransformUvToBounds but fewer instructions needed.\n\
+        uniform vec3 u_boxUvToRenderBoundsScale;\n\
+        uniform vec3 u_boxUvToRenderBoundsTranslate;\n\
+    #endif\n\
+#endif\n\
+\n\
+vec2 intersectUnitCube(Ray ray) // Unit cube from [-1, +1]\n\
+{\n\
+    vec3 o = ray.pos;\n\
+    vec3 d = ray.dir;\n\
+\n\
+    vec3 dInv = 1.0 / d;\n\
+    vec3 od = -o * dInv;\n\
+    vec3 t0 = od - dInv;\n\
+    vec3 t1 = od + dInv;\n\
+    vec3 m0 = min(t0, t1);\n\
+    vec3 m1 = max(t0, t1);\n\
+    float tMin = max(max(m0.x, m0.y), m0.z);\n\
+    float tMax = min(min(m1.x, m1.y), m1.z);\n\
+\n\
+    if (tMin >= tMax) {\n\
+        return vec2(NO_HIT);\n\
+    }\n\
+\n\
+    return vec2(tMin, tMax);\n\
+}\n\
+\n\
+vec2 intersectUnitSquare(Ray ray) // Unit square from [-1, +1]\n\
+{\n\
+    vec3 o = ray.pos;\n\
+    vec3 d = ray.dir;\n\
+\n\
+    float t = -o.z / d.z;\n\
+    vec2 planePos = o.xy + d.xy * t;\n\
+    if (any(greaterThan(abs(planePos), vec2(1.0)))) {\n\
+        return vec2(NO_HIT);\n\
+    }\n\
+\n\
+    return vec2(t, t);\n\
+}\n\
+\n\
+void intersectShape(Ray ray, inout Intersections ix)\n\
+{\n\
+    #if defined(BOX_HAS_RENDER_BOUNDS)\n\
+        #if defined(BOX_IS_2D)\n\
+            // Transform the ray into unit square space on Z plane\n\
+            // This matrix bakes in an axis conversion so that the math works for XY plane.\n\
+            ray.pos = vec3(u_boxUvToRenderBoundsTransform * vec4(ray.pos, 1.0));\n\
+            ray.dir = vec3(u_boxUvToRenderBoundsTransform * vec4(ray.dir, 0.0));\n\
+            vec2 entryExit = intersectUnitSquare(ray);\n\
+        #else\n\
+            // Transform the ray into unit cube space\n\
+            ray.pos = ray.pos * u_boxUvToRenderBoundsScale + u_boxUvToRenderBoundsTranslate;\n\
+            ray.dir *= u_boxUvToRenderBoundsScale;\n\
+            vec2 entryExit = intersectUnitCube(ray);\n\
+        #endif\n\
+    #else\n\
+        // Position is converted from [0,1] to [-1,+1] because shape intersections assume unit space is [-1,+1].\n\
+        // Direction is scaled as well to be in sync with position.\n\
+        ray.pos = ray.pos * 2.0 - 1.0;\n\
+        ray.dir = ray.dir * 2.0;\n\
+        vec2 entryExit = intersectUnitCube(ray);\n\
+    #endif\n\
+\n\
+    setIntersectionPair(ix, BOX_INTERSECTION_INDEX, entryExit);\n\
+}\n\
+";

package/Source/Shaders/Voxels/IntersectClippingPlanes.glsl

@@ -0,0 +1,70 @@
+// See IntersectionUtils.glsl for the definitions of Ray, Intersections, INF_HIT,
+// NO_HIT, setIntersectionPair
+
+/* Clipping plane defines (set in Scene/VoxelRenderResources.js)
+#define CLIPPING_PLANES_UNION
+#define CLIPPING_PLANES_COUNT
+#define CLIPPING_PLANES_INTERSECTION_INDEX
+*/
+
+uniform sampler2D u_clippingPlanesTexture;
+uniform mat4 u_clippingPlanesMatrix;
+
+// Plane is in Hessian Normal Form
+vec2 intersectPlane(Ray ray, vec4 plane) {
+    vec3 o = ray.pos;
+    vec3 d = ray.dir;
+    vec3 n = plane.xyz; // normal
+    float w = plane.w; // -dot(pointOnPlane, normal)
+
+    float a = dot(o, n);
+    float b = dot(d, n);
+    float t = -(w + a) / b;
+
+    if (dot(d, n) > 0.0) {
+        return vec2(t, +INF_HIT);
+    } else {
+        return vec2(-INF_HIT, t);
+    }
+}
+
+void intersectClippingPlanes(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);
+        vec2 intersection = intersectPlane(ray, planeUv);
+        setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, intersection);
+    #elif defined(CLIPPING_PLANES_UNION)
+        float minPositiveT = +INF_HIT;
+        float maxNegativeT = -INF_HIT;
+        for (int i = 0; i < CLIPPING_PLANES_COUNT; i++) {
+            vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i, u_clippingPlanesMatrix);
+            vec2 intersection = intersectPlane(ray, planeUv);
+            if (intersection.y == +INF_HIT) {
+                minPositiveT = min(minPositiveT, intersection.x);
+            } else {
+                maxNegativeT = max(maxNegativeT, intersection.y);
+            }
+        }
+        setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 0, vec2(-INF_HIT, maxNegativeT));
+        setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 1, vec2(minPositiveT, +INF_HIT));
+    #else // intersection
+        float maxPositiveT = -INF_HIT;
+        float minNegativeT = +INF_HIT;
+        for (int i = 0; i < CLIPPING_PLANES_COUNT; i++) {
+            vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i, u_clippingPlanesMatrix);
+            vec2 intersection = intersectPlane(ray, planeUv);
+            if (intersection.y == +INF_HIT) {
+                maxPositiveT = max(maxPositiveT, intersection.x);
+            } else {
+                minNegativeT = min(minNegativeT, intersection.y);
+            }
+        }
+        if (maxPositiveT < minNegativeT) {
+            setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, vec2(maxPositiveT, minNegativeT));
+        } else {
+            setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, vec2(NO_HIT));
+        }
+    #endif
+}

package/Source/Shaders/Voxels/IntersectClippingPlanes.js

@@ -0,0 +1,72 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// See IntersectionUtils.glsl for the definitions of Ray, Intersections, INF_HIT,\n\
+// NO_HIT, setIntersectionPair\n\
+\n\
+/* Clipping plane defines (set in Scene/VoxelRenderResources.js)\n\
+#define CLIPPING_PLANES_UNION\n\
+#define CLIPPING_PLANES_COUNT\n\
+#define CLIPPING_PLANES_INTERSECTION_INDEX\n\
+*/\n\
+\n\
+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\
+    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 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\
+}\n\
+\n\
+void intersectClippingPlanes(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\
+        vec2 intersection = intersectPlane(ray, planeUv);\n\
+        setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, intersection);\n\
+    #elif defined(CLIPPING_PLANES_UNION)\n\
+        float minPositiveT = +INF_HIT;\n\
+        float maxNegativeT = -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\
+            } else {\n\
+                maxNegativeT = max(maxNegativeT, intersection.y);\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\
+    #else // intersection\n\
+        float maxPositiveT = -INF_HIT;\n\
+        float minNegativeT = +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\
+            } else {\n\
+                minNegativeT = min(minNegativeT, intersection.y);\n\
+            }\n\
+        }\n\
+        if (maxPositiveT < minNegativeT) {\n\
+            setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, vec2(maxPositiveT, minNegativeT));\n\
+        } else {\n\
+            setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, vec2(NO_HIT));\n\
+        }\n\
+    #endif\n\
+}\n\
+";