cesium 0.13.0

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

@@ -0,0 +1,126 @@
+#ifdef GL_OES_standard_derivatives
+    #extension GL_OES_standard_derivatives : enable
+#endif  
+
+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;
+    
+    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;
+    
+    vec3 normalEC = normalize(v_normalEC);
+    normalEC = mix(normalEC, -normalEC, step(normalEC.z, 0.0));  // Normal facing viewer
+    materialInput.normalEC = normalEC;
+    
+    czm_material material = czm_getMaterial(materialInput);
+    return czm_phong(normalize(positionToEyeEC), material);
+}
+
+#endif
+
+bool ellipsoidSensorIntersection(czm_raySegment ellipsoidInterval)
+{
+	if (czm_isEmpty(ellipsoidInterval))
+	{
+	    return false;
+	}
+
+    float t = ellipsoidInterval.start;
+
+#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;
+#endif
+
+    float width = 2.0;  // TODO: Expose as a uniform
+    epsilon *= width;           
+
+    return czm_equalsEpsilon(t, length(v_positionEC), epsilon);
+}
+
+vec4 shade(czm_raySegment ellipsoidInterval)
+{
+#ifdef RENDER_FOR_PICK
+    return u_pickColor;
+#else
+    if (u_showIntersection && ellipsoidSensorIntersection(ellipsoidInterval))
+    {
+        return getIntersectionColor(u_sensorRadius, v_positionEC);
+    }
+    return getColor(u_sensorRadius, v_positionEC);
+#endif
+}
+
+bool 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);
+}
+
+void main()
+{
+    vec3 sensorVertexWC = czm_model[3].xyz;      // (0.0, 0.0, 0.0) in model coordinates
+    vec3 sensorVertexEC = czm_modelView[3].xyz;  // (0.0, 0.0, 0.0) in model coordinates
+
+    czm_ellipsoid ellipsoid = czm_getWgs84EllipsoidEC();
+
+    // 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))
+	    {
+            discard;
+	    }
+
+	    // Discard if in the sensor's shadow
+	    if (inSensorShadow(sensorVertexWC, ellipsoid, v_positionEC))
+	    {
+	        discard;
+	    }
+    }
+
+    // Discard if not in the sensor's sphere
+    // PERFORMANCE_IDEA: We can omit this check if the radius is Number.POSITIVE_INFINITY.
+    if (distance(v_positionEC, sensorVertexEC) > u_sensorRadius)
+    {
+        discard;
+    }
+
+    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);
+}

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

