Add existing to tracked

node_modules/@cesium/engine/Source/Shaders/Materials/AspectRampMaterial.glsl

@@ -0,0 +1,11 @@
+uniform sampler2D image;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+    vec4 rampColor = texture(image, vec2(materialInput.aspect / (2.0 * czm_pi), 0.5));
+    rampColor = czm_gammaCorrect(rampColor);
+    material.diffuse = rampColor.rgb;
+    material.alpha = rampColor.a;
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/AspectRampMaterial.js

@@ -0,0 +1,13 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform sampler2D image;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+    vec4 rampColor = texture(image, vec2(materialInput.aspect / (2.0 * czm_pi), 0.5));\n\
+    rampColor = czm_gammaCorrect(rampColor);\n\
+    material.diffuse = rampColor.rgb;\n\
+    material.alpha = rampColor.a;\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/BumpMapMaterial.glsl

@@ -0,0 +1,29 @@
+uniform sampler2D image;
+uniform float strength;
+uniform vec2 repeat;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    vec2 st = materialInput.st;
+
+    vec2 centerPixel = fract(repeat * st);
+    float centerBump = texture(image, centerPixel).channel;
+
+    float imageWidth = float(imageDimensions.x);
+    vec2 rightPixel = fract(repeat * (st + vec2(1.0 / imageWidth, 0.0)));
+    float rightBump = texture(image, rightPixel).channel;
+
+    float imageHeight = float(imageDimensions.y);
+    vec2 leftPixel = fract(repeat * (st + vec2(0.0, 1.0 / imageHeight)));
+    float topBump = texture(image, leftPixel).channel;
+
+    vec3 normalTangentSpace = normalize(vec3(centerBump - rightBump, centerBump - topBump, clamp(1.0 - strength, 0.1, 1.0)));
+    vec3 normalEC = materialInput.tangentToEyeMatrix * normalTangentSpace;
+
+    material.normal = normalEC;
+    material.diffuse = vec3(0.01);
+
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/BumpMapMaterial.js

@@ -0,0 +1,31 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform sampler2D image;\n\
+uniform float strength;\n\
+uniform vec2 repeat;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    vec2 st = materialInput.st;\n\
+\n\
+    vec2 centerPixel = fract(repeat * st);\n\
+    float centerBump = texture(image, centerPixel).channel;\n\
+\n\
+    float imageWidth = float(imageDimensions.x);\n\
+    vec2 rightPixel = fract(repeat * (st + vec2(1.0 / imageWidth, 0.0)));\n\
+    float rightBump = texture(image, rightPixel).channel;\n\
+\n\
+    float imageHeight = float(imageDimensions.y);\n\
+    vec2 leftPixel = fract(repeat * (st + vec2(0.0, 1.0 / imageHeight)));\n\
+    float topBump = texture(image, leftPixel).channel;\n\
+\n\
+    vec3 normalTangentSpace = normalize(vec3(centerBump - rightBump, centerBump - topBump, clamp(1.0 - strength, 0.1, 1.0)));\n\
+    vec3 normalEC = materialInput.tangentToEyeMatrix * normalTangentSpace;\n\
+\n\
+    material.normal = normalEC;\n\
+    material.diffuse = vec3(0.01);\n\
+\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/CheckerboardMaterial.glsl

@@ -0,0 +1,29 @@
+uniform vec4 lightColor;
+uniform vec4 darkColor;
+uniform vec2 repeat;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    vec2 st = materialInput.st;
+
+    // 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
+
+    // Find the distance from the closest separator (region between two colors)
+    float scaledWidth = fract(repeat.s * st.s);
+    scaledWidth = abs(scaledWidth - floor(scaledWidth + 0.5));
+    float scaledHeight = fract(repeat.t * st.t);
+    scaledHeight = abs(scaledHeight - floor(scaledHeight + 0.5));
+    float value = min(scaledWidth, scaledHeight);
+
+    vec4 currentColor = mix(lightColor, darkColor, b);
+    vec4 color = czm_antialias(lightColor, darkColor, currentColor, value, 0.03);
+
+    color = czm_gammaCorrect(color);
+    material.diffuse = color.rgb;
+    material.alpha = color.a;
+
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/CheckerboardMaterial.js

@@ -0,0 +1,31 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec4 lightColor;\n\
+uniform vec4 darkColor;\n\
+uniform vec2 repeat;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    vec2 st = materialInput.st;\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\
+\n\
+    // Find the distance from the closest separator (region between two colors)\n\
+    float scaledWidth = fract(repeat.s * st.s);\n\
+    scaledWidth = abs(scaledWidth - floor(scaledWidth + 0.5));\n\
+    float scaledHeight = fract(repeat.t * st.t);\n\
+    scaledHeight = abs(scaledHeight - floor(scaledHeight + 0.5));\n\
+    float value = min(scaledWidth, scaledHeight);\n\
+\n\
+    vec4 currentColor = mix(lightColor, darkColor, b);\n\
+    vec4 color = czm_antialias(lightColor, darkColor, currentColor, value, 0.03);\n\
+\n\
+    color = czm_gammaCorrect(color);\n\
+    material.diffuse = color.rgb;\n\
+    material.alpha = color.a;\n\
+\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/DotMaterial.glsl

@@ -0,0 +1,18 @@
+uniform vec4 lightColor;
+uniform vec4 darkColor;
+uniform vec2 repeat;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    // From Stefan Gustavson's Procedural Textures in GLSL in OpenGL Insights
+    float b = smoothstep(0.3, 0.32, length(fract(repeat * materialInput.st) - 0.5));  // 0.0 or 1.0
+
+    vec4 color = mix(lightColor, darkColor, b);
+    color = czm_gammaCorrect(color);
+    material.diffuse = color.rgb;
+    material.alpha = color.a;
+
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/DotMaterial.js

