@cesium/engine 1.0.0 → 2.0.0

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

@@ -1,9 +1,9 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "#ifdef LOG_DEPTH\n\
 // 1.0 at the near plane, increasing linearly from there.\n\
-varying float v_depthFromNearPlusOne;\n\
+out float v_depthFromNearPlusOne;\n\
 #ifdef SHADOW_MAP\n\
-varying vec3 v_logPositionEC;\n\
+out vec3 v_logPositionEC;\n\
 #endif\n\
 #endif\n\
 \n\

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/Builtin/Functions/writeDepthClamp.glsl

@@ -1,27 +1,24 @@
 // emulated noperspective
-#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)
-varying float v_WindowZ;
+#if !defined(LOG_DEPTH)
+in float v_WindowZ;
 #endif
 
 /**
  * Emulates GL_DEPTH_CLAMP. Clamps a fragment to the near and far plane
  * by writing the fragment's depth. See czm_depthClamp for more details.
- * <p>
- * The shader must enable the GL_EXT_frag_depth extension.
- * </p>
  *
  * @name czm_writeDepthClamp
  * @glslFunction
  *
  * @example
- * gl_FragColor = color;
+ * out_FragColor = color;
  * czm_writeDepthClamp();
  *
  * @see czm_depthClamp
  */
 void czm_writeDepthClamp()
 {
-#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)
-    gl_FragDepthEXT = clamp(v_WindowZ * gl_FragCoord.w, 0.0, 1.0);
+#if (!defined(LOG_DEPTH) && (__VERSION__ == 300 || defined(GL_EXT_frag_depth)))
+    gl_FragDepth = clamp(v_WindowZ * gl_FragCoord.w, 0.0, 1.0);
 #endif
 }

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

@@ -1,29 +1,26 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "// emulated noperspective\n\
-#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)\n\
-varying float v_WindowZ;\n\
+#if !defined(LOG_DEPTH)\n\
+in float v_WindowZ;\n\
 #endif\n\
 \n\
 /**\n\
  * Emulates GL_DEPTH_CLAMP. Clamps a fragment to the near and far plane\n\
  * by writing the fragment's depth. See czm_depthClamp for more details.\n\
- * <p>\n\
- * The shader must enable the GL_EXT_frag_depth extension.\n\
- * </p>\n\
  *\n\
  * @name czm_writeDepthClamp\n\
  * @glslFunction\n\
  *\n\
  * @example\n\
- * gl_FragColor = color;\n\
+ * out_FragColor = color;\n\
  * czm_writeDepthClamp();\n\
  *\n\
  * @see czm_depthClamp\n\
  */\n\
 void czm_writeDepthClamp()\n\
 {\n\
-#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)\n\
-    gl_FragDepthEXT = clamp(v_WindowZ * gl_FragCoord.w, 0.0, 1.0);\n\
+#if (!defined(LOG_DEPTH) && (__VERSION__ == 300 || defined(GL_EXT_frag_depth)))\n\
+    gl_FragDepth = clamp(v_WindowZ * gl_FragCoord.w, 0.0, 1.0);\n\
 #endif\n\
 }\n\
 ";

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

@@ -1,5 +1,5 @@
 #ifdef LOG_DEPTH
-varying float v_depthFromNearPlusOne;
+in float v_depthFromNearPlusOne;
 
 #ifdef POLYGON_OFFSET
 uniform vec2 u_polygonOffset;