@@ -0,0 +1,95 @@
+// This file is automatically rebuilt by the Cesium build process.
+/*global define*/
+define(function() {
+    "use strict";
+    return "#ifdef GL_OES_standard_derivatives\n\
+#extension GL_OES_standard_derivatives : enable\n\
+#endif\n\
+uniform bool u_showIntersection;\n\
+uniform bool u_showThroughEllipsoid;\n\
+uniform float u_sensorRadius;\n\
+uniform vec4 u_pickColor;\n\
+varying vec3 v_positionWC;\n\
+varying vec3 v_positionEC;\n\
+varying vec3 v_normalEC;\n\
+#ifndef RENDER_FOR_PICK\n\
+vec4 getColor(float sensorRadius, vec3 pointEC)\n\
+{\n\
+czm_materialInput materialInput;\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\
+vec3 positionToEyeEC = -v_positionEC;\n\
+materialInput.positionToEyeEC = positionToEyeEC;\n\
+vec3 normalEC = normalize(v_normalEC);\n\
+normalEC = mix(normalEC, -normalEC, step(normalEC.z, 0.0));\n\
+materialInput.normalEC = normalEC;\n\
+czm_material material = czm_getMaterial(materialInput);\n\
+return czm_phong(normalize(positionToEyeEC), material);\n\
+}\n\
+#endif\n\
+bool ellipsoidSensorIntersection(czm_raySegment ellipsoidInterval)\n\
+{\n\
+if (czm_isEmpty(ellipsoidInterval))\n\
+{\n\
+return false;\n\
+}\n\
+float t = ellipsoidInterval.start;\n\
+#ifdef GL_OES_standard_derivatives\n\
+float epsilon = max(abs(dFdx(t)), abs(dFdy(t)));\n\
+if (epsilon >= ellipsoidInterval.start)\n\
+{\n\
+return false;\n\
+}\n\
+#else\n\
+float epsilon = t / 500.0;\n\
+#endif\n\
+float width = 2.0;\n\
+epsilon *= width;\n\
+return czm_equalsEpsilon(t, length(v_positionEC), epsilon);\n\
+}\n\
+vec4 shade(czm_raySegment ellipsoidInterval)\n\
+{\n\
+#ifdef RENDER_FOR_PICK\n\
+return u_pickColor;\n\
+#else\n\
+if (u_showIntersection && ellipsoidSensorIntersection(ellipsoidInterval))\n\
+{\n\
+return getIntersectionColor(u_sensorRadius, v_positionEC);\n\
+}\n\
+return getColor(u_sensorRadius, v_positionEC);\n\
+#endif\n\
+}\n\
+bool czm_pointInEllipsoid(czm_ellipsoid ellipsoid, vec3 point)\n\
+{\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\
+}\n\
+void main()\n\
+{\n\
+vec3 sensorVertexWC = czm_model[3].xyz;\n\
+vec3 sensorVertexEC = czm_modelView[3].xyz;\n\
+czm_ellipsoid ellipsoid = czm_getWgs84EllipsoidEC();\n\
+if (!u_showThroughEllipsoid)\n\
+{\n\
+if (czm_pointInEllipsoid(ellipsoid, v_positionWC))\n\
+{\n\
+discard;\n\
+}\n\
+if (inSensorShadow(sensorVertexWC, ellipsoid, v_positionEC))\n\
+{\n\
+discard;\n\
+}\n\
+}\n\
+if (distance(v_positionEC, sensorVertexEC) > u_sensorRadius)\n\
+{\n\
+discard;\n\
+}\n\
+czm_ray ray = czm_ray(vec3(0.0), normalize(v_positionEC));\n\
+czm_raySegment ellipsoidInterval = czm_rayEllipsoidIntersectionInterval(ray, ellipsoid);\n\
+gl_FragColor = shade(ellipsoidInterval);\n\
+}\n\
+";
+});

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

@@ -0,0 +1,14 @@
+attribute vec4 position;
+attribute vec3 normal;
+
+varying vec3 v_positionWC;
+varying vec3 v_positionEC;
+varying vec3 v_normalEC;
+
+void main()
+{
+    gl_Position = czm_modelViewProjection * position;
+    v_positionWC = (czm_model * position).xyz;
+    v_positionEC = (czm_modelView * position).xyz;
+    v_normalEC = czm_normal * normal;
+}

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

@@ -0,0 +1,18 @@
+// This file is automatically rebuilt by the Cesium build process.
+/*global define*/
+define(function() {
+    "use strict";
+    return "attribute vec4 position;\n\
+attribute vec3 normal;\n\
+varying vec3 v_positionWC;\n\
+varying vec3 v_positionEC;\n\
+varying vec3 v_normalEC;\n\
+void main()\n\
+{\n\
+gl_Position = czm_modelViewProjection * position;\n\
+v_positionWC = (czm_model * position).xyz;\n\
+v_positionEC = (czm_modelView * position).xyz;\n\
+v_normalEC = czm_normal * normal;\n\
+}\n\
+";
+});

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

