Cull shadow commands

Apps/Sandcastle/gallery/development/Shadows.html

@@ -252,13 +252,15 @@
 };
 
 // Temp values for testing
-viewModel.lightSource = 'Freeform';
+viewModel.lightSource = 'Spot';
 viewModel.lightHorizon = 71.0;
 viewModel.lightAngle = 40.0;
 viewModel.distance = 10000.0;
 viewModel.location = 'Pinnacle PA';
-viewModel.model = 'Shadow Tester 4';
-viewModel.modelPosition = 'Ground';
+viewModel.model = 'Shadow Tester';
+viewModel.modelPosition = 'Center';
+viewModel.terrain = true;
+viewModel.terrainCast = true;
 
 var uiOptions = {
     all : ['lightHorizon', 'lightAngle', 'distance', 'radius', 'terrainCast', 'cascades', 'cascadeColors', 'fitNearFar', 'softShadows'],
@@ -540,7 +542,7 @@
     spotLightCamera.frustum.fov = Cesium.Math.PI_OVER_TWO;
     spotLightCamera.frustum.aspectRatio = 1.0;
     spotLightCamera.frustum.near = 1.0;
-    spotLightCamera.frustum.far = 200.0;
+    spotLightCamera.frustum.far = 500.0;
     spotLightCamera.lookAt(center, new Cesium.Cartesian3(location.tilt, location.tilt, location.offsetZ));
 
     pointLightCamera.position = center;
@@ -580,34 +582,40 @@
     var position2 = Cesium.Cartesian3.fromRadians(centerLongitude, centerLatitude, height + 10.0);
     var position3 = Cesium.Cartesian3.fromRadians(centerLongitude, centerLatitude, height + 15.0);
 
-    var model = createModel(uiOptions.modelUrls[viewModel.model], location, viewModel.modelPosition);
-    addModelToView(model);
+    var modelHeight;
+    if (viewModel.modelPosition === 'Ground') {
+        modelHeight = height - 50.0;
+    } else if (viewModel.modelPosition === 'Center') {
+        modelHeight = height;
+    }
+
+    var modelPosition = Cesium.Cartesian3.fromRadians(centerLongitude, centerLatitude, modelHeight);
+
+    createModel(uiOptions.modelUrls[viewModel.model], modelPosition);
     createBox(position3);
     createBoxRTC(position2);
     createSphere(position1);
-}
 