@@ -27,7 +27,7 @@ uniform vec2 u_polygonOffset;
  */
 void czm_writeLogDepth(float depth)
 {
-#if defined(GL_EXT_frag_depth) && defined(LOG_DEPTH)
+#if (defined(LOG_DEPTH) && (__VERSION__ == 300 || defined(GL_EXT_frag_depth)))
     // Discard the vertex if it's not between the near and far planes.
     // We allow a bit of epsilon on the near plane comparison because a 1.0
     // from the vertex shader (indicating the vertex should be _on_ the near
@@ -41,8 +41,8 @@ void czm_writeLogDepth(float depth)
     float factor = u_polygonOffset[0];
     float units = u_polygonOffset[1];
 
-// If we can't compute derivatives, just leave out the factor I guess?
-#ifdef GL_OES_standard_derivatives
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))
+    // This factor doesn't work in IE 10
     if (factor != 0.0) {
         // m = sqrt(dZdX^2 + dZdY^2);
         float x = dFdx(depth);
@@ -56,11 +56,11 @@ void czm_writeLogDepth(float depth)
 
 #endif
 
-    gl_FragDepthEXT = log2(depth) * czm_oneOverLog2FarDepthFromNearPlusOne;
+    gl_FragDepth = log2(depth) * czm_oneOverLog2FarDepthFromNearPlusOne;
 
 #ifdef POLYGON_OFFSET
     // Apply the units after the log depth.
-    gl_FragDepthEXT += czm_epsilon7 * units;
+    gl_FragDepth += czm_epsilon7 * units;
 #endif
 
 #endif

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

@@ -1,6 +1,6 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "#ifdef LOG_DEPTH\n\
-varying float v_depthFromNearPlusOne;\n\
+in float v_depthFromNearPlusOne;\n\
 \n\
 #ifdef POLYGON_OFFSET\n\
 uniform vec2 u_polygonOffset;\n\
@@ -28,7 +28,7 @@ uniform vec2 u_polygonOffset;\n\
  */\n\
 void czm_writeLogDepth(float depth)\n\
 {\n\
-#if defined(GL_EXT_frag_depth) && defined(LOG_DEPTH)\n\
+#if (defined(LOG_DEPTH) && (__VERSION__ == 300 || defined(GL_EXT_frag_depth)))\n\
     // Discard the vertex if it's not between the near and far planes.\n\
     // We allow a bit of epsilon on the near plane comparison because a 1.0\n\
     // from the vertex shader (indicating the vertex should be _on_ the near\n\
@@ -42,8 +42,8 @@ void czm_writeLogDepth(float depth)\n\
     float factor = u_polygonOffset[0];\n\
     float units = u_polygonOffset[1];\n\
 \n\
-// If we can't compute derivatives, just leave out the factor I guess?\n\
-#ifdef GL_OES_standard_derivatives\n\
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))\n\
+    // This factor doesn't work in IE 10\n\
     if (factor != 0.0) {\n\
         // m = sqrt(dZdX^2 + dZdY^2);\n\
         float x = dFdx(depth);\n\
@@ -57,11 +57,11 @@ void czm_writeLogDepth(float depth)\n\
 \n\
 #endif\n\
 \n\
-    gl_FragDepthEXT = log2(depth) * czm_oneOverLog2FarDepthFromNearPlusOne;\n\
+    gl_FragDepth = log2(depth) * czm_oneOverLog2FarDepthFromNearPlusOne;\n\
 \n\
 #ifdef POLYGON_OFFSET\n\
     // Apply the units after the log depth.\n\
-    gl_FragDepthEXT += czm_epsilon7 * units;\n\
+    gl_FragDepth += czm_epsilon7 * units;\n\
 #endif\n\
 \n\
 #endif\n\

package/Source/Shaders/CloudCollectionFS.glsl

@@ -1,11 +1,11 @@
 uniform sampler2D u_noiseTexture;
 uniform vec3 u_noiseTextureDimensions;
 uniform float u_noiseDetail;
-varying vec2 v_offset;
-varying vec3 v_maximumSize;
-varying vec4 v_color;
-varying float v_slice;
-varying float v_brightness;
+in vec2 v_offset;
+in vec3 v_maximumSize;
+in vec4 v_color;
+in float v_slice;
+in float v_brightness;
 
 float wrap(float value, float rangeLength) {
     if(value < 0.0) {
@@ -22,15 +22,14 @@ vec3 wrapVec(vec3 value, float rangeLength) {
                 wrap(value.z, rangeLength));
 }
 
-float textureSliceWidth = u_noiseTextureDimensions.x;
-float noiseTextureRows = u_noiseTextureDimensions.y;
-float inverseNoiseTextureRows = u_noiseTextureDimensions.z;
-
-float textureSliceWidthSquared = textureSliceWidth * textureSliceWidth;
-vec2 inverseNoiseTextureDimensions = vec2(noiseTextureRows / textureSliceWidthSquared,
-                                          inverseNoiseTextureRows / textureSliceWidth);
-
 vec2 voxelToUV(vec3 voxelIndex) {
+    float textureSliceWidth = u_noiseTextureDimensions.x;
+    float noiseTextureRows = u_noiseTextureDimensions.y;
+    float inverseNoiseTextureRows = u_noiseTextureDimensions.z;
+
+    float textureSliceWidthSquared = textureSliceWidth * textureSliceWidth;
+    vec2 inverseNoiseTextureDimensions = vec2(noiseTextureRows / textureSliceWidthSquared,
+                                            inverseNoiseTextureRows / textureSliceWidth);
     vec3 wrappedIndex = wrapVec(voxelIndex, textureSliceWidth);
     float column = mod(wrappedIndex.z, textureSliceWidth * inverseNoiseTextureRows);
     float row = floor(wrappedIndex.z / textureSliceWidth * noiseTextureRows);
@@ -44,12 +43,13 @@ vec2 voxelToUV(vec3 voxelIndex) {
 vec4 lerpSamplesX(vec3 voxelIndex, float x) {
     vec2 uv0 = voxelToUV(voxelIndex);
     vec2 uv1 = voxelToUV(voxelIndex + vec3(1.0, 0.0, 0.0));
-    vec4 sample0 = texture2D(u_noiseTexture, uv0);
-    vec4 sample1 = texture2D(u_noiseTexture, uv1);
+    vec4 sample0 = texture(u_noiseTexture, uv0);
+    vec4 sample1 = texture(u_noiseTexture, uv1);
     return mix(sample0, sample1, x);
 }
 
 vec4 sampleNoiseTexture(vec3 position) {
+    float textureSliceWidth = u_noiseTextureDimensions.x;
     vec3 recenteredPos = position + vec3(textureSliceWidth / 2.0);
     vec3 lerpValue = fract(recenteredPos);
     vec3 voxelIndex = floor(recenteredPos);
@@ -231,7 +231,7 @@ vec4 drawCloud(vec3 rayOrigin, vec3 rayDir, vec3 cloudCenter, vec3 cloudScale, f
 
 void main() {
 #ifdef DEBUG_BILLBOARDS
-    gl_FragColor = vec4(0.0, 0.5, 0.5, 1.0);
+    out_FragColor = vec4(0.0, 0.5, 0.5, 1.0);
 #endif
     // To avoid calculations with high values,
     // we raycast from an arbitrarily smaller space.
@@ -248,7 +248,7 @@ void main() {
     vec3 point, normal;
     if(intersectEllipsoid(rayOrigin, rayDir, ellipsoidCenter, ellipsoidScale, v_slice,
                           point, normal)) {
-        gl_FragColor = v_brightness * v_color;
+        out_FragColor = v_brightness * v_color;
     }
 #else
 #ifndef DEBUG_BILLBOARDS
@@ -257,7 +257,7 @@ void main() {
     if(cloud.w < 0.01) {
         discard;
     }
-    gl_FragColor = cloud;
+    out_FragColor = cloud;
 #endif
 #endif
 }

package/Source/Shaders/CloudCollectionFS.js

@@ -2,11 +2,11 @@
 export default "uniform sampler2D u_noiseTexture;\n\
 uniform vec3 u_noiseTextureDimensions;\n\
 uniform float u_noiseDetail;\n\
-varying vec2 v_offset;\n\
-varying vec3 v_maximumSize;\n\
-varying vec4 v_color;\n\
-varying float v_slice;\n\
-varying float v_brightness;\n\
+in vec2 v_offset;\n\
+in vec3 v_maximumSize;\n\
+in vec4 v_color;\n\
+in float v_slice;\n\
+in float v_brightness;\n\
 \n\
 float wrap(float value, float rangeLength) {\n\
     if(value < 0.0) {\n\
@@ -23,15 +23,14 @@ vec3 wrapVec(vec3 value, float rangeLength) {\n\
                 wrap(value.z, rangeLength));\n\
 }\n\
 \n\
-float textureSliceWidth = u_noiseTextureDimensions.x;\n\
-float noiseTextureRows = u_noiseTextureDimensions.y;\n\
-float inverseNoiseTextureRows = u_noiseTextureDimensions.z;\n\
-\n\
-float textureSliceWidthSquared = textureSliceWidth * textureSliceWidth;\n\
-vec2 inverseNoiseTextureDimensions = vec2(noiseTextureRows / textureSliceWidthSquared,\n\
-                                          inverseNoiseTextureRows / textureSliceWidth);\n\
-\n\
 vec2 voxelToUV(vec3 voxelIndex) {\n\
+    float textureSliceWidth = u_noiseTextureDimensions.x;\n\
+    float noiseTextureRows = u_noiseTextureDimensions.y;\n\
+    float inverseNoiseTextureRows = u_noiseTextureDimensions.z;\n\
+\n\
+    float textureSliceWidthSquared = textureSliceWidth * textureSliceWidth;\n\
+    vec2 inverseNoiseTextureDimensions = vec2(noiseTextureRows / textureSliceWidthSquared,\n\
+                                            inverseNoiseTextureRows / textureSliceWidth);\n\
     vec3 wrappedIndex = wrapVec(voxelIndex, textureSliceWidth);\n\
     float column = mod(wrappedIndex.z, textureSliceWidth * inverseNoiseTextureRows);\n\
     float row = floor(wrappedIndex.z / textureSliceWidth * noiseTextureRows);\n\
@@ -45,12 +44,13 @@ vec2 voxelToUV(vec3 voxelIndex) {\n\
 vec4 lerpSamplesX(vec3 voxelIndex, float x) {\n\
     vec2 uv0 = voxelToUV(voxelIndex);\n\
     vec2 uv1 = voxelToUV(voxelIndex + vec3(1.0, 0.0, 0.0));\n\
-    vec4 sample0 = texture2D(u_noiseTexture, uv0);\n\
-    vec4 sample1 = texture2D(u_noiseTexture, uv1);\n\
+    vec4 sample0 = texture(u_noiseTexture, uv0);\n\
+    vec4 sample1 = texture(u_noiseTexture, uv1);\n\
     return mix(sample0, sample1, x);\n\
 }\n\
 \n\
 vec4 sampleNoiseTexture(vec3 position) {\n\
+    float textureSliceWidth = u_noiseTextureDimensions.x;\n\
     vec3 recenteredPos = position + vec3(textureSliceWidth / 2.0);\n\
     vec3 lerpValue = fract(recenteredPos);\n\
     vec3 voxelIndex = floor(recenteredPos);\n\
@@ -232,7 +232,7 @@ vec4 drawCloud(vec3 rayOrigin, vec3 rayDir, vec3 cloudCenter, vec3 cloudScale, f
 \n\
 void main() {\n\
 #ifdef DEBUG_BILLBOARDS\n\
-    gl_FragColor = vec4(0.0, 0.5, 0.5, 1.0);\n\
+    out_FragColor = vec4(0.0, 0.5, 0.5, 1.0);\n\
 #endif\n\
     // To avoid calculations with high values,\n\
     // we raycast from an arbitrarily smaller space.\n\
@@ -249,7 +249,7 @@ void main() {\n\
     vec3 point, normal;\n\
     if(intersectEllipsoid(rayOrigin, rayDir, ellipsoidCenter, ellipsoidScale, v_slice,\n\
                           point, normal)) {\n\
-        gl_FragColor = v_brightness * v_color;\n\
+        out_FragColor = v_brightness * v_color;\n\
     }\n\
 #else\n\
 #ifndef DEBUG_BILLBOARDS\n\
@@ -258,7 +258,7 @@ void main() {\n\
     if(cloud.w < 0.01) {\n\
         discard;\n\
     }\n\
-    gl_FragColor = cloud;\n\
+    out_FragColor = cloud;\n\
 #endif\n\
 #endif\n\
 }\n\

package/Source/Shaders/CloudCollectionVS.glsl

@@ -1,17 +1,17 @@
 #ifdef INSTANCED
-attribute vec2 direction;
+in vec2 direction;
 #endif
-attribute vec4 positionHighAndScaleX;
-attribute vec4 positionLowAndScaleY;
-attribute vec4 packedAttribute0;
-attribute vec4 packedAttribute1;
-attribute vec4 color;
+in vec4 positionHighAndScaleX;
+in vec4 positionLowAndScaleY;
+in vec4 packedAttribute0;
+in vec4 packedAttribute1;
+in vec4 color;
 
-varying vec2 v_offset;
-varying vec3 v_maximumSize;
-varying vec4 v_color;
-varying float v_slice;
-varying float v_brightness;
+out vec2 v_offset;
+out vec3 v_maximumSize;
+out vec4 v_color;
+out float v_slice;
+out float v_brightness;
 
 void main() {
     // Unpack attributes.

package/Source/Shaders/CloudCollectionVS.js

@@ -1,18 +1,18 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "#ifdef INSTANCED\n\
-attribute vec2 direction;\n\
+in vec2 direction;\n\
 #endif\n\
-attribute vec4 positionHighAndScaleX;\n\
-attribute vec4 positionLowAndScaleY;\n\
-attribute vec4 packedAttribute0;\n\
-attribute vec4 packedAttribute1;\n\
-attribute vec4 color;\n\
+in vec4 positionHighAndScaleX;\n\
+in vec4 positionLowAndScaleY;\n\
+in vec4 packedAttribute0;\n\
+in vec4 packedAttribute1;\n\
+in vec4 color;\n\
 \n\
-varying vec2 v_offset;\n\
-varying vec3 v_maximumSize;\n\
-varying vec4 v_color;\n\
-varying float v_slice;\n\
-varying float v_brightness;\n\
+out vec2 v_offset;\n\
+out vec3 v_maximumSize;\n\
+out vec4 v_color;\n\
+out float v_slice;\n\
+out float v_brightness;\n\
 \n\
 void main() {\n\
     // Unpack attributes.\n\