@@ -0,0 +1,40 @@
+uniform vec3 u_radii;
+uniform vec3 u_oneOverEllipsoidRadiiSquared;
+
+varying vec3 v_positionEC;
+
+void main()
+{
+    czm_ellipsoid ellipsoid = czm_ellipsoidNew(czm_modelView[3].xyz, u_radii);
+    vec3 direction = normalize(v_positionEC);
+    czm_ray ray = czm_ray(vec3(0.0), direction);
+    czm_raySegment intersection = czm_rayEllipsoidIntersectionInterval(ray, ellipsoid);
+    
+    if (czm_isEmpty(intersection))
+    {
+        discard;
+    }
+        
+    // Pick the intersection point based on if the viewer is outside or inside the ellipsoid
+    bool hitFrontFace = (intersection.start != 0.0);
+    vec3 positionEC = czm_pointAlongRay(ray, hitFrontFace ? intersection.start : intersection.stop);
+    vec3 positionMC = (czm_inverseModelView * vec4(positionEC, 1.0)).xyz;
+    vec3 geodeticNormal = normalize(czm_geodeticSurfaceNormal(positionMC, vec3(0.0), u_oneOverEllipsoidRadiiSquared));
+    vec3 normalMC = hitFrontFace ? geodeticNormal : -geodeticNormal;   // normalized surface normal (always facing the viewer) in model coordinates
+    vec3 normalEC = normalize(czm_normal * normalMC);                  // normalized surface normal in eye coordiantes
+    
+    vec2 st = czm_ellipsoidWgs84TextureCoordinates(geodeticNormal);
+    vec3 positionToEyeEC = -positionEC; 
+                
+    czm_materialInput materialInput;
+    materialInput.s = st.s;
+    materialInput.st = st;
+    materialInput.str = (positionMC + u_radii) / u_radii;
+    materialInput.normalEC = normalEC;
+    materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(positionMC, normalEC);
+    materialInput.positionToEyeEC = positionToEyeEC;
+    materialInput.positionMC = positionMC;
+    czm_material material = czm_getMaterial(materialInput);
+
+	gl_FragColor = czm_phong(normalize(positionToEyeEC), material);
+}

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

@@ -0,0 +1,38 @@
+// This file is automatically rebuilt by the Cesium build process.
+/*global define*/
+define(function() {
+    "use strict";
+    return "uniform vec3 u_radii;\n\
+uniform vec3 u_oneOverEllipsoidRadiiSquared;\n\
+varying vec3 v_positionEC;\n\
+void main()\n\
+{\n\
+czm_ellipsoid ellipsoid = czm_ellipsoidNew(czm_modelView[3].xyz, u_radii);\n\
+vec3 direction = normalize(v_positionEC);\n\
+czm_ray ray = czm_ray(vec3(0.0), direction);\n\
+czm_raySegment intersection = czm_rayEllipsoidIntersectionInterval(ray, ellipsoid);\n\
+if (czm_isEmpty(intersection))\n\
+{\n\
+discard;\n\
+}\n\
+bool hitFrontFace = (intersection.start != 0.0);\n\
+vec3 positionEC = czm_pointAlongRay(ray, hitFrontFace ? intersection.start : intersection.stop);\n\
+vec3 positionMC = (czm_inverseModelView * vec4(positionEC, 1.0)).xyz;\n\
+vec3 geodeticNormal = normalize(czm_geodeticSurfaceNormal(positionMC, vec3(0.0), u_oneOverEllipsoidRadiiSquared));\n\
+vec3 normalMC = hitFrontFace ? geodeticNormal : -geodeticNormal;\n\
+vec3 normalEC = normalize(czm_normal * normalMC);\n\
+vec2 st = czm_ellipsoidWgs84TextureCoordinates(geodeticNormal);\n\
+vec3 positionToEyeEC = -positionEC;\n\
+czm_materialInput materialInput;\n\
+materialInput.s = st.s;\n\
+materialInput.st = st;\n\
+materialInput.str = (positionMC + u_radii) / u_radii;\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\
+gl_FragColor = czm_phong(normalize(positionToEyeEC), material);\n\
+}\n\
+";
+});

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