@@ -0,0 +1,20 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec4 lightColor;\n\
+uniform vec4 darkColor;\n\
+uniform vec2 repeat;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    // From Stefan Gustavson's Procedural Textures in GLSL in OpenGL Insights\n\
+    float b = smoothstep(0.3, 0.32, length(fract(repeat * materialInput.st) - 0.5));  // 0.0 or 1.0\n\
+\n\
+    vec4 color = mix(lightColor, darkColor, b);\n\
+    color = czm_gammaCorrect(color);\n\
+    material.diffuse = color.rgb;\n\
+    material.alpha = color.a;\n\
+\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/ElevationBandMaterial.glsl

@@ -0,0 +1,74 @@
+uniform sampler2D heights;
+uniform sampler2D colors;
+
+// This material expects heights to be sorted from lowest to highest.
+
+float getHeight(int idx, float invTexSize)
+{
+    vec2 uv = vec2((float(idx) + 0.5) * invTexSize, 0.5);
+#ifdef OES_texture_float
+    return texture(heights, uv).x;
+#else
+    return czm_unpackFloat(texture(heights, uv));
+#endif
+}
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    float height = materialInput.height;
+    float invTexSize = 1.0 / float(heightsDimensions.x);
+
+    float minHeight = getHeight(0, invTexSize);
+    float maxHeight = getHeight(heightsDimensions.x - 1, invTexSize);
+
+    // early-out when outside the height range
+    if (height < minHeight || height > maxHeight) {
+        material.diffuse = vec3(0.0);
+        material.alpha = 0.0;
+        return material;
+    }
+
+    // Binary search to find heights above and below.
+    int idxBelow = 0;
+    int idxAbove = heightsDimensions.x;
+    float heightBelow = minHeight;
+    float heightAbove = maxHeight;
+
+    // while loop not allowed, so use for loop with max iterations.
+    // maxIterations of 16 supports a texture size up to 65536 (2^16).
+    const int maxIterations = 16;
+    for (int i = 0; i < maxIterations; i++) {
+        if (idxBelow >= idxAbove - 1) {
+            break;
+        }
+
+        int idxMid = (idxBelow + idxAbove) / 2;
+        float heightTex = getHeight(idxMid, invTexSize);
+
+        if (height > heightTex) {
+            idxBelow = idxMid;
+            heightBelow = heightTex;
+        } else {
+            idxAbove = idxMid;
+            heightAbove = heightTex;
+        }
+    }
+
+    float lerper = heightBelow == heightAbove ? 1.0 : (height - heightBelow) / (heightAbove - heightBelow);
+    vec2 colorUv = vec2(invTexSize * (float(idxBelow) + 0.5 + lerper), 0.5);
+    vec4 color = texture(colors, colorUv);
+
+    // undo preumultiplied alpha
+    if (color.a > 0.0) 
+    {
+        color.rgb /= color.a;
+    }
+    
+    color.rgb = czm_gammaCorrect(color.rgb);
+
+    material.diffuse = color.rgb;
+    material.alpha = color.a;
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/ElevationBandMaterial.js

@@ -0,0 +1,76 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform sampler2D heights;\n\
+uniform sampler2D colors;\n\
+\n\
+// This material expects heights to be sorted from lowest to highest.\n\
+\n\
+float getHeight(int idx, float invTexSize)\n\
+{\n\
+    vec2 uv = vec2((float(idx) + 0.5) * invTexSize, 0.5);\n\
+#ifdef OES_texture_float\n\
+    return texture(heights, uv).x;\n\
+#else\n\
+    return czm_unpackFloat(texture(heights, uv));\n\
+#endif\n\
+}\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    float height = materialInput.height;\n\
+    float invTexSize = 1.0 / float(heightsDimensions.x);\n\
+\n\
+    float minHeight = getHeight(0, invTexSize);\n\
+    float maxHeight = getHeight(heightsDimensions.x - 1, invTexSize);\n\
+\n\
+    // early-out when outside the height range\n\
+    if (height < minHeight || height > maxHeight) {\n\
+        material.diffuse = vec3(0.0);\n\
+        material.alpha = 0.0;\n\
+        return material;\n\
+    }\n\
+\n\
+    // Binary search to find heights above and below.\n\
+    int idxBelow = 0;\n\
+    int idxAbove = heightsDimensions.x;\n\
+    float heightBelow = minHeight;\n\
+    float heightAbove = maxHeight;\n\
+\n\
+    // while loop not allowed, so use for loop with max iterations.\n\
+    // maxIterations of 16 supports a texture size up to 65536 (2^16).\n\
+    const int maxIterations = 16;\n\
+    for (int i = 0; i < maxIterations; i++) {\n\
+        if (idxBelow >= idxAbove - 1) {\n\
+            break;\n\
+        }\n\
+\n\
+        int idxMid = (idxBelow + idxAbove) / 2;\n\
+        float heightTex = getHeight(idxMid, invTexSize);\n\
+\n\
+        if (height > heightTex) {\n\
+            idxBelow = idxMid;\n\
+            heightBelow = heightTex;\n\
+        } else {\n\
+            idxAbove = idxMid;\n\
+            heightAbove = heightTex;\n\
+        }\n\
+    }\n\
+\n\
+    float lerper = heightBelow == heightAbove ? 1.0 : (height - heightBelow) / (heightAbove - heightBelow);\n\
+    vec2 colorUv = vec2(invTexSize * (float(idxBelow) + 0.5 + lerper), 0.5);\n\
+    vec4 color = texture(colors, colorUv);\n\
+\n\
+    // undo preumultiplied alpha\n\
+    if (color.a > 0.0) \n\
+    {\n\
+        color.rgb /= color.a;\n\
+    }\n\
+    \n\
+    color.rgb = czm_gammaCorrect(color.rgb);\n\
+\n\
+    material.diffuse = color.rgb;\n\
+    material.alpha = color.a;\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/ElevationContourMaterial.glsl

