cesium 0.13.0

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

@@ -0,0 +1,19 @@
+// This file is automatically rebuilt by the Cesium build process.
+/*global define*/
+define(function() {
+    "use strict";
+    return "uniform vec4 lightColor;\n\
+uniform vec4 darkColor;\n\
+uniform float frequency;\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+czm_material material = czm_getDefaultMaterial(materialInput);\n\
+vec2 F = czm_cellular(materialInput.st * frequency);\n\
+float t = 1.0 - F.x * F.x;\n\
+vec4 color = mix(lightColor, darkColor, t);\n\
+material.diffuse = color.rgb;\n\
+material.alpha = color.a;\n\
+return material;\n\
+}\n\
+";
+});

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

@@ -0,0 +1,42 @@
+uniform vec4 brickColor;
+uniform vec4 mortarColor;
+uniform vec2 brickSize;
+uniform vec2 brickPct;
+uniform float brickRoughness;
+uniform float mortarRoughness;
+
+#define Integral(x, p) ((floor(x) * p) + max(fract(x) - (1.0 - p), 0.0))
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    // From OpenGL Shading Language (3rd edition) pg. 194, 501
+    vec2 st = materialInput.st;
+    vec2 position = st / brickSize;
+    if(fract(position.y * 0.5) > 0.5) {
+        position.x += 0.5;    
+    }
+        
+    //calculate whether to use brick or mortar (does AA)
+    vec2 filterWidth = vec2(0.02);
+    vec2 useBrick = (Integral(position + filterWidth, brickPct) - 
+                       Integral(position, brickPct)) / filterWidth;
+    float useBrickFinal = useBrick.x * useBrick.y;
+    vec4 color = mix(mortarColor, brickColor, useBrickFinal);
+    
+    //Apply noise to brick
+    vec2 brickScaled = vec2(st.x / 0.1, st.y / 0.006);
+    float brickNoise = abs(czm_snoise(brickScaled) * brickRoughness / 5.0);
+    color.rg += brickNoise * useBrickFinal;
+    
+    //Apply noise to mortar
+    vec2 mortarScaled = st / 0.005;
+    float mortarNoise = max(czm_snoise(mortarScaled) * mortarRoughness, 0.0);
+    color.rgb += mortarNoise * (1.0 - useBrickFinal); 
+
+    material.diffuse = color.rgb;
+    material.alpha = color.a;
+    
+    return material;
+}

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

@@ -0,0 +1,36 @@
+// This file is automatically rebuilt by the Cesium build process.
+/*global define*/
+define(function() {
+    "use strict";
+    return "uniform vec4 brickColor;\n\
+uniform vec4 mortarColor;\n\
+uniform vec2 brickSize;\n\
+uniform vec2 brickPct;\n\
+uniform float brickRoughness;\n\
+uniform float mortarRoughness;\n\
+#define Integral(x, p) ((floor(x) * p) + max(fract(x) - (1.0 - p), 0.0))\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+czm_material material = czm_getDefaultMaterial(materialInput);\n\
+vec2 st = materialInput.st;\n\
+vec2 position = st / brickSize;\n\
+if(fract(position.y * 0.5) > 0.5) {\n\
+position.x += 0.5;\n\
+}\n\
+vec2 filterWidth = vec2(0.02);\n\
+vec2 useBrick = (Integral(position + filterWidth, brickPct) -\n\
+Integral(position, brickPct)) / filterWidth;\n\
+float useBrickFinal = useBrick.x * useBrick.y;\n\
+vec4 color = mix(mortarColor, brickColor, useBrickFinal);\n\
+vec2 brickScaled = vec2(st.x / 0.1, st.y / 0.006);\n\
+float brickNoise = abs(czm_snoise(brickScaled) * brickRoughness / 5.0);\n\
+color.rg += brickNoise * useBrickFinal;\n\
+vec2 mortarScaled = st / 0.005;\n\
+float mortarNoise = max(czm_snoise(mortarScaled) * mortarRoughness, 0.0);\n\
+color.rgb += mortarNoise * (1.0 - useBrickFinal);\n\
+material.diffuse = color.rgb;\n\
+material.alpha = color.a;\n\
+return material;\n\
+}\n\
+";
+});