@@ -0,0 +1,26 @@
+attribute vec3 position;
+
+uniform vec3 u_radii;
+
+varying vec3 v_positionEC;
+
+void main() 
+{
+    // In the vertex data, the cube goes from (-1.0, -1.0, -1.0) to (1.0, 1.0, 1.0) in model coordinates.
+    // Scale to consider the radii.  We could also do this once on the CPU when using the BoxTessellator,
+    // but doing it here allows us to change the radii without rewriting the vertex data, and
+    // allows all ellipsoids to reuse the same vertex data.
+    vec4 p = vec4(u_radii * position, 1.0);
+    
+    v_positionEC = (czm_modelView * p).xyz;     // position in eye coordinates
+    gl_Position = czm_modelViewProjection * p;  // position in clip coordinates
+    
+    // With multi-frustum, when the ellipsoid primitive is positioned on the intersection of two frustums 
+    // and close to terrain, the terrain (writes depth) in the closest frustum can overwrite part of the 
+    // ellipsoid (does not write depth) that was rendered in the farther frustum.
+    //
+    // Here, we clamp the depth in the vertex shader to avoid being overwritten; however, this creates
+    // artifacts since some fragments can be alpha blended twice.  This is solved by only rendering
+    // the ellipsoid in the closest frustum to the viewer.
+    gl_Position.z = clamp(gl_Position.z, gl_DepthRange.near, gl_DepthRange.far);
+}

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

@@ -0,0 +1,16 @@
+// This file is automatically rebuilt by the Cesium build process.
+/*global define*/
+define(function() {
+    "use strict";
+    return "attribute vec3 position;\n\
+uniform vec3 u_radii;\n\
+varying vec3 v_positionEC;\n\
+void main()\n\
+{\n\
+vec4 p = vec4(u_radii * position, 1.0);\n\
+v_positionEC = (czm_modelView * p).xyz;\n\
+gl_Position = czm_modelViewProjection * p;\n\
+gl_Position.z = clamp(gl_Position.z, gl_DepthRange.near, gl_DepthRange.far);\n\
+}\n\
+";
+});

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

@@ -0,0 +1,25 @@
+uniform vec4 asphaltColor;
+uniform float bumpSize;
+uniform float roughness;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    // From Stefan Gustavson's Procedural Textures in GLSL in OpenGL Insights
+    //Main cellular pattern
+    vec4 color = asphaltColor;
+    vec2 st = materialInput.st;
+    vec2 F = czm_cellular(st / bumpSize);
+    color.rgb -= (F.x / F.y) * 0.1;
+    
+    //Extra bumps for roughness
+    float noise = czm_snoise(st / bumpSize);
+    noise = pow(noise, 5.0) * roughness;
+    color.rgb += noise;
+
+    material.diffuse = color.rgb;
+    material.alpha = color.a;
+    
+    return material;
+}

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

@@ -0,0 +1,23 @@
+// This file is automatically rebuilt by the Cesium build process.
+/*global define*/
+define(function() {
+    "use strict";
+    return "uniform vec4 asphaltColor;\n\
+uniform float bumpSize;\n\
+uniform float roughness;\n\
+czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+{\n\
+czm_material material = czm_getDefaultMaterial(materialInput);\n\
+vec4 color = asphaltColor;\n\
+vec2 st = materialInput.st;\n\
+vec2 F = czm_cellular(st / bumpSize);\n\
+color.rgb -= (F.x / F.y) * 0.1;\n\
+float noise = czm_snoise(st / bumpSize);\n\
+noise = pow(noise, 5.0) * roughness;\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/BlobMaterial.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 = 1.0 - F.x * F.x;
+    
+    vec4 color = mix(lightColor, darkColor, t);
+    material.diffuse = color.rgb;
+    material.alpha = color.a;
+    
+    return material;
+}