@@ -0,0 +1,26 @@
+uniform vec4 color;
+uniform float spacing;
+uniform float width;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    float distanceToContour = mod(materialInput.height, spacing);
+
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))
+    float dxc = abs(dFdx(materialInput.height));
+    float dyc = abs(dFdy(materialInput.height));
+    float dF = max(dxc, dyc) * czm_pixelRatio * width;
+    float alpha = (distanceToContour < dF) ? 1.0 : 0.0;
+#else
+    // If no derivatives available (IE 10?), use pixel ratio
+    float alpha = (distanceToContour < (czm_pixelRatio * width)) ? 1.0 : 0.0;
+#endif
+
+    vec4 outColor = czm_gammaCorrect(vec4(color.rgb, alpha * color.a));
+    material.diffuse = outColor.rgb;
+    material.alpha = outColor.a;
+
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/ElevationContourMaterial.js

@@ -0,0 +1,28 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec4 color;\n\
+uniform float spacing;\n\
+uniform float width;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    float distanceToContour = mod(materialInput.height, spacing);\n\
+\n\
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))\n\
+    float dxc = abs(dFdx(materialInput.height));\n\
+    float dyc = abs(dFdy(materialInput.height));\n\
+    float dF = max(dxc, dyc) * czm_pixelRatio * width;\n\
+    float alpha = (distanceToContour < dF) ? 1.0 : 0.0;\n\
+#else\n\
+    // If no derivatives available (IE 10?), use pixel ratio\n\
+    float alpha = (distanceToContour < (czm_pixelRatio * width)) ? 1.0 : 0.0;\n\
+#endif\n\
+\n\
+    vec4 outColor = czm_gammaCorrect(vec4(color.rgb, alpha * color.a));\n\
+    material.diffuse = outColor.rgb;\n\
+    material.alpha = outColor.a;\n\
+\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/ElevationRampMaterial.glsl

@@ -0,0 +1,14 @@
+uniform sampler2D image;
+uniform float minimumHeight;
+uniform float maximumHeight;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+    float scaledHeight = clamp((materialInput.height - minimumHeight) / (maximumHeight - minimumHeight), 0.0, 1.0);
+    vec4 rampColor = texture(image, vec2(scaledHeight, 0.5));
+    rampColor = czm_gammaCorrect(rampColor);
+    material.diffuse = rampColor.rgb;
+    material.alpha = rampColor.a;
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/ElevationRampMaterial.js

@@ -0,0 +1,16 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform sampler2D image;\n\
+uniform float minimumHeight;\n\
+uniform float maximumHeight;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+    float scaledHeight = clamp((materialInput.height - minimumHeight) / (maximumHeight - minimumHeight), 0.0, 1.0);\n\
+    vec4 rampColor = texture(image, vec2(scaledHeight, 0.5));\n\
+    rampColor = czm_gammaCorrect(rampColor);\n\
+    material.diffuse = rampColor.rgb;\n\
+    material.alpha = rampColor.a;\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/FadeMaterial.glsl

@@ -0,0 +1,37 @@
+uniform vec4 fadeInColor;
+uniform vec4 fadeOutColor;
+uniform float maximumDistance;
+uniform bool repeat;
+uniform vec2 fadeDirection;
+uniform vec2 time;
+
+float getTime(float t, float coord)
+{
+    float scalar = 1.0 / maximumDistance;
+    float q  = distance(t, coord) * scalar;
+    if (repeat)
+    {
+        float r = distance(t, coord + 1.0) * scalar;
+        float s = distance(t, coord - 1.0) * scalar;
+        q = min(min(r, s), q);
+    }
+    return clamp(q, 0.0, 1.0);
+}
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    vec2 st = materialInput.st;
+    float s = getTime(time.x, st.s) * fadeDirection.s;
+    float t = getTime(time.y, st.t) * fadeDirection.t;
+
+    float u = length(vec2(s, t));
+    vec4 color = mix(fadeInColor, fadeOutColor, u);
+
+    color = czm_gammaCorrect(color);
+    material.emission = color.rgb;
+    material.alpha = color.a;
+
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/FadeMaterial.js

@@ -0,0 +1,39 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec4 fadeInColor;\n\
+uniform vec4 fadeOutColor;\n\
+uniform float maximumDistance;\n\
+uniform bool repeat;\n\
+uniform vec2 fadeDirection;\n\
+uniform vec2 time;\n\
+\n\
+float getTime(float t, float coord)\n\
+{\n\
+    float scalar = 1.0 / maximumDistance;\n\
+    float q  = distance(t, coord) * scalar;\n\
+    if (repeat)\n\
+    {\n\
+        float r = distance(t, coord + 1.0) * scalar;\n\
+        float s = distance(t, coord - 1.0) * scalar;\n\
+        q = min(min(r, s), q);\n\
+    }\n\
+    return clamp(q, 0.0, 1.0);\n\
+}\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    vec2 st = materialInput.st;\n\
+    float s = getTime(time.x, st.s) * fadeDirection.s;\n\
+    float t = getTime(time.y, st.t) * fadeDirection.t;\n\
+\n\
+    float u = length(vec2(s, t));\n\
+    vec4 color = mix(fadeInColor, fadeOutColor, u);\n\
+\n\
+    color = czm_gammaCorrect(color);\n\
+    material.emission = color.rgb;\n\
+    material.alpha = color.a;\n\
+\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/GridMaterial.glsl

