@cesium/engine 1.0.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'
@@ -45,6 +46,12 @@ import czm_pbrParameters from './Structs/pbrParameters.js'
 import czm_ray from './Structs/ray.js'
 import czm_raySegment from './Structs/raySegment.js'
 import czm_shadowParameters from './Structs/shadowParameters.js'
+import czm_HSBToRGB from './Functions/HSBToRGB.js'
+import czm_HSLToRGB from './Functions/HSLToRGB.js'
+import czm_RGBToHSB from './Functions/RGBToHSB.js'
+import czm_RGBToHSL from './Functions/RGBToHSL.js'
+import czm_RGBToXYZ from './Functions/RGBToXYZ.js'
+import czm_XYZToRGB from './Functions/XYZToRGB.js'
 import czm_acesTonemapping from './Functions/acesTonemapping.js'
 import czm_alphaWeight from './Functions/alphaWeight.js'
 import czm_antialias from './Functions/antialias.js'
@@ -75,15 +82,13 @@ import czm_getDefaultMaterial from './Functions/getDefaultMaterial.js'
 import czm_getLambertDiffuse from './Functions/getLambertDiffuse.js'
 import czm_getSpecular from './Functions/getSpecular.js'
 import czm_getWaterNoise from './Functions/getWaterNoise.js'
-import czm_HSBToRGB from './Functions/HSBToRGB.js'
-import czm_HSLToRGB from './Functions/HSLToRGB.js'
 import czm_hue from './Functions/hue.js'
 import czm_inverseGamma from './Functions/inverseGamma.js'
 import czm_isEmpty from './Functions/isEmpty.js'
 import czm_isFull from './Functions/isFull.js'
 import czm_latitudeToWebMercatorFraction from './Functions/latitudeToWebMercatorFraction.js'
-import czm_linearToSrgb from './Functions/linearToSrgb.js'
 import czm_lineDistance from './Functions/lineDistance.js'
+import czm_linearToSrgb from './Functions/linearToSrgb.js'
 import czm_luminance from './Functions/luminance.js'
 import czm_metersPerPixel from './Functions/metersPerPixel.js'
 import czm_modelToWindowCoordinates from './Functions/modelToWindowCoordinates.js'
@@ -102,9 +107,6 @@ import czm_raySphereIntersectionInterval from './Functions/raySphereIntersection
 import czm_readDepth from './Functions/readDepth.js'
 import czm_readNonPerspective from './Functions/readNonPerspective.js'
 import czm_reverseLogDepth from './Functions/reverseLogDepth.js'
-import czm_RGBToHSB from './Functions/RGBToHSB.js'
-import czm_RGBToHSL from './Functions/RGBToHSL.js'
-import czm_RGBToXYZ from './Functions/RGBToXYZ.js'
 import czm_round from './Functions/round.js'
 import czm_sampleOctahedralProjection from './Functions/sampleOctahedralProjection.js'
 import czm_saturation from './Functions/saturation.js'
@@ -127,7 +129,6 @@ import czm_windowToEyeCoordinates from './Functions/windowToEyeCoordinates.js'
 import czm_writeDepthClamp from './Functions/writeDepthClamp.js'
 import czm_writeLogDepth from './Functions/writeLogDepth.js'
 import czm_writeNonPerspective from './Functions/writeNonPerspective.js'
-import czm_XYZToRGB from './Functions/XYZToRGB.js'
 
 export default {
     czm_degreesPerRadian : czm_degreesPerRadian,
@@ -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,
@@ -176,6 +178,12 @@ export default {
     czm_ray : czm_ray,
     czm_raySegment : czm_raySegment,
     czm_shadowParameters : czm_shadowParameters,
+    czm_HSBToRGB : czm_HSBToRGB,
+    czm_HSLToRGB : czm_HSLToRGB,
+    czm_RGBToHSB : czm_RGBToHSB,
+    czm_RGBToHSL : czm_RGBToHSL,
+    czm_RGBToXYZ : czm_RGBToXYZ,
+    czm_XYZToRGB : czm_XYZToRGB,
     czm_acesTonemapping : czm_acesTonemapping,
     czm_alphaWeight : czm_alphaWeight,
     czm_antialias : czm_antialias,
@@ -206,15 +214,13 @@ export default {
     czm_getLambertDiffuse : czm_getLambertDiffuse,
     czm_getSpecular : czm_getSpecular,
     czm_getWaterNoise : czm_getWaterNoise,
-    czm_HSBToRGB : czm_HSBToRGB,
-    czm_HSLToRGB : czm_HSLToRGB,
     czm_hue : czm_hue,
     czm_inverseGamma : czm_inverseGamma,
     czm_isEmpty : czm_isEmpty,
     czm_isFull : czm_isFull,
     czm_latitudeToWebMercatorFraction : czm_latitudeToWebMercatorFraction,
-    czm_linearToSrgb : czm_linearToSrgb,
     czm_lineDistance : czm_lineDistance,
+    czm_linearToSrgb : czm_linearToSrgb,
     czm_luminance : czm_luminance,
     czm_metersPerPixel : czm_metersPerPixel,
     czm_modelToWindowCoordinates : czm_modelToWindowCoordinates,
@@ -233,9 +239,6 @@ export default {
     czm_readDepth : czm_readDepth,
     czm_readNonPerspective : czm_readNonPerspective,
     czm_reverseLogDepth : czm_reverseLogDepth,
-    czm_RGBToHSB : czm_RGBToHSB,
-    czm_RGBToHSL : czm_RGBToHSL,
-    czm_RGBToXYZ : czm_RGBToXYZ,
     czm_round : czm_round,
     czm_sampleOctahedralProjection : czm_sampleOctahedralProjection,
     czm_saturation : czm_saturation,
@@ -257,6 +260,5 @@ export default {
     czm_windowToEyeCoordinates : czm_windowToEyeCoordinates,
     czm_writeDepthClamp : czm_writeDepthClamp,
     czm_writeLogDepth : czm_writeLogDepth,
-    czm_writeNonPerspective : czm_writeNonPerspective,
-    czm_XYZToRGB : czm_XYZToRGB
+    czm_writeNonPerspective : czm_writeNonPerspective
 };

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