-function createModel(url, location, position) {
-    var origin;
-    if (position === 'Ground') {
-        origin = Cesium.Cartesian3.fromRadians(location.centerLongitude, location.centerLatitude, location.height - 50.0);
-    }
-    else if (position === 'Center') {
-        origin = Cesium.Cartesian3.fromRadians(location.centerLongitude, location.centerLatitude, location.height);
+    // Add a grid of models
+    var spacing = 0.00002;
+    var gridSize = 10;
+    for (var i = 0; i < gridSize * gridSize; ++i) {
+        var x = i % gridSize;
+        var y = Math.floor(i / gridSize);
+        var longitude = centerLongitude + spacing * (x - gridSize / 2.0);
+        var latitude = centerLatitude + spacing * (y - gridSize / 2.0);
+        var position = Cesium.Cartesian3.fromRadians(longitude, latitude, modelHeight);
+        createModel(uiOptions.modelUrls['Shadow Tester'], position);
     }
+}
 
+function createModel(url, origin) {
     var modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(origin, 0.0, 0.0, 0.0);
 
-    var model = Cesium.Model.fromGltf({
+    var model = scene.primitives.add(Cesium.Model.fromGltf({
         url : url,
         modelMatrix : modelMatrix
-    });
-
-    return model;
-}
-
-function addModelToView(model) {
-    model = scene.primitives.add(model);
+    }));
 
     model.readyPromise.then(function(model) {
         // Play and loop all animations at half-speed
@@ -618,6 +626,8 @@
     }).otherwise(function(error){
         window.alert(error);
     });
+
+    return model;
 }
 
 function createBoxRTC(origin) {

Source/Scene/Scene.js

@@ -1685,64 +1685,137 @@ define([
         }
     }
 
-    function getShadowMapCommands(scene) {
-        // TODO : temporary solution for testing
-        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) {
-                        shadowCommands.push(command);
+    function getTerrainShadowCommands(scene, shadowMap) {
+        var frameState = scene.frameState;
+
+        var sceneCommandList = frameState.commandList;
+        var sceneCamera = frameState.camera;
+        var sceneCullingVolume = frameState.cullingVolume;
+
+        var terrainCommands = []; // TODO : avoid allocation
+
+        // Update frame state to render from the light camera
+        frameState.commandList = terrainCommands;
+        frameState.camera = shadowMap.shadowMapCamera;
+        frameState.cullingVolume = shadowMap.shadowMapCullingVolume;
+
+        // Collect terrain commands from the light's POV
+        if (scene._globe && scene._globe.castShadows) {
+            scene._globe.update(frameState);
+        }
+
+        // Revert back to original frame state
+        frameState.commandList = sceneCommandList;
+        frameState.camera = sceneCamera;
+        frameState.cullingVolume = sceneCullingVolume;
+
+        return terrainCommands;
+    }
+
+    // function getTerrainShadowCommands(scene, shadowMap) {
+    //     // TODO : Temporary for testing. Globe.update doesn't work with orthographic frustums currently
+    //     var terrainCommands = [];
+    //     var commandList = scene.frameState.commandList;
+    //     var length = commandList.length;
+    //     for (var i = 0; i < length; ++i) {
+    //         var command = commandList[i];
+    //         if (command.castShadows && command.pass === Pass.GLOBE) {
+    //             terrainCommands.push(command);
+    //         }
+    //     }
+    //
+    //     return terrainCommands;
+    // }
+
+    function insertShadowCommands(commandList, insertAll, shadowMap, shadowPassCommands) {
+        var shadowVolume = shadowMap.shadowMapCullingVolume;
+        var passVolumes = shadowMap.passCullingVolumes;
+
+        var isPointLight = shadowMap.isPointLight;
+        var center = shadowMap.pointLightPosition;
+        var radius = shadowMap.pointLightRadius;
+
+        var numberOfPasses = shadowMap.numberOfPasses;
+
+        var length = commandList.length;
+        for (var i = 0; i < length; ++i) {
+            var command = commandList[i];
+            // Don't insert globe commands with the rest of the scene commands since they are handled separately
+            if (command.castShadows && (insertAll || (command.pass === Pass.OPAQUE || command.pass === Pass.TRANSLUCENT))) {
+                if (isPointLight) {
+                    if (defined(command.boundingVolume)) {
+                        var distance = command.boundingVolume.distanceSquaredTo(center);
+                        if (distance < radius * radius) {
+                            for (var k = 0; k < numberOfPasses; ++k) {
+                                shadowPassCommands[k].push(command);
+                            }
+                        }
+                    }
+                } else {
+                    if (isVisible(command, shadowVolume)) {
+                        if (numberOfPasses <= 1) {
+                            shadowPassCommands[0].push(command);
+                        } else {
+                            var wasVisible = false;
+                            // Loop over cascades from largest to smallest
+                            for (var j = numberOfPasses - 1; j >= 0; --j) {
+                                var cascadeVolume = passVolumes[j];
+                                if (isVisible(command, cascadeVolume)) {
+                                    shadowPassCommands[j].push(command);
+                                    wasVisible = true;
+                                } else if (wasVisible) {
+                                    // If it was visible in the previous cascade but now isn't
+                                    // then there is no need to check any more cascades
+                                    break;
+                                }
+                            }
+                        }
                     }
                 }
             }
         }
-        return [terrainCommands, primitiveCommands];
+    }
+
+    function resetShadowCommands(passCommands) {
+        var length = passCommands.length;
+        for (var i = 0; i < length; ++i) {
+            passCommands[i].length = 0;
+        }
     }
 
     function executeShadowMapCommands(scene) {
         var context = scene.context;
         var uniformState = context.uniformState;
         var shadowMap = scene.shadowMap;
         var isPointLight = shadowMap.isPointLight;
+        var renderState = isPointLight ? shadowMap.pointRenderState : shadowMap.primitiveRenderState;
 
-        var commands = getShadowMapCommands(scene);
-        var terrainCommands = commands[0];
-        var primitiveCommands = commands[1];
+        var shadowPassCommands = shadowMap.passCommands;
+        resetShadowCommands(shadowPassCommands);
 
-        var j;
-        var command;
+        // Insert the scene commands into the shadow map passes
+        var sceneCommands = scene.frameState.commandList;
+        insertShadowCommands(sceneCommands, false, shadowMap, shadowPassCommands);
+        var terrainCommands = getTerrainShadowCommands(scene, shadowMap);
+        insertShadowCommands(terrainCommands, true, shadowMap, shadowPassCommands);
 
         var numberOfPasses = shadowMap.numberOfPasses;
+
+        // // TODO : testing only
+        // for (var k = 0; k < numberOfPasses; ++k) {
+        //     console.log('Pass ' + k + ': ' + shadowPassCommands[k].length + ' commands.');
+        // }
+
         for (var i = 0; i < numberOfPasses; ++i) {
             uniformState.updateCamera(shadowMap.passCameras[i]);
             var passState = shadowMap.passStates[i];
             shadowMap.updatePass(context, i);
 
-            // 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);
+            var passCommands = shadowPassCommands[i];
+            var numberOfCommands = passCommands.length;
+            for (var j = 0; j < numberOfCommands; ++j) {
+                var command = passCommands[j];
+                executeCommand(command, scene, context, passState, renderState, command.shadowCastProgram);
             }
         }
     }