@@ -0,0 +1,57 @@
+uniform vec4 color;
+uniform float cellAlpha;
+uniform vec2 lineCount;
+uniform vec2 lineThickness;
+uniform vec2 lineOffset;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    vec2 st = materialInput.st;
+
+    float scaledWidth = fract(lineCount.s * st.s - lineOffset.s);
+    scaledWidth = abs(scaledWidth - floor(scaledWidth + 0.5));
+    float scaledHeight = fract(lineCount.t * st.t - lineOffset.t);
+    scaledHeight = abs(scaledHeight - floor(scaledHeight + 0.5));
+
+    float value;
+
+    // Fuzz Factor - Controls blurriness of lines
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))
+    const float fuzz = 1.2;
+    vec2 thickness = (lineThickness * czm_pixelRatio) - 1.0;
+
+    // From "3D Engine Design for Virtual Globes" by Cozzi and Ring, Listing 4.13.
+    vec2 dx = abs(dFdx(st));
+    vec2 dy = abs(dFdy(st));
+    vec2 dF = vec2(max(dx.s, dy.s), max(dx.t, dy.t)) * lineCount;
+    value = min(
+        smoothstep(dF.s * thickness.s, dF.s * (fuzz + thickness.s), scaledWidth),
+        smoothstep(dF.t * thickness.t, dF.t * (fuzz + thickness.t), scaledHeight));
+#else
+    // If no derivatives available (IE 10?), revert to view-dependent fuzz
+    const float fuzz = 0.05;
+
+    vec2 range = 0.5 - (lineThickness * 0.05);
+    value = min(
+        1.0 - smoothstep(range.s, range.s + fuzz, scaledWidth),
+        1.0 - smoothstep(range.t, range.t + fuzz, scaledHeight));
+#endif
+
+    // Edges taken from RimLightingMaterial.glsl
+    // See http://www.fundza.com/rman_shaders/surface/fake_rim/fake_rim1.html
+    float dRim = 1.0 - abs(dot(materialInput.normalEC, normalize(materialInput.positionToEyeEC)));
+    float sRim = smoothstep(0.8, 1.0, dRim);
+    value *= (1.0 - sRim);
+
+    vec4 halfColor;
+    halfColor.rgb = color.rgb * 0.5;
+    halfColor.a = color.a * (1.0 - ((1.0 - cellAlpha) * value));
+    halfColor = czm_gammaCorrect(halfColor);
+    material.diffuse = halfColor.rgb;
+    material.emission = halfColor.rgb;
+    material.alpha = halfColor.a;
+
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/GridMaterial.js

@@ -0,0 +1,59 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec4 color;\n\
+uniform float cellAlpha;\n\
+uniform vec2 lineCount;\n\
+uniform vec2 lineThickness;\n\
+uniform vec2 lineOffset;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    vec2 st = materialInput.st;\n\
+\n\
+    float scaledWidth = fract(lineCount.s * st.s - lineOffset.s);\n\
+    scaledWidth = abs(scaledWidth - floor(scaledWidth + 0.5));\n\
+    float scaledHeight = fract(lineCount.t * st.t - lineOffset.t);\n\
+    scaledHeight = abs(scaledHeight - floor(scaledHeight + 0.5));\n\
+\n\
+    float value;\n\
+\n\
+    // Fuzz Factor - Controls blurriness of lines\n\
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))\n\
+    const float fuzz = 1.2;\n\
+    vec2 thickness = (lineThickness * czm_pixelRatio) - 1.0;\n\
+\n\
+    // From \"3D Engine Design for Virtual Globes\" by Cozzi and Ring, Listing 4.13.\n\
+    vec2 dx = abs(dFdx(st));\n\
+    vec2 dy = abs(dFdy(st));\n\
+    vec2 dF = vec2(max(dx.s, dy.s), max(dx.t, dy.t)) * lineCount;\n\
+    value = min(\n\
+        smoothstep(dF.s * thickness.s, dF.s * (fuzz + thickness.s), scaledWidth),\n\
+        smoothstep(dF.t * thickness.t, dF.t * (fuzz + thickness.t), scaledHeight));\n\
+#else\n\
+    // If no derivatives available (IE 10?), revert to view-dependent fuzz\n\
+    const float fuzz = 0.05;\n\
+\n\
+    vec2 range = 0.5 - (lineThickness * 0.05);\n\
+    value = min(\n\
+        1.0 - smoothstep(range.s, range.s + fuzz, scaledWidth),\n\
+        1.0 - smoothstep(range.t, range.t + fuzz, scaledHeight));\n\
+#endif\n\
+\n\
+    // Edges taken from RimLightingMaterial.glsl\n\
+    // See http://www.fundza.com/rman_shaders/surface/fake_rim/fake_rim1.html\n\
+    float dRim = 1.0 - abs(dot(materialInput.normalEC, normalize(materialInput.positionToEyeEC)));\n\
+    float sRim = smoothstep(0.8, 1.0, dRim);\n\
+    value *= (1.0 - sRim);\n\
+\n\
+    vec4 halfColor;\n\
+    halfColor.rgb = color.rgb * 0.5;\n\
+    halfColor.a = color.a * (1.0 - ((1.0 - cellAlpha) * value));\n\
+    halfColor = czm_gammaCorrect(halfColor);\n\
+    material.diffuse = halfColor.rgb;\n\
+    material.emission = halfColor.rgb;\n\
+    material.alpha = halfColor.a;\n\
+\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/NormalMapMaterial.glsl

@@ -0,0 +1,19 @@
+uniform sampler2D image;
+uniform float strength;
+uniform vec2 repeat;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+    
+    vec4 textureValue = texture(image, fract(repeat * materialInput.st));
+    vec3 normalTangentSpace = textureValue.channels;
+    normalTangentSpace.xy = normalTangentSpace.xy * 2.0 - 1.0;
+    normalTangentSpace.z = clamp(1.0 - strength, 0.1, 1.0);
+    normalTangentSpace = normalize(normalTangentSpace);
+    vec3 normalEC = materialInput.tangentToEyeMatrix * normalTangentSpace;
+    
+    material.normal = normalEC;
+    
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/NormalMapMaterial.js

