Improved Terrain Shadows

Source/Renderer/AutomaticUniforms.js

@@ -1588,6 +1588,34 @@ define([
             getValue : function(uniformState) {
                 return uniformState.shadowMap.texelStepSize;
             }
+        }),
+
+        /**
+         * An automatic GLSL uniform representing the shadow map cascade distances.
+         *
+         * @alias czm_shadowMapCascadeDistances
+         * @glslUniform
+         */
+        czm_shadowMapCascadeDistances : new AutomaticUniform({
+            size : 1,
+            datatype : WebGLConstants.FLOAT_VEC4,
+            getValue : function(uniformState) {
+                return uniformState.shadowMap.cascadeDistances;
+            }
+        }),
+
+        /**
+         * An automatic GLSL uniform representing the shadow map distance.
+         *
+         * @alias czm_shadowMapDistance
+         * @glslUniform
+         */
+        czm_shadowMapDistance : new AutomaticUniform({
+            size : 1,
+            datatype : WebGLConstants.FLOAT,
+            getValue : function(uniformState) {
+                return uniformState.shadowMap.distance;
+            }
         })
     };
 

Source/Scene/Camera.js

@@ -253,7 +253,7 @@ define([
     function updateViewMatrix(camera) {
         Matrix4.computeView(camera._direction, camera._up, camera._right, camera._position, camera._viewMatrix);
         Matrix4.multiply(camera._viewMatrix, camera._actualInvTransform, camera._viewMatrix);
-        Matrix4.inverseTransformation(camera._viewMatrix, camera._invViewMatrix);
+        Matrix4.inverse(camera._viewMatrix, camera._invViewMatrix);
     }
 
     var scratchCartographic = new Cartographic();

Source/Scene/Globe.js

@@ -194,7 +194,7 @@ define([
          * @type {Boolean}
          * @default true
          */
-        this.castShadows = true;
+        this.castShadows = false;
 
         /**
          * Determines whether the globe will receive shadows when shadow mapping is enabled.

Source/Scene/GlobeSurfaceShaderSet.js

@@ -203,7 +203,7 @@ define([
             if (receiveShadows) {
                 var normalVarying = hasVertexNormals ? 'v_normalEC' : undefined;
                 vs.sources[1] = ShadowMapShader.createShadowReceiveVertexShader(vs.sources[1], frameState);
-                fs.sources[0] = ShadowMapShader.createShadowReceiveFragmentShader(fs.sources[0], frameState, normalVarying, 'v_positionEC');
+                fs.sources[0] = ShadowMapShader.createShadowReceiveFragmentShader(fs.sources[0], frameState, normalVarying, 'v_positionEC', true, fs.defines);
             }
 
             var shader = ShaderProgram.fromCache({
@@ -286,9 +286,13 @@ define([
             vs.sources.push(getPositionMode(sceneMode));
             vs.sources.push(get2DYPositionFraction(useWebMercatorProjection));
 
+            // Output v_positionEC
+            vs.defines.push('ENABLE_DAYNIGHT_SHADING');
+
             vs.sources[1] = ShadowMapShader.createShadowCastVertexShader(vs.sources[1], frameState, 'v_positionEC');
             fs.sources[0] = ShadowMapShader.createShadowCastFragmentShader(fs.sources[0], frameState, true, 'v_positionEC');
 
+
             shadowCastShader = this._shadowCastPrograms[flags] = ShaderProgram.fromCache({
                 context : frameState.context,
                 vertexShaderSource : vs,

Source/Scene/GlobeSurfaceTileProvider.js

@@ -503,6 +503,7 @@ define([
     };
 
     var modifiedModelViewScratch = new Matrix4();
+    var modifiedModelViewProjectionScratch = new Matrix4();
     var tileRectangleScratch = new Cartesian4();
     var rtcScratch = new Cartesian3();
     var centerEyeScratch = new Cartesian3();
@@ -676,6 +677,14 @@ define([
                 Matrix4.setTranslation(viewMatrix, centerEye, modifiedModelViewScratch);
                 return modifiedModelViewScratch;
             },
+            u_modifiedModelViewProjection : function() {
+                var viewMatrix = frameState.context.uniformState.view;
+                var projectionMatrix = frameState.context.uniformState.projection;
+                var centerEye = Matrix4.multiplyByPoint(viewMatrix, this.center3D, centerEyeScratch);
+                Matrix4.setTranslation(viewMatrix, centerEye, modifiedModelViewProjectionScratch);
+                Matrix4.multiply(projectionMatrix, modifiedModelViewProjectionScratch, modifiedModelViewProjectionScratch);
+                return modifiedModelViewProjectionScratch;
+            },
             u_dayTextures : function() {
                 return this.dayTextures;
             },

Source/Scene/Model.js

@@ -1511,18 +1511,22 @@ define([
                 attributeLocations : attributeLocations
             });
         }
-
+        
         // Modify draw program to receive shadows
+        var shadowDefines = [];
         if (shadowsEnabled && model.receiveShadows) {
             drawVS = ShadowMapShader.createShadowReceiveVertexShader(drawVS, frameState);
             // TODO : assumes the shader has these varyings, which may not be true for some models
-            drawFS = ShadowMapShader.createShadowReceiveFragmentShader(drawFS, frameState, 'v_normal', 'v_positionEC');
+            drawFS = ShadowMapShader.createShadowReceiveFragmentShader(drawFS, frameState, 'v_normal', 'v_positionEC', false, shadowDefines);
         }
 
         model._rendererResources.programs[id] = ShaderProgram.fromCache({
             context : context,
             vertexShaderSource : drawVS,
-            fragmentShaderSource : drawFS,
+            fragmentShaderSource : new ShaderSource({
+                sources : [drawFS],
+                defines : shadowDefines
+            }),
             attributeLocations : attributeLocations
         });
 

Source/Scene/Primitive.js

@@ -1155,16 +1155,20 @@ define([
         validateShaderMatching(primitive._pickSP, attributeLocations);
 
         // Modify program to receive shadows
+        var shadowDefines = [];
         if (shadowsEnabled && primitive._receiveShadows) {
             vs = ShadowMapShader.createShadowReceiveVertexShader(vs, frameState);
-            fs = ShadowMapShader.createShadowReceiveFragmentShader(fs, frameState, 'v_normalEC', 'v_positionEC');
+            fs = ShadowMapShader.createShadowReceiveFragmentShader(fs, frameState, 'v_normalEC', 'v_positionEC', false, shadowDefines);
         }
 
         primitive._sp = ShaderProgram.replaceCache({
             context : context,
             shaderProgram : primitive._sp,
             vertexShaderSource : vs,
-            fragmentShaderSource : fs,
+            fragmentShaderSource : new ShaderSource({
+                sources : [fs],
+                defines : shadowDefines
+            }),
             attributeLocations : attributeLocations
         });
         validateShaderMatching(primitive._sp, attributeLocations);

Source/Scene/Scene.js

@@ -1687,43 +1687,62 @@ define([
 
     function getShadowMapCommands(scene) {
         // TODO : temporary solution for testing
-        var shadowMapCommands = [];
+        var terrainCommands = [];
+        var primitiveCommands = [];
         var frustumCommandsList = scene._frustumCommandsList;
         var numFrustums = frustumCommandsList.length;
         for (var i = 0; i < numFrustums; ++i) {
             var frustumCommands = frustumCommandsList[i];
             var startPass = Pass.GLOBE;
             var endPass = Pass.TRANSLUCENT;
             for (var pass = startPass; pass <= endPass; ++pass) {
+                var shadowCommands = (pass === Pass.GLOBE) ? terrainCommands : primitiveCommands;
                 var commands = frustumCommands.commands[pass];
                 var length = frustumCommands.indices[pass];
                 for (var j = 0; j < length; ++j) {
                     var command = commands[j];
                     if (command.castShadows) {
-                        shadowMapCommands.push(command);
+                        shadowCommands.push(command);
                     }
                 }
             }
         }
-        return shadowMapCommands;
+        return [terrainCommands, primitiveCommands];
     }
 
     function executeShadowMapCommands(scene) {
         var context = scene.context;
         var uniformState = context.uniformState;
         var shadowMap = scene.shadowMap;
-        var renderState = shadowMap.renderState;
+        var isPointLight = shadowMap.isPointLight;
 
         var commands = getShadowMapCommands(scene);
-        var numberOfCommands = commands.length;
+        var terrainCommands = commands[0];
+        var primitiveCommands = commands[1];
+
+        var j;
+        var command;
+
         var numberOfPasses = shadowMap.numberOfPasses;
         for (var i = 0; i < numberOfPasses; ++i) {
             uniformState.updateCamera(shadowMap.passCameras[i]);
             var passState = shadowMap.passStates[i];
             shadowMap.updatePass(context, i);
-            for (var j = 0; j < numberOfCommands; ++j) {
-                var command = commands[j];
-                executeCommand(command, scene, context, passState, renderState, command.shadowCastProgram);
+
+            // Execute terrain commands
+            var terrainRenderState = isPointLight ? shadowMap.pointRenderState : shadowMap.terrainRenderState;
+            var numberOfTerrainCommands = terrainCommands.length;
+            for (j = 0; j < numberOfTerrainCommands; ++j) {
+                command = terrainCommands[j];
+                executeCommand(command, scene, context, passState, terrainRenderState, command.shadowCastProgram);
+            }
+
+            // Execute primitive commands
+            var primitiveRenderState = isPointLight ? shadowMap.pointRenderState : shadowMap.primitiveRenderState;
+            var numberOfPrimitiveCommands = primitiveCommands.length;
+            for (j = 0; j < numberOfPrimitiveCommands; ++j) {
+                command = primitiveCommands[j];
+                executeCommand(command, scene, context, passState, primitiveRenderState, command.shadowCastProgram);
             }
         }
     }
@@ -1733,7 +1752,6 @@ define([
 
         var viewport = passState.viewport;
 
-        var uniformState = context.uniformState;
         var frameState = scene._frameState;
         var camera = frameState.camera;
         var mode = frameState.mode;
@@ -1744,7 +1762,7 @@ define([
             updateAndClearFramebuffers(scene, passState, backgroundColor, picking);
             executeComputeCommands(scene);
 
-            if (scene.shadowMap.enabled) {
+            if (scene.shadowMap.enabled && !picking) {
                 executeShadowMapCommands(scene);
             }
 
@@ -1895,7 +1913,7 @@ define([
             updateAndClearFramebuffers(scene, passState, backgroundColor, picking);
             executeComputeCommands(scene);
 
-            if (scene.shadowMap.enabled) {
+            if (scene.shadowMap.enabled && !picking) {
                 executeShadowMapCommands(scene);
             }
         }