data/app/assets/javascripts/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 = texture2D(image, centerPixel).channel;
+    
+    float imageWidth = float(imageDimensions.x);
+    vec2 rightPixel = fract(repeat * (st + vec2(1.0 / imageWidth, 0.0)));
+    float rightBump = texture2D(image, rightPixel).channel;
+    
+    float imageHeight = float(imageDimensions.y);
+    vec2 leftPixel = fract(repeat * (st + vec2(0.0, 1.0 / imageHeight)));
+    float topBump = texture2D(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;
+}

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

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

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

@@ -0,0 +1,19 @@
+uniform vec4 cementColor;
+uniform float grainScale;
+uniform float roughness;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    float noise = czm_snoise(materialInput.st / grainScale);
+    noise = pow(noise, 5.0) * roughness;
+   
+    vec4 color = cementColor;
+    color.rgb += noise;
+    
+    material.diffuse = color.rgb;
+    material.alpha = color.a;
+    
+    return material;
+}

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

@@ -0,0 +1,20 @@
+// This file is automatically rebuilt by the Cesium build process.
+/*global define*/
+define(function() {
+    "use strict";
+    return "uniform vec4 cementColor;\n\
+uniform float grainScale;\n\
+uniform float roughness;\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+czm_material material = czm_getDefaultMaterial(materialInput);\n\
+float noise = czm_snoise(materialInput.st / grainScale);\n\
+noise = pow(noise, 5.0) * roughness;\n\
+vec4 color = cementColor;\n\
+color.rgb += noise;\n\
+material.diffuse = color.rgb;\n\
+material.alpha = color.a;\n\
+return material;\n\
+}\n\
+";
+});

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

@@ -0,0 +1,38 @@
+uniform vec4 lightColor;
+uniform vec4 darkColor;
+uniform vec2 repeat;
+
+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
+    
+    // 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);
+    
+    //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 = mix(midColor, currentColor, val1);
+    material.diffuse = color.rgb;
+    material.alpha = color.a;
+    
+    return material;
+}

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

@@ -0,0 +1,32 @@
+// This file is automatically rebuilt by the Cesium build process.
+/*global define*/
+define(function() {
+    "use strict";
+    return "uniform vec4 lightColor;\n\
+uniform vec4 darkColor;\n\
+uniform vec2 repeat;\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+czm_material material = czm_getDefaultMaterial(materialInput);\n\
+vec2 st = materialInput.st;\n\
+const float fuzz = 0.03;\n\
+float b = mod(floor(repeat.s * st.s) + floor(repeat.t * st.t), 2.0);\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\
+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);\n\
+vec4 midColor = (lightColor + darkColor) / 2.0;\n\
+vec4 currentColor = mix(lightColor, darkColor, b);\n\
+vec4 color = mix(midColor, currentColor, val1);\n\
+material.diffuse = color.rgb;\n\
+material.alpha = color.a;\n\
+return material;\n\
+}\n\
+";
+});

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

@@ -0,0 +1,17 @@
+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);
+    material.diffuse = color.rgb;
+    material.alpha = color.a;
+    
+    return material;
+}

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

@@ -0,0 +1,18 @@
+// This file is automatically rebuilt by the Cesium build process.
+/*global define*/
+define(function() {
+    "use strict";
+    return "uniform vec4 lightColor;\n\
+uniform vec4 darkColor;\n\
+uniform vec2 repeat;\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+czm_material material = czm_getDefaultMaterial(materialInput);\n\
+float b = smoothstep(0.3, 0.32, length(fract(repeat * materialInput.st) - 0.5));\n\
+vec4 color = mix(lightColor, darkColor, b);\n\
+material.diffuse = color.rgb;\n\
+material.alpha = color.a;\n\
+return material;\n\
+}\n\
+";
+});

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

@@ -0,0 +1,23 @@
+uniform vec4 color;
+uniform float time;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    float alpha = 1.0;
+    if (time != 1.0)
+    {
+        float t = 0.5 + (0.5 * czm_snoise(materialInput.str / (1.0 / 10.0)));   // Scale [-1, 1] to [0, 1]
+    
+        if (t > time)
+        {
+            alpha = 0.0;
+        }
+    }
+    
+    material.diffuse = color.rgb;
+    material.alpha = color.a * alpha;
+
+    return material;
+}

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