@@ -0,0 +1,21 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform sampler2D image;\n\
+uniform float strength;\n\
+uniform vec2 repeat;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+    \n\
+    vec4 textureValue = texture(image, fract(repeat * materialInput.st));\n\
+    vec3 normalTangentSpace = textureValue.channels;\n\
+    normalTangentSpace.xy = normalTangentSpace.xy * 2.0 - 1.0;\n\
+    normalTangentSpace.z = clamp(1.0 - strength, 0.1, 1.0);\n\
+    normalTangentSpace = normalize(normalTangentSpace);\n\
+    vec3 normalEC = materialInput.tangentToEyeMatrix * normalTangentSpace;\n\
+    \n\
+    material.normal = normalEC;\n\
+    \n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/PolylineArrowMaterial.glsl

@@ -0,0 +1,63 @@
+uniform vec4 color;
+
+float getPointOnLine(vec2 p0, vec2 p1, float x)
+{
+    float slope = (p0.y - p1.y) / (p0.x - p1.x);
+    return slope * (x - p0.x) + p0.y;
+}
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    vec2 st = materialInput.st;
+
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))
+    float base = 1.0 - abs(fwidth(st.s)) * 10.0 * czm_pixelRatio;
+#else
+     // If no derivatives available (IE 10?), 2.5% of the line will be the arrow head
+    float base = 0.975;
+#endif
+
+    vec2 center = vec2(1.0, 0.5);
+    float ptOnUpperLine = getPointOnLine(vec2(base, 1.0), center, st.s);
+    float ptOnLowerLine = getPointOnLine(vec2(base, 0.0), center, st.s);
+
+    float halfWidth = 0.15;
+    float s = step(0.5 - halfWidth, st.t);
+    s *= 1.0 - step(0.5 + halfWidth, st.t);
+    s *= 1.0 - step(base, st.s);
+
+    float t = step(base, materialInput.st.s);
+    t *= 1.0 - step(ptOnUpperLine, st.t);
+    t *= step(ptOnLowerLine, st.t);
+
+    // Find the distance from the closest separator (region between two colors)
+    float dist;
+    if (st.s < base)
+    {
+        float d1 = abs(st.t - (0.5 - halfWidth));
+        float d2 = abs(st.t - (0.5 + halfWidth));
+        dist = min(d1, d2);
+    }
+    else
+    {
+        float d1 = czm_infinity;
+        if (st.t < 0.5 - halfWidth && st.t > 0.5 + halfWidth)
+        {
+            d1 = abs(st.s - base);
+        }
+        float d2 = abs(st.t - ptOnUpperLine);
+        float d3 = abs(st.t - ptOnLowerLine);
+        dist = min(min(d1, d2), d3);
+    }
+
+    vec4 outsideColor = vec4(0.0);
+    vec4 currentColor = mix(outsideColor, color, clamp(s + t, 0.0, 1.0));
+    vec4 outColor = czm_antialias(outsideColor, color, currentColor, dist);
+
+    outColor = czm_gammaCorrect(outColor);
+    material.diffuse = outColor.rgb;
+    material.alpha = outColor.a;
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/PolylineArrowMaterial.js

@@ -0,0 +1,65 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec4 color;\n\
+\n\
+float getPointOnLine(vec2 p0, vec2 p1, float x)\n\
+{\n\
+    float slope = (p0.y - p1.y) / (p0.x - p1.x);\n\
+    return slope * (x - p0.x) + p0.y;\n\
+}\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    vec2 st = materialInput.st;\n\
+\n\
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))\n\
+    float base = 1.0 - abs(fwidth(st.s)) * 10.0 * czm_pixelRatio;\n\
+#else\n\
+     // If no derivatives available (IE 10?), 2.5% of the line will be the arrow head\n\
+    float base = 0.975;\n\
+#endif\n\
+\n\
+    vec2 center = vec2(1.0, 0.5);\n\
+    float ptOnUpperLine = getPointOnLine(vec2(base, 1.0), center, st.s);\n\
+    float ptOnLowerLine = getPointOnLine(vec2(base, 0.0), center, st.s);\n\
+\n\
+    float halfWidth = 0.15;\n\
+    float s = step(0.5 - halfWidth, st.t);\n\
+    s *= 1.0 - step(0.5 + halfWidth, st.t);\n\
+    s *= 1.0 - step(base, st.s);\n\
+\n\
+    float t = step(base, materialInput.st.s);\n\
+    t *= 1.0 - step(ptOnUpperLine, st.t);\n\
+    t *= step(ptOnLowerLine, st.t);\n\
+\n\
+    // Find the distance from the closest separator (region between two colors)\n\
+    float dist;\n\
+    if (st.s < base)\n\
+    {\n\
+        float d1 = abs(st.t - (0.5 - halfWidth));\n\
+        float d2 = abs(st.t - (0.5 + halfWidth));\n\
+        dist = min(d1, d2);\n\
+    }\n\
+    else\n\
+    {\n\
+        float d1 = czm_infinity;\n\
+        if (st.t < 0.5 - halfWidth && st.t > 0.5 + halfWidth)\n\
+        {\n\
+            d1 = abs(st.s - base);\n\
+        }\n\
+        float d2 = abs(st.t - ptOnUpperLine);\n\
+        float d3 = abs(st.t - ptOnLowerLine);\n\
+        dist = min(min(d1, d2), d3);\n\
+    }\n\
+\n\
+    vec4 outsideColor = vec4(0.0);\n\
+    vec4 currentColor = mix(outsideColor, color, clamp(s + t, 0.0, 1.0));\n\
+    vec4 outColor = czm_antialias(outsideColor, color, currentColor, dist);\n\
+\n\
+    outColor = czm_gammaCorrect(outColor);\n\
+    material.diffuse = outColor.rgb;\n\
+    material.alpha = outColor.a;\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/PolylineDashMaterial.glsl

