Fix shadow volumes by using a different technique.

Source/Scene/GroundPolygon.js

@@ -22,6 +22,7 @@ define([
         '../Shaders/ShadowVolumeVS',
         './BlendingState',
         './CullFace',
+        './DepthFunction',
         './Pass',
         './StencilFunction',
         './StencilOperation'
@@ -48,6 +49,7 @@ define([
         ShadowVolumeVS,
         BlendingState,
         CullFace,
+        DepthFunction,
         Pass,
         StencilFunction,
         StencilOperation) {
@@ -316,7 +318,49 @@ define([
         }
 
         if (!defined(this._stencilPassCommand)) {
-            var stencilPassRenderState = context.createRenderState({
+            var stencilPreloadRenderState = context.createRenderState({
+                colorMask : {
+                    red : false,
+                    green : false,
+                    blue : false,
+                    alpha : false
+                },
+                stencilTest : {
+                    enabled : true,
+                    frontFunction : StencilFunction.ALWAYS,
+                    frontOperation : {
+                        fail : StencilOperation.KEEP,
+                        zFail : StencilOperation.DECREMENT_WRAP,
+                        zPass : StencilOperation.DECREMENT_WRAP
+                    },
+                    backFunction : StencilFunction.ALWAYS,
+                    backOperation : {
+                        fail : StencilOperation.KEEP,
+                        zFail : StencilOperation.INCREMENT_WRAP,
+                        zPass : StencilOperation.INCREMENT_WRAP
+                    },
+                    reference : 0,
+                    mask : ~0
+                },
+                depthTest : {
+                    enabled : false
+                },
+                depthMask : false
+            });
+
+            this._stencilPreloadCommand = new DrawCommand({
+                primitiveType : PrimitiveType.TRIANGLES,
+                vertexArray : this._va,
+                renderState : stencilPreloadRenderState,
+                shaderProgram : this._sp,
+                uniformMap : this._uniformMap,
+                boundingVolume : this._boundingSphere,
+                owner : this,
+                modelMatrix : Matrix4.IDENTITY,
+                pass : Pass.GROUND
+            });
+
+            var stencilDepthRenderState = context.createRenderState({
                 colorMask : {
                     red : false,
                     green : false,
@@ -341,15 +385,16 @@ define([
                     mask : ~0
                 },
                 depthTest : {
-                    enabled : true
+                    enabled : true,
+                    func : DepthFunction.LESS_OR_EQUAL
                 },
                 depthMask : false
             });
 
-            this._stencilPassCommand = new DrawCommand({
+            this._stencilDepthCommand = new DrawCommand({
                 primitiveType : PrimitiveType.TRIANGLES,
                 vertexArray : this._va,
-                renderState : stencilPassRenderState,
+                renderState : stencilDepthRenderState,
                 shaderProgram : this._sp,
                 uniformMap : this._uniformMap,
                 boundingVolume : this._boundingSphere,
@@ -376,12 +421,8 @@ define([
                     reference : 0,
                     mask : ~0
                 },
-                cull : {
-                    enabled : true,
-                    face : CullFace.BACK
-                },
                 depthTest : {
-                    enabled : true
+                    enabled : false
                 },
                 depthMask : false,
                 blending : BlendingState.ALPHA_BLEND
@@ -433,7 +474,7 @@ define([
             if (this.debugVolume) {
                 commandList.push(this._debugVolumeCommand);
             } else {
-                commandList.push(this._stencilPassCommand, this._colorPassCommand);
+                commandList.push(this._stencilPreloadCommand, this._stencilDepthCommand, this._colorPassCommand);
             }
         }
     };

Source/Shaders/ShadowVolumeFS.glsl

@@ -2,29 +2,20 @@
 #extension GL_EXT_frag_depth : enable
 #endif
 
-//varying vec3 v_pointEC;
+#ifdef GL_EXT_frag_depth
+// emulated noperspective
+varying float v_WindowZ;
+#endif
 
-void czm_writeDepthClampedToFarPlane()
+void writeDepthClampedToFarPlane()
 {
-/*
 #ifdef GL_EXT_frag_depth
-    vec4 pointCC = czm_projection * vec4(v_pointEC, 1.0);
-    float z = pointCC.z / pointCC.w;
-
-    float n = czm_depthRange.near;
-    float f = czm_depthRange.far;
-
-    float depth = (z * (f - n) + f + n) * 0.5;
-    depth = clamp(depth, n, f);
-    //gl_FragDepthEXT = depth;
-
-    //gl_FragDepthEXT = (z * (f - n) + f + n) * 0.5;
+    gl_FragDepthEXT = min(v_WindowZ * gl_FragCoord.w, 1.0);
 #endif
-*/
 }
 
 void main(void)
 {
     gl_FragColor = vec4(1.0, 1.0, 0.0, 0.5);
-    czm_writeDepthClampedToFarPlane();
+    writeDepthClampedToFarPlane();
 }

Source/Shaders/ShadowVolumeVS.glsl

@@ -6,40 +6,18 @@ attribute float extrude;
 uniform float centralBodyMinimumAltitude;
 uniform float LODNegativeToleranceOverDistance;
 
-vec4 clipPointToPlane(vec3 p0, vec3 p1, bool nearPlane)
+#ifdef GL_EXT_frag_depth
+// emulated noperspective
+varying float v_WindowZ;
+#endif
+
+vec4 depthClampFarPlane(vec4 vertexInClipCoordinates)
 {
-    const float offset = 1.0;
-    //const float denominatorEpsilon = czm_epsilon7;
-    const float denominatorEpsilon = 1e-15;
-
-    vec2 frustum = czm_currentFrustum;
-    float planeDistance = nearPlane ? frustum.x : frustum.y;
-
-    vec3 diff = p1 - p0;
-    float magnitude = length(diff);
-    vec3 direction = normalize(diff);
-    float denominator = -direction.z;
-    float pointDistance = -(planeDistance + p0.z);
-    bool behindPlane = nearPlane ? pointDistance < 0.0 : pointDistance > 0.0;
-
-    // point is behind the plane and not parallel
-    if (behindPlane && abs(denominator) > denominatorEpsilon)
-    {
-        // find intersection of ray and the plane
-        // t = (-dot(plane normal, point on plane) - dot(plane normal, ray origin)) / dot(plane normal, ray direction)
-        float t = (planeDistance + p0.z) / denominator;
-
-        // The intersection is on the segment
-        if (t >= 0.0 && t <= magnitude)
-        {
-            // compute intersection with plane slightly offset
-            // to prevent precision artifacts
-            t += offset;
-            p0 = p0 + t * direction;
-        }
-    }
-
-    return czm_projection * vec4(p0, 1.0);
+#ifdef GL_EXT_frag_depth
+    v_WindowZ = (0.5 * (vertexInClipCoordinates.z / vertexInClipCoordinates.w) + 0.5) * vertexInClipCoordinates.w;
+    vertexInClipCoordinates.z = min(vertexInClipCoordinates.z, vertexInClipCoordinates.w);
+#endif
+    return vertexInClipCoordinates;
 }
 
 void main()
@@ -48,20 +26,6 @@ void main()
 
     float delta = 1.0; // TODO: moving the vertex is a function of the view
 
-    vec3 origPosition = position.xyz;
-    vec3 movedPosition = position.xyz + normal * delta;
-
-    vec3 origPositionEC = (czm_modelViewRelativeToEye * vec4(origPosition, 1.0)).xyz;
-    vec3 movedPositionEC = (czm_modelViewRelativeToEye * vec4(movedPosition, 1.0)).xyz;
-
-    vec3 diff = movedPositionEC - origPositionEC;
-
-    if (extrude == 0.0)
-    {
-        gl_Position = clipPointToPlane(origPositionEC, movedPositionEC, diff.z < 0.0);
-    }
-    else
-    {
-        gl_Position = clipPointToPlane(movedPositionEC, origPositionEC, diff.z >= 0.0);
-    }
+    position.xyz = position.xyz + extrude * normal * delta;
+    gl_Position = depthClampFarPlane(czm_modelViewProjectionRelativeToEye * position);
 }