@@ -0,0 +1,24 @@
+// This file is automatically rebuilt by the Cesium build process.
+/*global define*/
+define(function() {
+    "use strict";
+    return "uniform vec4 color;\n\
+uniform float time;\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+czm_material material = czm_getDefaultMaterial(materialInput);\n\
+float alpha = 1.0;\n\
+if (time != 1.0)\n\
+{\n\
+float t = 0.5 + (0.5 * czm_snoise(materialInput.str / (1.0 / 10.0)));\n\
+if (t > time)\n\
+{\n\
+alpha = 0.0;\n\
+}\n\
+}\n\
+material.diffuse = color.rgb;\n\
+material.alpha = color.a * alpha;\n\
+return material;\n\
+}\n\
+";
+});

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

@@ -0,0 +1,18 @@
+uniform vec4 lightColor;
+uniform vec4 darkColor;
+uniform float frequency;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+    
+    // From Stefan Gustavson's Procedural Textures in GLSL in OpenGL Insights
+    vec2 F = czm_cellular(materialInput.st * frequency);
+    float t = 0.1 + (F.y - F.x);
+        
+    vec4 color = mix(lightColor, darkColor, t);
+    material.diffuse = color.rgb;
+    material.alpha = color.a;
+    
+    return material;
+}

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

@@ -0,0 +1,19 @@
+// This file is automatically rebuilt by the Cesium build process.
+/*global define*/
+define(function() {
+    "use strict";
+    return "uniform vec4 lightColor;\n\
+uniform vec4 darkColor;\n\
+uniform float frequency;\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+czm_material material = czm_getDefaultMaterial(materialInput);\n\
+vec2 F = czm_cellular(materialInput.st * frequency);\n\
+float t = 0.1 + (F.y - F.x);\n\
+vec4 color = mix(lightColor, darkColor, t);\n\
+material.diffuse = color.rgb;\n\
+material.alpha = color.a;\n\
+return material;\n\
+}\n\
+";
+});

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

@@ -0,0 +1,12 @@
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+    
+    vec3 normalWC = normalize(czm_inverseViewRotation * material.normal);
+    vec3 positionWC = normalize(czm_inverseViewRotation * materialInput.positionToEyeEC);
+    float cosAngIncidence = max(dot(normalWC, positionWC), 0.0);
+    
+    material.diffuse = mix(reflection.diffuse, refraction.diffuse, cosAngIncidence);
+    
+    return material;
+}

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

@@ -0,0 +1,15 @@
+// This file is automatically rebuilt by the Cesium build process.
+/*global define*/
+define(function() {
+    "use strict";
+    return "czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+czm_material material = czm_getDefaultMaterial(materialInput);\n\
+vec3 normalWC = normalize(czm_inverseViewRotation * material.normal);\n\
+vec3 positionWC = normalize(czm_inverseViewRotation * materialInput.positionToEyeEC);\n\
+float cosAngIncidence = max(dot(normalWC, positionWC), 0.0);\n\
+material.diffuse = mix(reflection.diffuse, refraction.diffuse, cosAngIncidence);\n\
+return material;\n\
+}\n\
+";
+});

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

@@ -0,0 +1,28 @@
+uniform vec4 grassColor;
+uniform vec4 dirtColor;
+uniform float patchiness;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+    
+    vec2 st = materialInput.st;
+    float noise1 = (czm_snoise(st * patchiness * 1.0)) * 1.0;
+    float noise2 = (czm_snoise(st * patchiness * 2.0)) * 0.5;
+    float noise3 = (czm_snoise(st * patchiness * 4.0)) * 0.25;
+    float noise = sin(noise1 + noise2 + noise3) * 0.1;
+    
+    vec4 color = mix(grassColor, dirtColor, noise);
+    
+    //Make thatch patterns
+    float verticalNoise = czm_snoise(vec2(st.x * 100.0, st.y * 20.0)) * 0.02;
+    float horizontalNoise = czm_snoise(vec2(st.x * 20.0, st.y * 100.0)) * 0.02;
+    float stripeNoise = min(verticalNoise, horizontalNoise);
+ 
+    color.rgb += stripeNoise;
+    
+    material.diffuse = color.rgb;
+    material.alpha = color.a;
+    
+    return material;
+}