cesium 0.15.0 → 0.16.0

data/app/assets/javascripts/Shaders/CentralBodyFS.glsl

@@ -1,7 +1,4 @@
 //#define SHOW_TILE_BOUNDARIES
-//#define SHOW_TEXTURE_BOUNDARIES
-
-uniform float u_morphTime;
 
 #if TEXTURE_UNITS > 0
 uniform sampler2D u_dayTextures[TEXTURE_UNITS];
@@ -42,18 +39,13 @@ vec3 sampleAndBlend(
     float textureSaturation,
     float textureOneOverGamma)
 {
-    // This crazy step stuff sets the alpha to 0.0 if this following condition is true:
-    //    tileTextureCoordinates.s < textureCoordinateExtent.s ||
-    //    tileTextureCoordinates.s > textureCoordinateExtent.p ||
-    //    tileTextureCoordinates.t < textureCoordinateExtent.t ||
-    //    tileTextureCoordinates.t > textureCoordinateExtent.q
-    // In other words, the alpha is zero if the fragment is outside the extent
-    // covered by this texture.  Would an actual 'if' yield better performance?
-    vec2 alphaMultiplier = step(textureCoordinateExtent.st, tileTextureCoordinates); 
-    textureAlpha = textureAlpha * alphaMultiplier.x * alphaMultiplier.y;
-    
-    alphaMultiplier = step(vec2(0.0), textureCoordinateExtent.pq - tileTextureCoordinates);
-    textureAlpha = textureAlpha * alphaMultiplier.x * alphaMultiplier.y;
+    if (tileTextureCoordinates.s < textureCoordinateExtent.s ||
+        tileTextureCoordinates.s > textureCoordinateExtent.p ||
+        tileTextureCoordinates.t < textureCoordinateExtent.t ||
+        tileTextureCoordinates.t > textureCoordinateExtent.q)
+    {
+        return previousColor;
+    }
     
     vec2 translation = textureCoordinateTranslationAndScale.xy;
     vec2 scale = textureCoordinateTranslationAndScale.zw;
@@ -82,16 +74,11 @@ vec3 sampleAndBlend(
     color = pow(color, vec3(textureOneOverGamma));
 #endif
 
-#ifdef SHOW_TEXTURE_BOUNDARIES
-    if (textureCoordinates.x < (1.0/256.0) || textureCoordinates.x > (255.0/256.0) ||
-        textureCoordinates.y < (1.0/256.0) || textureCoordinates.y > (255.0/256.0))
-    {
-        color = vec3(1.0);
-        alpha = 1.0;
-    }
+#ifdef APPLY_ALPHA
+    alpha *= textureAlpha;
 #endif
 
-    return mix(previousColor, color, alpha * textureAlpha);
+    return mix(previousColor, color, alpha);
 }
 
 vec3 computeDayColor(vec3 initialColor, vec2 textureCoordinates);
@@ -132,7 +119,7 @@ void main()
         vec2 ellipsoidTextureCoordinates = czm_ellipsoidWgs84TextureCoordinates(normalMC);
         vec2 ellipsoidFlippedTextureCoordinates = czm_ellipsoidWgs84TextureCoordinates(normalMC.zyx);
 
-        vec2 textureCoordinates = mix(ellipsoidTextureCoordinates, ellipsoidFlippedTextureCoordinates, u_morphTime * smoothstep(0.9, 0.95, normalMC.z));
+        vec2 textureCoordinates = mix(ellipsoidTextureCoordinates, ellipsoidFlippedTextureCoordinates, czm_morphTime * smoothstep(0.9, 0.95, normalMC.z));
 
         color = computeWaterColor(v_positionEC, textureCoordinates, enuToEye, startDayColor, mask);
     }

data/app/assets/javascripts/Shaders/CentralBodyFS.js