@@ -0,0 +1,39 @@
+uniform vec4 color;
+uniform vec4 gapColor;
+uniform float dashLength;
+uniform float dashPattern;
+in float v_polylineAngle;
+
+const float maskLength = 16.0;
+
+mat2 rotate(float rad) {
+    float c = cos(rad);
+    float s = sin(rad);
+    return mat2(
+        c, s,
+        -s, c
+    );
+}
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    vec2 pos = rotate(v_polylineAngle) * gl_FragCoord.xy;
+
+    // Get the relative position within the dash from 0 to 1
+    float dashPosition = fract(pos.x / (dashLength * czm_pixelRatio));
+    // Figure out the mask index.
+    float maskIndex = floor(dashPosition * maskLength);
+    // Test the bit mask.
+    float maskTest = floor(dashPattern / pow(2.0, maskIndex));
+    vec4 fragColor = (mod(maskTest, 2.0) < 1.0) ? gapColor : color;
+    if (fragColor.a < 0.005) {   // matches 0/255 and 1/255
+        discard;
+    }
+
+    fragColor = czm_gammaCorrect(fragColor);
+    material.emission = fragColor.rgb;
+    material.alpha = fragColor.a;
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/PolylineDashMaterial.js

@@ -0,0 +1,41 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec4 color;\n\
+uniform vec4 gapColor;\n\
+uniform float dashLength;\n\
+uniform float dashPattern;\n\
+in float v_polylineAngle;\n\
+\n\
+const float maskLength = 16.0;\n\
+\n\
+mat2 rotate(float rad) {\n\
+    float c = cos(rad);\n\
+    float s = sin(rad);\n\
+    return mat2(\n\
+        c, s,\n\
+        -s, c\n\
+    );\n\
+}\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    vec2 pos = rotate(v_polylineAngle) * gl_FragCoord.xy;\n\
+\n\
+    // Get the relative position within the dash from 0 to 1\n\
+    float dashPosition = fract(pos.x / (dashLength * czm_pixelRatio));\n\
+    // Figure out the mask index.\n\
+    float maskIndex = floor(dashPosition * maskLength);\n\
+    // Test the bit mask.\n\
+    float maskTest = floor(dashPattern / pow(2.0, maskIndex));\n\
+    vec4 fragColor = (mod(maskTest, 2.0) < 1.0) ? gapColor : color;\n\
+    if (fragColor.a < 0.005) {   // matches 0/255 and 1/255\n\
+        discard;\n\
+    }\n\
+\n\
+    fragColor = czm_gammaCorrect(fragColor);\n\
+    material.emission = fragColor.rgb;\n\
+    material.alpha = fragColor.a;\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/PolylineGlowMaterial.glsl

@@ -0,0 +1,25 @@
+uniform vec4 color;
+uniform float glowPower;
+uniform float taperPower;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    vec2 st = materialInput.st;
+    float glow = glowPower / abs(st.t - 0.5) - (glowPower / 0.5);
+
+    if (taperPower <= 0.99999) {
+        glow *= min(1.0, taperPower / (0.5 - st.s * 0.5) - (taperPower / 0.5));
+    }
+
+    vec4 fragColor;
+    fragColor.rgb = max(vec3(glow - 1.0 + color.rgb), color.rgb);
+    fragColor.a = clamp(glow, 0.0, 1.0) * color.a;
+    fragColor = czm_gammaCorrect(fragColor);
+
+    material.emission = fragColor.rgb;
+    material.alpha = fragColor.a;
+
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/PolylineGlowMaterial.js

@@ -0,0 +1,27 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec4 color;\n\
+uniform float glowPower;\n\
+uniform float taperPower;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    vec2 st = materialInput.st;\n\
+    float glow = glowPower / abs(st.t - 0.5) - (glowPower / 0.5);\n\
+\n\
+    if (taperPower <= 0.99999) {\n\
+        glow *= min(1.0, taperPower / (0.5 - st.s * 0.5) - (taperPower / 0.5));\n\
+    }\n\
+\n\
+    vec4 fragColor;\n\
+    fragColor.rgb = max(vec3(glow - 1.0 + color.rgb), color.rgb);\n\
+    fragColor.a = clamp(glow, 0.0, 1.0) * color.a;\n\
+    fragColor = czm_gammaCorrect(fragColor);\n\
+\n\
+    material.emission = fragColor.rgb;\n\
+    material.alpha = fragColor.a;\n\
+\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/PolylineOutlineMaterial.glsl

@@ -0,0 +1,29 @@
+uniform vec4 color;
+uniform vec4 outlineColor;
+uniform float outlineWidth;
+
+in float v_width;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    vec2 st = materialInput.st;
+    float halfInteriorWidth =  0.5 * (v_width - outlineWidth) / v_width;
+    float b = step(0.5 - halfInteriorWidth, st.t);
+    b *= 1.0 - step(0.5 + halfInteriorWidth, st.t);
+
+    // Find the distance from the closest separator (region between two colors)
+    float d1 = abs(st.t - (0.5 - halfInteriorWidth));
+    float d2 = abs(st.t - (0.5 + halfInteriorWidth));
+    float dist = min(d1, d2);
+
+    vec4 currentColor = mix(outlineColor, color, b);
+    vec4 outColor = czm_antialias(outlineColor, color, currentColor, dist);
+    outColor = czm_gammaCorrect(outColor);
+
+    material.diffuse = outColor.rgb;
+    material.alpha = outColor.a;
+
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/PolylineOutlineMaterial.js

