cesium 0.13.2 → 0.14.0

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

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

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

@@ -4,15 +4,16 @@ define(function() {
     "use strict";
     return "attribute vec4 position;\n\
 attribute vec3 normal;\n\
+\n\
 varying vec3 v_positionWC;\n\
 varying vec3 v_positionEC;\n\
 varying vec3 v_normalEC;\n\
+\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\
-";
+    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\
+}";
 });

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

@@ -4,35 +4,43 @@ define(function() {
     "use strict";
     return "uniform vec3 u_radii;\n\
 uniform vec3 u_oneOverEllipsoidRadiiSquared;\n\
+\n\
 varying vec3 v_positionEC;\n\
+\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\
+    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\
+    \n\
+    if (czm_isEmpty(intersection))\n\
+    {\n\
+        discard;\n\
+    }\n\
+        \n\
+    // Pick the intersection point based on if the viewer is outside or inside the ellipsoid\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;   // normalized surface normal (always facing the viewer) in model coordinates\n\
+    vec3 normalEC = normalize(czm_normal * normalMC);                  // normalized surface normal in eye coordiantes\n\
+    \n\
+    vec2 st = czm_ellipsoidWgs84TextureCoordinates(geodeticNormal);\n\
+    vec3 positionToEyeEC = -positionEC; \n\
+                \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\
+\n\
+	gl_FragColor = czm_phong(normalize(positionToEyeEC), material);\n\
 }\n\
 ";
 });

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

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

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

@@ -5,19 +5,27 @@ define(function() {
     return "uniform vec4 asphaltColor;\n\
 uniform float bumpSize;\n\
 uniform float roughness;\n\
+\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\
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    // From Stefan Gustavson's Procedural Textures in GLSL in OpenGL Insights\n\
+    //Main cellular pattern\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\
+    \n\
+    //Extra bumps for roughness\n\
+    float noise = czm_snoise(st / bumpSize);\n\
+    noise = pow(noise, 5.0) * roughness;\n\
+    color.rgb += noise;\n\
+\n\
+    material.diffuse = color.rgb;\n\
+    material.alpha = color.a;\n\
+    \n\
+    return material;\n\
 }\n\
 ";
 });

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

@@ -5,15 +5,19 @@ define(function() {
     return "uniform vec4 lightColor;\n\
 uniform vec4 darkColor;\n\
 uniform float frequency;\n\
+\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\
-";
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    // From Stefan Gustavson's Procedural Textures in GLSL in OpenGL Insights\n\
+    vec2 F = czm_cellular(materialInput.st * frequency);\n\
+    float t = 1.0 - F.x * F.x;\n\
+    \n\
+    vec4 color = mix(lightColor, darkColor, t);\n\
+    material.diffuse = color.rgb;\n\
+    material.alpha = color.a;\n\
+    \n\
+    return material;\n\
+}";
 });

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

@@ -8,29 +8,40 @@ uniform vec2 brickSize;\n\
 uniform vec2 brickPct;\n\
 uniform float brickRoughness;\n\
 uniform float mortarRoughness;\n\
+\n\
 #define Integral(x, p) ((floor(x) * p) + max(fract(x) - (1.0 - p), 0.0))\n\
+\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\
-";
+    czm_material material = czm_getDefaultMaterial(materialInput);\n\
+\n\
+    // From OpenGL Shading Language (3rd edition) pg. 194, 501\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\
+        \n\
+    //calculate whether to use brick or mortar (does AA)\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\
+    \n\
+    //Apply noise to brick\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\
+    \n\
+    //Apply noise to mortar\n\
+    vec2 mortarScaled = st / 0.005;\n\
+    float mortarNoise = max(czm_snoise(mortarScaled) * mortarRoughness, 0.0);\n\
+    color.rgb += mortarNoise * (1.0 - useBrickFinal); \n\
+\n\
+    material.diffuse = color.rgb;\n\
+    material.alpha = color.a;\n\
+    \n\
+    return material;\n\
+}";
 });