@@ -3,9 +3,6 @@
 define(function() {
 "use strict";
 return "//#define SHOW_TILE_BOUNDARIES\n\
-//#define SHOW_TEXTURE_BOUNDARIES\n\
-\n\
-uniform float u_morphTime;\n\
 \n\
 #if TEXTURE_UNITS > 0\n\
 uniform sampler2D u_dayTextures[TEXTURE_UNITS];\n\
@@ -46,18 +43,13 @@ vec3 sampleAndBlend(\n\
     float textureSaturation,\n\
     float textureOneOverGamma)\n\
 {\n\
-    // This crazy step stuff sets the alpha to 0.0 if this following condition is true:\n\
-    //    tileTextureCoordinates.s < textureCoordinateExtent.s ||\n\
-    //    tileTextureCoordinates.s > textureCoordinateExtent.p ||\n\
-    //    tileTextureCoordinates.t < textureCoordinateExtent.t ||\n\
-    //    tileTextureCoordinates.t > textureCoordinateExtent.q\n\
-    // In other words, the alpha is zero if the fragment is outside the extent\n\
-    // covered by this texture.  Would an actual 'if' yield better performance?\n\
-    vec2 alphaMultiplier = step(textureCoordinateExtent.st, tileTextureCoordinates); \n\
-    textureAlpha = textureAlpha * alphaMultiplier.x * alphaMultiplier.y;\n\
-    \n\
-    alphaMultiplier = step(vec2(0.0), textureCoordinateExtent.pq - tileTextureCoordinates);\n\
-    textureAlpha = textureAlpha * alphaMultiplier.x * alphaMultiplier.y;\n\
+    if (tileTextureCoordinates.s < textureCoordinateExtent.s ||\n\
+        tileTextureCoordinates.s > textureCoordinateExtent.p ||\n\
+        tileTextureCoordinates.t < textureCoordinateExtent.t ||\n\
+        tileTextureCoordinates.t > textureCoordinateExtent.q)\n\
+    {\n\
+        return previousColor;\n\
+    }\n\
     \n\
     vec2 translation = textureCoordinateTranslationAndScale.xy;\n\
     vec2 scale = textureCoordinateTranslationAndScale.zw;\n\
@@ -86,16 +78,11 @@ vec3 sampleAndBlend(\n\
     color = pow(color, vec3(textureOneOverGamma));\n\
 #endif\n\
 \n\
-#ifdef SHOW_TEXTURE_BOUNDARIES\n\
-    if (textureCoordinates.x < (1.0/256.0) || textureCoordinates.x > (255.0/256.0) ||\n\
-        textureCoordinates.y < (1.0/256.0) || textureCoordinates.y > (255.0/256.0))\n\
-    {\n\
-        color = vec3(1.0);\n\
-        alpha = 1.0;\n\
-    }\n\
+#ifdef APPLY_ALPHA\n\
+    alpha *= textureAlpha;\n\
 #endif\n\
 \n\
-    return mix(previousColor, color, alpha * textureAlpha);\n\
+    return mix(previousColor, color, alpha);\n\
 }\n\
 \n\
 vec3 computeDayColor(vec3 initialColor, vec2 textureCoordinates);\n\
@@ -136,7 +123,7 @@ void main()\n\
         vec2 ellipsoidTextureCoordinates = czm_ellipsoidWgs84TextureCoordinates(normalMC);\n\
         vec2 ellipsoidFlippedTextureCoordinates = czm_ellipsoidWgs84TextureCoordinates(normalMC.zyx);\n\
 \n\
-        vec2 textureCoordinates = mix(ellipsoidTextureCoordinates, ellipsoidFlippedTextureCoordinates, u_morphTime * smoothstep(0.9, 0.95, normalMC.z));\n\
+        vec2 textureCoordinates = mix(ellipsoidTextureCoordinates, ellipsoidFlippedTextureCoordinates, czm_morphTime * smoothstep(0.9, 0.95, normalMC.z));\n\
 \n\
         color = computeWaterColor(v_positionEC, textureCoordinates, enuToEye, startDayColor, mask);\n\
     }\n\

data/app/assets/javascripts/Shaders/CentralBodyVS.glsl

@@ -1,8 +1,6 @@
 attribute vec4 position3DAndHeight;
 attribute vec2 textureCoordinates;
 
-uniform float u_morphTime;
-
 uniform vec3 u_center3D;
 uniform mat4 u_modifiedModelView;
 uniform vec4 u_tileExtent;
@@ -77,7 +75,7 @@ vec4 getPositionMorphingMode(vec3 position3DWC)
     // This is unlikely to be noticable, though.
     float yPositionFraction = get2DYPositionFraction();
     vec3 position2DWC = vec3(0.0, mix(u_tileExtent.st, u_tileExtent.pq, vec2(textureCoordinates.x, yPositionFraction)));
-    vec4 morphPosition = czm_columbusViewMorph(position2DWC, position3DWC, u_morphTime);
+    vec4 morphPosition = czm_columbusViewMorph(position2DWC, position3DWC, czm_morphTime);
     return czm_modelViewProjection * morphPosition;
 }
 

data/app/assets/javascripts/Shaders/CentralBodyVS.js

@@ -5,8 +5,6 @@ define(function() {
 return "attribute vec4 position3DAndHeight;\n\
 attribute vec2 textureCoordinates;\n\
 \n\
-uniform float u_morphTime;\n\
-\n\
 uniform vec3 u_center3D;\n\
 uniform mat4 u_modifiedModelView;\n\
 uniform vec4 u_tileExtent;\n\
@@ -81,7 +79,7 @@ vec4 getPositionMorphingMode(vec3 position3DWC)\n\
     // This is unlikely to be noticable, though.\n\
     float yPositionFraction = get2DYPositionFraction();\n\
     vec3 position2DWC = vec3(0.0, mix(u_tileExtent.st, u_tileExtent.pq, vec2(textureCoordinates.x, yPositionFraction)));\n\
-    vec4 morphPosition = czm_columbusViewMorph(position2DWC, position3DWC, u_morphTime);\n\
+    vec4 morphPosition = czm_columbusViewMorph(position2DWC, position3DWC, czm_morphTime);\n\
     return czm_modelViewProjection * morphPosition;\n\
 }\n\
 \n\

data/app/assets/javascripts/Shaders/CustomSensorVolumeFS.glsl

@@ -6,14 +6,11 @@ uniform bool u_showIntersection;
 uniform bool u_showThroughEllipsoid;
 
 uniform float u_sensorRadius;
-uniform vec4 u_pickColor;
 
 varying vec3 v_positionWC;
 varying vec3 v_positionEC;
 varying vec3 v_normalEC;
 
-#ifndef RENDER_FOR_PICK
-
 vec4 getColor(float sensorRadius, vec3 pointEC)
 {
     czm_materialInput materialInput;
@@ -21,7 +18,6 @@ vec4 getColor(float sensorRadius, vec3 pointEC)
     vec3 pointMC = (czm_inverseModelView * vec4(pointEC, 1.0)).xyz;                                
     materialInput.st = sensor2dTextureCoordinates(sensorRadius, pointMC);   
     materialInput.str = pointMC / sensorRadius;
-    materialInput.positionMC = pointMC;               
     
     vec3 positionToEyeEC = -v_positionEC;
     materialInput.positionToEyeEC = positionToEyeEC;
@@ -34,58 +30,42 @@ vec4 getColor(float sensorRadius, vec3 pointEC)
     return czm_phong(normalize(positionToEyeEC), material);
 }
 
-#endif
-
-bool ellipsoidSensorIntersection(czm_raySegment ellipsoidInterval)
+bool ellipsoidSensorIntersection(czm_raySegment ellipsoidInterval, float pointInEllipsoid)
 {
-	if (czm_isEmpty(ellipsoidInterval))
-	{
-	    return false;
-	}
+    if (czm_isEmpty(ellipsoidInterval)) {
+        return false;
+    }
 
-    float t = ellipsoidInterval.start;
+    float t = pointInEllipsoid;
 
 #ifdef GL_OES_standard_derivatives
-    // TODO: This seems to be too aggressive in some areas, and too conservative in others
     float epsilon = max(abs(dFdx(t)), abs(dFdy(t)));
-    
-    if (epsilon >= ellipsoidInterval.start)
-    {
-        // If the fragment is on the silhouette of the ellipsoid, the adjacent fragment
-        // will not hit the ellipsoid (its ellipsoidInterval.start will be zero),
-        // so the derivative will be large, and we would get false positives.
-        return false;
-    }
 #else
     // TODO:  Don't hardcode this.
-    float epsilon = t / 500.0;
+    float epsilon = 1.0 / 500.0;
 #endif
 
     float width = 2.0;  // TODO: Expose as a uniform
     epsilon *= width;           
 
-    return czm_equalsEpsilon(t, length(v_positionEC), epsilon);
+    return czm_equalsEpsilon(t, 1.0, epsilon);
 }
 
-vec4 shade(czm_raySegment ellipsoidInterval)
+vec4 shade(czm_raySegment ellipsoidInterval, float pointInEllipsoid)
 {
-#ifdef RENDER_FOR_PICK
-    return u_pickColor;
-#else
-    if (u_showIntersection && ellipsoidSensorIntersection(ellipsoidInterval))
+    if (u_showIntersection && ellipsoidSensorIntersection(ellipsoidInterval, pointInEllipsoid))
     {
         return getIntersectionColor(u_sensorRadius, v_positionEC);
     }
     return getColor(u_sensorRadius, v_positionEC);
-#endif
 }
 
-bool czm_pointInEllipsoid(czm_ellipsoid ellipsoid, vec3 point)
+float czm_pointInEllipsoid(czm_ellipsoid ellipsoid, vec3 point)
 {
     // TODO: Take into account ellipsoid's center; optimize with radii-squared; and move elsewhere
     return (((point.x * point.x) / (ellipsoid.radii.x * ellipsoid.radii.x)) +
             ((point.y * point.y) / (ellipsoid.radii.y * ellipsoid.radii.y)) +
-            ((point.z * point.z) / (ellipsoid.radii.z * ellipsoid.radii.z)) < 1.0);
+            ((point.z * point.z) / (ellipsoid.radii.z * ellipsoid.radii.z)));
 }
 
 void main()
@@ -94,13 +74,14 @@ void main()
     vec3 sensorVertexEC = czm_modelView[3].xyz;  // (0.0, 0.0, 0.0) in model coordinates
 
     czm_ellipsoid ellipsoid = czm_getWgs84EllipsoidEC();
+    float pointInEllipsoid = czm_pointInEllipsoid(ellipsoid, v_positionWC);
 
     // Occluded by the ellipsoid?
 	if (!u_showThroughEllipsoid)
 	{
 	    // Discard if in the ellipsoid    
 	    // PERFORMANCE_IDEA: A coarse check for ellipsoid intersection could be done on the CPU first.
-	    if (czm_pointInEllipsoid(ellipsoid, v_positionWC))
+	    if (pointInEllipsoid < 1.0)
 	    {
             discard;
 	    }
@@ -122,5 +103,5 @@ void main()
     czm_ray ray = czm_ray(vec3(0.0), normalize(v_positionEC));  // Ray from eye to fragment in eye coordinates
     czm_raySegment ellipsoidInterval = czm_rayEllipsoidIntersectionInterval(ray, ellipsoid);
 
-    gl_FragColor = shade(ellipsoidInterval);
+    gl_FragColor = shade(ellipsoidInterval, pointInEllipsoid);
 }

data/app/assets/javascripts/Shaders/CustomSensorVolumeFS.js

@@ -10,14 +10,11 @@ uniform bool u_showIntersection;\n\
 uniform bool u_showThroughEllipsoid;\n\
 \n\
 uniform float u_sensorRadius;\n\
-uniform vec4 u_pickColor;\n\
 \n\
 varying vec3 v_positionWC;\n\
 varying vec3 v_positionEC;\n\
 varying vec3 v_normalEC;\n\
 \n\
-#ifndef RENDER_FOR_PICK\n\
-\n\
 vec4 getColor(float sensorRadius, vec3 pointEC)\n\
 {\n\
     czm_materialInput materialInput;\n\
@@ -25,7 +22,6 @@ vec4 getColor(float sensorRadius, vec3 pointEC)\n\
     vec3 pointMC = (czm_inverseModelView * vec4(pointEC, 1.0)).xyz;                                \n\
     materialInput.st = sensor2dTextureCoordinates(sensorRadius, pointMC);   \n\
     materialInput.str = pointMC / sensorRadius;\n\
-    materialInput.positionMC = pointMC;               \n\
     \n\
     vec3 positionToEyeEC = -v_positionEC;\n\
     materialInput.positionToEyeEC = positionToEyeEC;\n\
@@ -38,58 +34,42 @@ vec4 getColor(float sensorRadius, vec3 pointEC)\n\
     return czm_phong(normalize(positionToEyeEC), material);\n\
 }\n\
 \n\
-#endif\n\
-\n\
-bool ellipsoidSensorIntersection(czm_raySegment ellipsoidInterval)\n\
+bool ellipsoidSensorIntersection(czm_raySegment ellipsoidInterval, float pointInEllipsoid)\n\
 {\n\
-	if (czm_isEmpty(ellipsoidInterval))\n\
-	{\n\
-	    return false;\n\
-	}\n\
+    if (czm_isEmpty(ellipsoidInterval)) {\n\
+        return false;\n\
+    }\n\
 \n\
-    float t = ellipsoidInterval.start;\n\
+    float t = pointInEllipsoid;\n\
 \n\
 #ifdef GL_OES_standard_derivatives\n\
-    // TODO: This seems to be too aggressive in some areas, and too conservative in others\n\
     float epsilon = max(abs(dFdx(t)), abs(dFdy(t)));\n\
-    \n\
-    if (epsilon >= ellipsoidInterval.start)\n\
-    {\n\
-        // If the fragment is on the silhouette of the ellipsoid, the adjacent fragment\n\
-        // will not hit the ellipsoid (its ellipsoidInterval.start will be zero),\n\
-        // so the derivative will be large, and we would get false positives.\n\
-        return false;\n\
-    }\n\
 #else\n\
     // TODO:  Don't hardcode this.\n\
-    float epsilon = t / 500.0;\n\
+    float epsilon = 1.0 / 500.0;\n\
 #endif\n\
 \n\
     float width = 2.0;  // TODO: Expose as a uniform\n\
     epsilon *= width;           \n\
 \n\
-    return czm_equalsEpsilon(t, length(v_positionEC), epsilon);\n\
+    return czm_equalsEpsilon(t, 1.0, epsilon);\n\
 }\n\
 \n\
-vec4 shade(czm_raySegment ellipsoidInterval)\n\
+vec4 shade(czm_raySegment ellipsoidInterval, float pointInEllipsoid)\n\
 {\n\
-#ifdef RENDER_FOR_PICK\n\
-    return u_pickColor;\n\
-#else\n\
-    if (u_showIntersection && ellipsoidSensorIntersection(ellipsoidInterval))\n\
+    if (u_showIntersection && ellipsoidSensorIntersection(ellipsoidInterval, pointInEllipsoid))\n\
     {\n\
         return getIntersectionColor(u_sensorRadius, v_positionEC);\n\
     }\n\
     return getColor(u_sensorRadius, v_positionEC);\n\
-#endif\n\
 }\n\
 \n\
-bool czm_pointInEllipsoid(czm_ellipsoid ellipsoid, vec3 point)\n\
+float czm_pointInEllipsoid(czm_ellipsoid ellipsoid, vec3 point)\n\
 {\n\
     // TODO: Take into account ellipsoid's center; optimize with radii-squared; and move elsewhere\n\
     return (((point.x * point.x) / (ellipsoid.radii.x * ellipsoid.radii.x)) +\n\
             ((point.y * point.y) / (ellipsoid.radii.y * ellipsoid.radii.y)) +\n\
-            ((point.z * point.z) / (ellipsoid.radii.z * ellipsoid.radii.z)) < 1.0);\n\
+            ((point.z * point.z) / (ellipsoid.radii.z * ellipsoid.radii.z)));\n\
 }\n\
 \n\
 void main()\n\
@@ -98,13 +78,14 @@ void main()\n\
     vec3 sensorVertexEC = czm_modelView[3].xyz;  // (0.0, 0.0, 0.0) in model coordinates\n\
 \n\
     czm_ellipsoid ellipsoid = czm_getWgs84EllipsoidEC();\n\
+    float pointInEllipsoid = czm_pointInEllipsoid(ellipsoid, v_positionWC);\n\
 \n\
     // Occluded by the ellipsoid?\n\
 	if (!u_showThroughEllipsoid)\n\
 	{\n\
 	    // Discard if in the ellipsoid    \n\
 	    // PERFORMANCE_IDEA: A coarse check for ellipsoid intersection could be done on the CPU first.\n\
-	    if (czm_pointInEllipsoid(ellipsoid, v_positionWC))\n\
+	    if (pointInEllipsoid < 1.0)\n\
 	    {\n\
             discard;\n\
 	    }\n\
@@ -126,7 +107,7 @@ void main()\n\
     czm_ray ray = czm_ray(vec3(0.0), normalize(v_positionEC));  // Ray from eye to fragment in eye coordinates\n\
     czm_raySegment ellipsoidInterval = czm_rayEllipsoidIntersectionInterval(ray, ellipsoid);\n\
 \n\
-    gl_FragColor = shade(ellipsoidInterval);\n\
+    gl_FragColor = shade(ellipsoidInterval, pointInEllipsoid);\n\
 }\n\
 ";
 });