@@ -0,0 +1,31 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec4 color;\n\
+uniform vec4 outlineColor;\n\
+uniform float outlineWidth;\n\
+\n\
+in float v_width;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    vec2 st = materialInput.st;\n\
+    float halfInteriorWidth =  0.5 * (v_width - outlineWidth) / v_width;\n\
+    float b = step(0.5 - halfInteriorWidth, st.t);\n\
+    b *= 1.0 - step(0.5 + halfInteriorWidth, st.t);\n\
+\n\
+    // Find the distance from the closest separator (region between two colors)\n\
+    float d1 = abs(st.t - (0.5 - halfInteriorWidth));\n\
+    float d2 = abs(st.t - (0.5 + halfInteriorWidth));\n\
+    float dist = min(d1, d2);\n\
+\n\
+    vec4 currentColor = mix(outlineColor, color, b);\n\
+    vec4 outColor = czm_antialias(outlineColor, color, currentColor, dist);\n\
+    outColor = czm_gammaCorrect(outColor);\n\
+\n\
+    material.diffuse = outColor.rgb;\n\
+    material.alpha = outColor.a;\n\
+\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/RimLightingMaterial.glsl

@@ -0,0 +1,21 @@
+uniform vec4 color;
+uniform vec4 rimColor;
+uniform float width;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    // See http://www.fundza.com/rman_shaders/surface/fake_rim/fake_rim1.html
+    float d = 1.0 - dot(materialInput.normalEC, normalize(materialInput.positionToEyeEC));
+    float s = smoothstep(1.0 - width, 1.0, d);
+
+    vec4 outColor = czm_gammaCorrect(color);
+    vec4 outRimColor = czm_gammaCorrect(rimColor);
+
+    material.diffuse = outColor.rgb;
+    material.emission = outRimColor.rgb * s;
+    material.alpha = mix(outColor.a, outRimColor.a, s);
+
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/RimLightingMaterial.js

@@ -0,0 +1,23 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec4 color;\n\
+uniform vec4 rimColor;\n\
+uniform float width;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    // See http://www.fundza.com/rman_shaders/surface/fake_rim/fake_rim1.html\n\
+    float d = 1.0 - dot(materialInput.normalEC, normalize(materialInput.positionToEyeEC));\n\
+    float s = smoothstep(1.0 - width, 1.0, d);\n\
+\n\
+    vec4 outColor = czm_gammaCorrect(color);\n\
+    vec4 outRimColor = czm_gammaCorrect(rimColor);\n\
+\n\
+    material.diffuse = outColor.rgb;\n\
+    material.emission = outRimColor.rgb * s;\n\
+    material.alpha = mix(outColor.a, outRimColor.a, s);\n\
+\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/SlopeRampMaterial.glsl

@@ -0,0 +1,11 @@
+uniform sampler2D image;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+    vec4 rampColor = texture(image, vec2(materialInput.slope / (czm_pi / 2.0), 0.5));
+    rampColor = czm_gammaCorrect(rampColor);
+    material.diffuse = rampColor.rgb;
+    material.alpha = rampColor.a;
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/SlopeRampMaterial.js

@@ -0,0 +1,13 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform sampler2D image;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+    vec4 rampColor = texture(image, vec2(materialInput.slope / (czm_pi / 2.0), 0.5));\n\
+    rampColor = czm_gammaCorrect(rampColor);\n\
+    material.diffuse = rampColor.rgb;\n\
+    material.alpha = rampColor.a;\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/StripeMaterial.glsl

@@ -0,0 +1,24 @@
+uniform vec4 evenColor;
+uniform vec4 oddColor;
+uniform float offset;
+uniform float repeat;
+uniform bool horizontal;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    // Based on the Stripes Fragment Shader in the Orange Book (11.1.2)
+    float coord = mix(materialInput.st.s, materialInput.st.t, float(horizontal));
+    float value = fract((coord - offset) * (repeat * 0.5));
+    float dist = min(value, min(abs(value - 0.5), 1.0 - value));
+
+    vec4 currentColor = mix(evenColor, oddColor, step(0.5, value));
+    vec4 color = czm_antialias(evenColor, oddColor, currentColor, dist);
+    color = czm_gammaCorrect(color);
+
+    material.diffuse = color.rgb;
+    material.alpha = color.a;
+
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/StripeMaterial.js

@@ -0,0 +1,26 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec4 evenColor;\n\
+uniform vec4 oddColor;\n\
+uniform float offset;\n\
+uniform float repeat;\n\
+uniform bool horizontal;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    // Based on the Stripes Fragment Shader in the Orange Book (11.1.2)\n\
+    float coord = mix(materialInput.st.s, materialInput.st.t, float(horizontal));\n\
+    float value = fract((coord - offset) * (repeat * 0.5));\n\
+    float dist = min(value, min(abs(value - 0.5), 1.0 - value));\n\
+\n\
+    vec4 currentColor = mix(evenColor, oddColor, step(0.5, value));\n\
+    vec4 color = czm_antialias(evenColor, oddColor, currentColor, dist);\n\
+    color = czm_gammaCorrect(color);\n\
+\n\
+    material.diffuse = color.rgb;\n\
+    material.alpha = color.a;\n\
+\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/Water.glsl

