Simplify and fix

Author: lilleyse

Source/Scene/Batched3DModel3DTileContent.js

@@ -68,8 +68,8 @@ define([
         this.batchTable = undefined;
         this.featurePropertiesDirty = false;
 
-        this._contentReadyToProcessPromise = when.defer();
-        this._readyPromise = when.defer();
+        this._contentReadyToProcessPromise = undefined;
+        this._readyPromise = undefined;
         this._featuresLength = 0;
         this._features = undefined;
     }
@@ -215,6 +215,9 @@ define([
             return false;
         }
 
+        this._contentReadyToProcessPromise = when.defer();
+        this._readyPromise = when.defer();
+
         this.state = Cesium3DTileContentState.LOADING;
         promise.then(function(arrayBuffer) {
             if (that.isDestroyed()) {

Source/Scene/Cesium3DTile.js

@@ -289,7 +289,7 @@ define([
         }
 
         /**
-         * The time in seconds after the tile's content is downloaded when the content expires and new content is requested.
+         * The time in seconds after the tile's content is ready when the content expires and new content is requested.
          *
          * @type {Number}
          */
@@ -482,12 +482,49 @@ define([
         }
     });
 
+    var scratchJulianDate = new JulianDate();
+
+    /**
+     * Check if the tile's content has expired.
+     *
+     * @private
+     */
+    Cesium3DTile.prototype.isContentExpired = function() {
+        if (this._content.state === Cesium3DTileContentState.EXPIRED) {
+            return true;
+        }
+        if (defined(this.expireDate) && this.contentReady && (this.hasContent || this.hasTilesetContent)) {
+            var now = JulianDate.now(scratchJulianDate);
+            if (JulianDate.lessThan(this.expireDate, now)) {
+                this._content.state = Cesium3DTileContentState.EXPIRED;
+                return true;
+            }
+        }
+        return false;
+    };
+
+    function updateExpireDate(tile) {
+        if (defined(tile.expireDuration)) {
+            var expireDurationDate = JulianDate.now(scratchJulianDate);
+            JulianDate.addSeconds(expireDurationDate, tile.expireDuration, expireDurationDate);
+
+            if (defined(tile.expireDate)) {
+                if (JulianDate.lessThan(tile.expireDate, expireDurationDate)) {
+                    JulianDate.clone(expireDurationDate, tile.expireDate);
+                }
+            } else {
+                tile.expireDate = JulianDate.clone(expireDurationDate);
+            }
+        }
+    }
+
     function addContentReadyPromise(tile) {
         // Content enters the READY state
-        tile._content.readyPromise.then(function(content) {
+        tile._content.readyPromise.then(function() {
             if (defined(tile.parent)) {
                 --tile.parent.numberOfChildrenWithoutContent;
             }
+            updateExpireDate(tile);
         }).otherwise(function(error) {
             // In this case, that.parent.numberOfChildrenWithoutContent will never reach zero
             // and therefore that.parent will never refine.  If this becomes an issue, failed
@@ -531,11 +568,19 @@ define([
      *
      * @private
      */
-    Cesium3DTile.prototype.unloadContent = function() {
+    Cesium3DTile.prototype.unloadContent = function(makeEmpty) {
         if (defined(this.parent)) {
             ++this.parent.numberOfChildrenWithoutContent;
         }
 
+        if (makeEmpty) {
+            this.hasContent = false;
+            this.hasTilesetContent = false;
+            this._createContent = function() {
+                return new Empty3DTileContent();
+            };
+        }
+
         this._content = this._content && this._content.destroy();
         this._content = this._createContent();
         if (!this.hasContent && !this.hasTilesetContent) {
@@ -556,16 +601,6 @@ define([
         this._debugViewerRequestVolume = this._debugViewerRequestVolume && this._debugViewerRequestVolume.destroy();
     };
 
-    Cesium3DTile.prototype.unloadContentAndMakeEmpty = function() {
-        this.hasContent = false;
-        this.hasTilesetContent = false;
-        this._createContent = function() {
-            return new Empty3DTileContent();
-        };
-        this.unloadContent();
-    };
-
-
     var scratchProjectedBoundingSphere = new BoundingSphere();
 
     function getBoundingVolume(tile, frameState) {

Source/Scene/Cesium3DTileset.js

@@ -434,7 +434,7 @@ define([
         this.allTilesLoaded = new Event();
 
         /**
-         * The event fired to indicate that a tile's content was unloaded from the cache.
+         * The event fired to indicate that a tile's content was unloaded.
          * <p>
          * The unloaded {@link Cesium3DTile} is passed to the event listener.
          * </p>
@@ -924,11 +924,6 @@ define([
             // If there is a parentTile, add the root of the currently loading tileset
             // to parentTile's children, and increment its numberOfChildrenWithoutContent
             if (defined(parentTile)) {
-                if (parentTile.children.length > 0) {
-                    // Unload the old subtree if it exists
-                    unloadExpiredSubtree(parentTile);
-                }
-
                 parentTile.children.push(rootTile);
                 ++parentTile.numberOfChildrenWithoutContent;
 
@@ -1015,13 +1010,6 @@ define([
         }
     }
 
-    function recheckRefinement(tile) {
-        var ancestor = getAncestorWithContent(tile);
-        if (defined(ancestor) && (ancestor.refine === Cesium3DTileRefine.REPLACE)) {
-            prepareRefiningTiles([ancestor]);
-        }
-    }
-
     var scratchPositionNormal = new Cartesian3();
     var scratchCartographic = new Cartographic();
     var scratchMatrix = new Matrix4();
@@ -1161,71 +1149,23 @@ define([
 
     ///////////////////////////////////////////////////////////////////////////
 
-    var scratchJulianDate = new JulianDate();
-
-    function updateExpireDate(tile) {
-        if (defined(tile.expireDuration)) {
-            var expireDurationDate = JulianDate.now(scratchJulianDate);
-            JulianDate.addSeconds(expireDurationDate, tile.expireDuration, expireDurationDate);
-
-            if (defined(tile.expireDate)) {
-                if (JulianDate.lessThan(expireDurationDate, tile.expireDate)) {
-                    JulianDate.clone(expireDurationDate, tile.expireDate);
-                }
-            } else {
-                tile.expireDate = JulianDate.clone(expireDurationDate);
-            }
-        }
-    }
-
-    function unloadExpiredSubtree(tile) {
+    function unloadSubtree(tileset, tile) {
+        var stats = tileset._statistics;
         var stack = [];
         stack.push(tile);
         while (stack.length > 0) {
             tile = stack.pop();
+            unloadTile(tileset, tile, false);
             var children = tile.children;
             var length = children.length;
             for (var i = 0; i < length; ++i) {
                 var child = children[i];
-                child.destroy();
+                --stats.numberTotal;
                 stack.push(child);
             }
         }
-        tile.children = [];
-        tile.unloadContent();
-    }
-
-    function unloadExpiredLeafTile(tile) {
-        tile.destroy();
-        var parent = tile.parent;
-        if (defined(parent)) {
-            var index = parent.children.indexOf(tile);
-            parent.children.splice(index, 1);
-            recheckRefinement(parent);
-        }
-    }
-
-    function unloadExpiredTile(tile) {
-        if (tile.children.length === 0) {
-            unloadExpiredLeafTile(tile);
-            return;
-        }
 
-        if (tile.hasContent) {
-            // When the tile is expired and the request fails, there is no longer any content to show.
-            // Unload the tile's old content and replace it with Empty3DTileContent.
-            tile.unloadContentAndMakeEmpty();
-            // Now that the tile is empty recheck its parent's refinement
-            recheckRefinement(tile.parent);
-        } else if (tile.hasTilesetContent) {
-            // When the tile is the root of an external tileset, unload the entire subtree
-            unloadExpiredSubtree(tile);
-            // Also destroy this tile
-            unloadExpiredLeafTile(tile);
-        }
-    }
-    function isVisible(visibilityPlaneMask) {
-        return visibilityPlaneMask !== CullingVolume.MASK_OUTSIDE;
+        tile.children = [];
     }
 
     function requestContent(tileset, tile, outOfCore) {
@@ -1236,7 +1176,7 @@ define([
             return;
         }
 
-        var expired = (tile.content.state === Cesium3DTileContentState.EXPIRED);
+        var expired = tile.isContentExpired();
 
         tile.requestContent();
 
@@ -1247,25 +1187,28 @@ define([
         if (tile.content.state === Cesium3DTileContentState.LOADING) {
             ++stats.numberOfPendingRequests;
 
+            if (expired && tile.hasTilesetContent) {
+                unloadSubtree(tileset, tile);
+            }
+
             var removeFunction = removeFromProcessingQueue(tileset, tile);
-            when(tile.content.contentReadyToProcessPromise).then(function() {
-                // Content is loaded and ready to process
-                addToProcessingQueue(tileset, tile);
-                updateExpireDate(tile);
-            }).otherwise(removeFunction);
-
-            when(tile.content.readyPromise).then(removeFunction).otherwise(function() {
-                // The request failed
+            tile.content.contentReadyToProcessPromise.then(addToProcessingQueue(tileset, tile));
+            tile.content.readyPromise.then(removeFunction).otherwise(function() {
                 removeFunction();
                 if (expired) {
-                    unloadExpiredTile(tile);
+                    // Failed to request new content for the expired tile, so unload it and make it empty
+                    unloadTile(tileset, tile, true);
                 }
             });
         } else {
             ++stats.numberOfAttemptedRequests;
         }
     }
 
+    function isVisible(visibilityPlaneMask) {
+        return visibilityPlaneMask !== CullingVolume.MASK_OUTSIDE;
+    }
+
     function selectTile(tileset, tile, fullyVisible, frameState) {
         // There may also be a tight box around just the tile's contents, e.g., for a city, we may be
         // zoomed into a neighborhood and can cull the skyscrapers in the root node.
@@ -1386,6 +1329,10 @@ define([
             t.replaced = false;
             ++stats.visited;
 
+            if (t.isContentExpired()) {
+                requestContent(tileset, t, outOfCore);
+            }
+
             var visibilityPlaneMask = t.visibilityPlaneMask;
             var fullyVisible = (visibilityPlaneMask === CullingVolume.MASK_INSIDE);
 
@@ -1395,18 +1342,6 @@ define([
             var sse = getScreenSpaceError(tileset, t.geometricError, t, frameState);
             // PERFORMANCE_IDEA: refine also based on (1) occlusion/VMSSE and/or (2) center of viewport
 
-            // If the tile is expired, request new content
-            if (defined(t.expireDate)) {
-                var now = JulianDate.now(scratchJulianDate);
-                if (JulianDate.lessThan(now, t.expireDate)) {
-                    // Request new content
-                    if (t.contentReady && (t.hasContent || t.hasTilesetContent)) {
-                        t.content.state = Cesium3DTileContentState.EXPIRED;
-                        requestContent(tileset, t, outOfCore);
-                    }
-                }
-            }
-
             var children = t.children;
             var childrenLength = children.length;
             var child;
@@ -1698,10 +1633,12 @@ define([
     ///////////////////////////////////////////////////////////////////////////
 
     function addToProcessingQueue(tileset, tile) {
-        tileset._processingQueue.push(tile);
+        return function() {
+            tileset._processingQueue.push(tile);
 
-        --tileset._statistics.numberOfPendingRequests;
-        ++tileset._statistics.numberProcessing;
+            --tileset._statistics.numberOfPendingRequests;
+            ++tileset._statistics.numberProcessing;
+        };
     }
 
     function removeFromProcessingQueue(tileset, tile) {
@@ -1878,14 +1815,29 @@ define([
         }
     }
 
+    function unloadTile(tileset, tile, makeEmpty) {
+        if (tile.hasContent) {
+            var stats = tileset._statistics;
+            var replacementList = tileset._replacementList;
+            var tileUnload = tileset.tileUnload;
+
+            tileUnload.raiseEvent(tile);
+            replacementList.remove(tile.replacementNode);
+            decrementPointAndFeatureLoadCounts(tileset, tile.content);
+            --stats.numberContentReady;
+        }
+
+        if (tile.hasContent || (tile.hasTilesetContent && makeEmpty)) {
+            tile.unloadContent(makeEmpty);
+        }
+    }
+
     function unloadTiles(tileset, frameState) {
         var trimTiles = tileset._trimTiles;
         tileset._trimTiles = false;
 
-        var stats = tileset._statistics;
         var maximumNumberOfLoadedTiles = tileset._maximumNumberOfLoadedTiles + 1; // + 1 to account for sentinel
         var replacementList = tileset._replacementList;
-        var tileUnload = tileset.tileUnload;
 
         // Traverse the list only to the sentinel since tiles/nodes to the
         // right of the sentinel were used this frame.
@@ -1895,16 +1847,8 @@ define([
         var node = replacementList.head;
         while ((node !== sentinel) && ((replacementList.length > maximumNumberOfLoadedTiles) || trimTiles)) {
             var tile = node.item;
-
-            decrementPointAndFeatureLoadCounts(tileset, tile.content);
-            tileUnload.raiseEvent(tile);
-            tile.unloadContent();
-
-            var currentNode = node;
             node = node.next;
-            replacementList.remove(currentNode);
-
-            --stats.numberContentReady;
+            unloadTile(tileset, tile, false);
         }
     }
 

Source/Scene/Composite3DTileContent.js

@@ -50,8 +50,8 @@ define([
         this.state = Cesium3DTileContentState.UNLOADED;
         this.batchTable = undefined;
 
-        this._contentReadyToProcessPromise = when.defer();
-        this._readyPromise = when.defer();
+        this._contentReadyToProcessPromise = undefined;
+        this._readyPromise = undefined;
     }
 
     defineProperties(Composite3DTileContent.prototype, {
@@ -192,6 +192,9 @@ define([
             return false;
         }
 
+        this._contentReadyToProcessPromise = when.defer();
+        this._readyPromise = when.defer();
+
         this.state = Cesium3DTileContentState.LOADING;
         promise.then(function(arrayBuffer) {
             if (that.isDestroyed()) {