data/app/assets/javascripts/Shaders/EllipsoidFS.glsl

@@ -22,7 +22,6 @@ vec4 computeEllipsoidColor(czm_ray ray, float intersection, float side)
     materialInput.normalEC = normalEC;
     materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(positionMC, normalEC);
     materialInput.positionToEyeEC = positionToEyeEC;
-    materialInput.positionMC = positionMC;
     czm_material material = czm_getMaterial(materialInput);
 
     return czm_phong(normalize(positionToEyeEC), material);

data/app/assets/javascripts/Shaders/EllipsoidFS.js

@@ -26,7 +26,6 @@ vec4 computeEllipsoidColor(czm_ray ray, float intersection, float side)\n\
     materialInput.normalEC = normalEC;\n\
     materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(positionMC, normalEC);\n\
     materialInput.positionToEyeEC = positionToEyeEC;\n\
-    materialInput.positionMC = positionMC;\n\
     czm_material material = czm_getMaterial(materialInput);\n\
 \n\
     return czm_phong(normalize(positionToEyeEC), material);\n\

data/app/assets/javascripts/Shaders/Materials/CheckerboardMaterial.glsl

@@ -6,9 +6,7 @@ czm_material czm_getMaterial(czm_materialInput materialInput)
 {
     czm_material material = czm_getDefaultMaterial(materialInput);
 
-    // Fuzz Factor - Controls blurriness between light and dark colors
     vec2 st = materialInput.st;
-    const float fuzz = 0.03;
     
     // From Stefan Gustavson's Procedural Textures in GLSL in OpenGL Insights
     float b = mod(floor(repeat.s * st.s) + floor(repeat.t * st.t), 2.0);  // 0.0 or 1.0
@@ -20,17 +18,9 @@ czm_material czm_getMaterial(czm_materialInput materialInput)
     scaledHeight = abs(scaledHeight - floor(scaledHeight + 0.5));
     float value = min(scaledWidth, scaledHeight);
     
-    //anti-aliasing
-    float val1 = clamp(value / fuzz, 0.0, 1.0);
-    float val2 = clamp((value - 0.5) / fuzz, 0.0, 1.0);
-    val1 = val1 * (1.0 - val2);
-    val1 = val1 * val1 * (3.0 - (2.0 * val1));
-    val1 = pow(val1, 0.5); //makes the transition nicer
-    
-    vec4 midColor = (lightColor + darkColor) / 2.0;
     vec4 currentColor = mix(lightColor, darkColor, b);
+    vec4 color = czm_antialias(lightColor, darkColor, currentColor, value, 0.03);
     
-    vec4 color = mix(midColor, currentColor, val1);
     material.diffuse = color.rgb;
     material.alpha = color.a;
     

data/app/assets/javascripts/Shaders/Materials/CheckerboardMaterial.js

@@ -10,9 +10,7 @@ czm_material czm_getMaterial(czm_materialInput materialInput)\n\
 {\n\
     czm_material material = czm_getDefaultMaterial(materialInput);\n\
 \n\
-    // Fuzz Factor - Controls blurriness between light and dark colors\n\
     vec2 st = materialInput.st;\n\
-    const float fuzz = 0.03;\n\
     \n\
     // From Stefan Gustavson's Procedural Textures in GLSL in OpenGL Insights\n\
     float b = mod(floor(repeat.s * st.s) + floor(repeat.t * st.t), 2.0);  // 0.0 or 1.0\n\
@@ -24,17 +22,9 @@ czm_material czm_getMaterial(czm_materialInput materialInput)\n\
     scaledHeight = abs(scaledHeight - floor(scaledHeight + 0.5));\n\
     float value = min(scaledWidth, scaledHeight);\n\
     \n\
-    //anti-aliasing\n\
-    float val1 = clamp(value / fuzz, 0.0, 1.0);\n\
-    float val2 = clamp((value - 0.5) / fuzz, 0.0, 1.0);\n\
-    val1 = val1 * (1.0 - val2);\n\
-    val1 = val1 * val1 * (3.0 - (2.0 * val1));\n\
-    val1 = pow(val1, 0.5); //makes the transition nicer\n\
-    \n\
-    vec4 midColor = (lightColor + darkColor) / 2.0;\n\
     vec4 currentColor = mix(lightColor, darkColor, b);\n\
+    vec4 color = czm_antialias(lightColor, darkColor, currentColor, value, 0.03);\n\
     \n\
-    vec4 color = mix(midColor, currentColor, val1);\n\
     material.diffuse = color.rgb;\n\
     material.alpha = color.a;\n\
     \n\