@@ -0,0 +1,58 @@
+// Thanks for the contribution Jonas
+// http://29a.ch/2012/7/19/webgl-terrain-rendering-water-fog
+
+uniform sampler2D specularMap;
+uniform sampler2D normalMap;
+uniform vec4 baseWaterColor;
+uniform vec4 blendColor;
+uniform float frequency;
+uniform float animationSpeed;
+uniform float amplitude;
+uniform float specularIntensity;
+uniform float fadeFactor;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    float time = czm_frameNumber * animationSpeed;
+
+    // fade is a function of the distance from the fragment and the frequency of the waves
+    float fade = max(1.0, (length(materialInput.positionToEyeEC) / 10000000000.0) * frequency * fadeFactor);
+
+    float specularMapValue = texture(specularMap, materialInput.st).r;
+
+    // note: not using directional motion at this time, just set the angle to 0.0;
+    vec4 noise = czm_getWaterNoise(normalMap, materialInput.st * frequency, time, 0.0);
+    vec3 normalTangentSpace = noise.xyz * vec3(1.0, 1.0, (1.0 / amplitude));
+
+    // fade out the normal perturbation as we move further from the water surface
+    normalTangentSpace.xy /= fade;
+
+    // attempt to fade out the normal perturbation as we approach non water areas (low specular map value)
+    normalTangentSpace = mix(vec3(0.0, 0.0, 50.0), normalTangentSpace, specularMapValue);
+
+    normalTangentSpace = normalize(normalTangentSpace);
+
+    // get ratios for alignment of the new normal vector with a vector perpendicular to the tangent plane
+    float tsPerturbationRatio = clamp(dot(normalTangentSpace, vec3(0.0, 0.0, 1.0)), 0.0, 1.0);
+
+    // fade out water effect as specular map value decreases
+    material.alpha = mix(blendColor.a, baseWaterColor.a, specularMapValue) * specularMapValue;
+
+    // base color is a blend of the water and non-water color based on the value from the specular map
+    // may need a uniform blend factor to better control this
+    material.diffuse = mix(blendColor.rgb, baseWaterColor.rgb, specularMapValue);
+
+    // diffuse highlights are based on how perturbed the normal is
+    material.diffuse += (0.1 * tsPerturbationRatio);
+
+    material.diffuse = material.diffuse;
+
+    material.normal = normalize(materialInput.tangentToEyeMatrix * normalTangentSpace);
+
+    material.specular = specularIntensity;
+    material.shininess = 10.0;
+
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/Water.js

@@ -0,0 +1,60 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// Thanks for the contribution Jonas\n\
+// http://29a.ch/2012/7/19/webgl-terrain-rendering-water-fog\n\
+\n\
+uniform sampler2D specularMap;\n\
+uniform sampler2D normalMap;\n\
+uniform vec4 baseWaterColor;\n\
+uniform vec4 blendColor;\n\
+uniform float frequency;\n\
+uniform float animationSpeed;\n\
+uniform float amplitude;\n\
+uniform float specularIntensity;\n\
+uniform float fadeFactor;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    float time = czm_frameNumber * animationSpeed;\n\
+\n\
+    // fade is a function of the distance from the fragment and the frequency of the waves\n\
+    float fade = max(1.0, (length(materialInput.positionToEyeEC) / 10000000000.0) * frequency * fadeFactor);\n\
+\n\
+    float specularMapValue = texture(specularMap, materialInput.st).r;\n\
+\n\
+    // note: not using directional motion at this time, just set the angle to 0.0;\n\
+    vec4 noise = czm_getWaterNoise(normalMap, materialInput.st * frequency, time, 0.0);\n\
+    vec3 normalTangentSpace = noise.xyz * vec3(1.0, 1.0, (1.0 / amplitude));\n\
+\n\
+    // fade out the normal perturbation as we move further from the water surface\n\
+    normalTangentSpace.xy /= fade;\n\
+\n\
+    // attempt to fade out the normal perturbation as we approach non water areas (low specular map value)\n\
+    normalTangentSpace = mix(vec3(0.0, 0.0, 50.0), normalTangentSpace, specularMapValue);\n\
+\n\
+    normalTangentSpace = normalize(normalTangentSpace);\n\
+\n\
+    // get ratios for alignment of the new normal vector with a vector perpendicular to the tangent plane\n\
+    float tsPerturbationRatio = clamp(dot(normalTangentSpace, vec3(0.0, 0.0, 1.0)), 0.0, 1.0);\n\
+\n\
+    // fade out water effect as specular map value decreases\n\
+    material.alpha = mix(blendColor.a, baseWaterColor.a, specularMapValue) * specularMapValue;\n\
+\n\
+    // base color is a blend of the water and non-water color based on the value from the specular map\n\
+    // may need a uniform blend factor to better control this\n\
+    material.diffuse = mix(blendColor.rgb, baseWaterColor.rgb, specularMapValue);\n\
+\n\
+    // diffuse highlights are based on how perturbed the normal is\n\
+    material.diffuse += (0.1 * tsPerturbationRatio);\n\
+\n\
+    material.diffuse = material.diffuse;\n\
+\n\
+    material.normal = normalize(materialInput.tangentToEyeMatrix * normalTangentSpace);\n\
+\n\
+    material.specular = specularIntensity;\n\
+    material.shininess = 10.0;\n\
+\n\
+    return material;\n\
+}\n\
+";

node_modules/@cesium/engine/Source/Shaders/Materials/WaterMaskMaterial.glsl

@@ -0,0 +1,15 @@
+uniform vec4 waterColor;
+uniform vec4 landColor;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    vec4 outColor = mix(landColor, waterColor, materialInput.waterMask);
+    outColor = czm_gammaCorrect(outColor);
+
+    material.diffuse = outColor.rgb;
+    material.alpha = outColor.a;
+
+    return material;
+}

node_modules/@cesium/engine/Source/Shaders/Materials/WaterMaskMaterial.js

@@ -0,0 +1,17 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec4 waterColor;\n\
+uniform vec4 landColor;\n\
+\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    vec4 outColor = mix(landColor, waterColor, materialInput.waterMask);\n\
+    outColor = czm_gammaCorrect(outColor);\n\
+\n\
+    material.diffuse = outColor.rgb;\n\
+    material.alpha = outColor.a;\n\
+\n\
+    return material;\n\
+}\n\
+";