Handle expiring subtrees

lilleyse · lilleyse · commit 63b899d73a07 · 2017-04-24T16:58:59.000-04:00
diff --git a/Source/Scene/Cesium3DTile.js b/Source/Scene/Cesium3DTile.js
@@ -120,8 +120,6 @@ define([
          */
         this.computedTransform = computedTransform;
 
-        this._transformDirty = true;
-
         this._boundingVolume = this.createBoundingVolume(header.boundingVolume, computedTransform);
         this._boundingVolume2D = undefined;
 
@@ -422,20 +420,6 @@ define([
             }
         },
 
-        /**
-         * Whether the computedTransform has changed this frame.
-         *
-         * @memberof Cesium3DTile.prototype
-         *
-         * @type {Boolean}
-         * @readonly
-         */
-        transformDirty : {
-            get : function() {
-                return this._transformDirty;
-            }
-        },
-
         /**
          * @readonly
          * @private
@@ -550,15 +534,20 @@ define([
 
     var scratchJulianDate = new JulianDate();
 
-    function updateExpiration(tile) {
-        if (defined(tile.expireDate) && tile.contentReady && !tile.hasEmptyContent) {
+    /**
+     * Update whether the tile has expired.
+     *
+     * @private
+     */
+    Cesium3DTile.prototype.updateExpiration = function() {
+        if (defined(this.expireDate) && this.contentReady && !this.hasEmptyContent) {
             var now = JulianDate.now(scratchJulianDate);
-            if (JulianDate.lessThan(tile.expireDate, now)) {
-                tile._contentState = Cesium3DTileContentState.EXPIRED;
-                tile._expiredContent = tile._content;
+            if (JulianDate.lessThan(this.expireDate, now)) {
+                this._contentState = Cesium3DTileContentState.EXPIRED;
+                this._expiredContent = this._content;
             }
         }
-    }
+    };
 
     function updateExpireDate(tile) {
         if (defined(tile.expireDuration)) {
@@ -620,9 +609,9 @@ define([
 
         promise.then(function(arrayBuffer) {
             if (that.isDestroyed()) {
-                return when.reject('tileset is destroyed');
+                // Tile is unloaded before the content finishes loading
+                return when.reject('tile is destroyed');
             }
-
             var uint8Array = new Uint8Array(arrayBuffer);
             var magic = getMagic(uint8Array);
             var contentFactory = Cesium3DTileContentFactory[magic];
@@ -642,6 +631,11 @@ define([
             that._contentReadyToProcessPromise.resolve(content);
 
             content.readyPromise.then(function(content) {
+                if (that.isDestroyed()) {
+                    // Tile is unloaded before the content finishes processing
+                    that._content.destroy();
+                    return when.reject('tile is destroyed');
+                }
                 updateExpireDate(that);
                 that._contentState = Cesium3DTileContentState.READY;
                 that._contentReadyPromise.resolve(content);
@@ -883,9 +877,8 @@ define([
     Cesium3DTile.prototype.updateTransform = function(parentTransform) {
         parentTransform = defaultValue(parentTransform, Matrix4.IDENTITY);
         var computedTransform = Matrix4.multiply(parentTransform, this.transform, scratchTransform);
-        var transformDirty = !Matrix4.equals(computedTransform, this.computedTransform);
-        if (transformDirty) {
-            this._transformDirty = true;
+        var transformChanged = !Matrix4.equals(computedTransform, this.computedTransform);
+        if (transformChanged) {
             Matrix4.clone(computedTransform, this.computedTransform);
 
             // Update the bounding volumes
@@ -969,9 +962,7 @@ define([
      */
     Cesium3DTile.prototype.update = function(tileset, frameState) {
         applyDebugSettings(this, tileset, frameState);
-        updateExpiration(this);
         updateContent(this, tileset, frameState);
-        this._transformDirty = false;
     };
 
     var scratchCommandList = [];
@@ -1005,8 +996,9 @@ define([
      * @private
      */
     Cesium3DTile.prototype.destroy = function() {
+        // For the interval between new content being requested and downloaded, expiredContent === content, so don't destroy twice
         this._content = this._content && this._content.destroy();
-        this._expiredContent = this._expiredContent && this._expiredContent.destroy();
+        this._expiredContent = this._expiredContent && !this._expiredContent.isDestroyed() && this._expiredContent.destroy();
         this._debugBoundingVolume = this._debugBoundingVolume && this._debugBoundingVolume.destroy();
         this._debugContentBoundingVolume = this._debugContentBoundingVolume && this._debugContentBoundingVolume.destroy();
         this._debugViewerRequestVolume = this._debugViewerRequestVolume && this._debugViewerRequestVolume.destroy();
diff --git a/Source/Scene/Cesium3DTileset.js b/Source/Scene/Cesium3DTileset.js
@@ -1222,23 +1222,25 @@ define([
 
     ///////////////////////////////////////////////////////////////////////////
 
-    function unloadSubtree(tileset, tile) {
+    function destroySubtree(tileset, tile) {
+        var root = tile;
         var stats = tileset._statistics;
-        var stack = [];
+        var stack = scratchStack;
         stack.push(tile);
         while (stack.length > 0) {
             tile = stack.pop();
-            unloadTile(tileset, tile);
             var children = tile.children;
             var length = children.length;
             for (var i = 0; i < length; ++i) {
-                var child = children[i];
+                stack.push(children[i]);
+            }
+            if (tile !== root) {
+                unloadTileFromCache(tileset, tile);
+                tile.destroy();
                 --stats.numberTotal;
-                stack.push(child);
             }
         }
-
-        tile.children = [];
+        root.children = [];
     }
 
     function isVisible(visibilityPlaneMask) {
@@ -1263,8 +1265,13 @@ define([
             return;
         }
 
-        if (expired && tile.hasTilesetContent) {
-            unloadSubtree(tileset, tile);
+        if (expired) {
+            if (tile.hasRenderableContent) {
+                decrementPointAndFeatureLoadCounts(tileset, tile.content);
+                --tileset._statistics.numberContentReady;
+            } else if (tile.hasTilesetContent) {
+                destroySubtree(tileset, tile);
+            }
         }
 
         ++stats.numberOfPendingRequests;
@@ -1591,6 +1598,7 @@ define([
         tile._sse = getScreenSpaceError(tileset, tile.geometricError, tile, frameState);
         tile.selected = false;
         tile._finalResolution = false;
+        tile.updateExpiration();
         touch(tileset, tile, outOfCore);
     }
 
@@ -1623,7 +1631,12 @@ define([
         var loadSiblings = tileset.loadSiblings;
 
         if (tile.hasTilesetContent) {
-            updateAndPushChildren(tileset, tile, frameState, stack, loadSiblings, outOfCore);
+            if (tile.contentExpired) {
+                // Request new content and destroy subtree
+                loadTile(tile);
+            } else {
+                updateAndPushChildren(tileset, tile, frameState, stack, loadSiblings, outOfCore);
+            }
         } else {
             if (tile.refine === Cesium3DTileRefine.ADD) {
                 loadAndAddToQueue(tileset, tile, finalQueue);
@@ -1751,12 +1764,17 @@ define([
                 // Remove from processing queue
                 tileset._processingQueue.splice(index, 1);
                 --tileset._statistics.numberProcessing;
+
                 if (tile.hasRenderableContent) {
                     // RESEARCH_IDEA: ability to unload tiles (without content) for an
                     // external tileset when all the tiles are unloaded.
-                    ++tileset._statistics.numberContentReady;
                     incrementPointAndFeatureLoadCounts(tileset, tile.content);
-                    tile.replacementNode = tileset._replacementList.add(tile);
+                    ++tileset._statistics.numberContentReady;
+
+                    // Add to the tile cache. Previously expired tiles are already in the cache.
+                    if (!defined(tile.replacementNode)) {
+                        tile.replacementNode = tileset._replacementList.add(tile);
+                    }
                 }
             } else {
                 // Not in processing queue
@@ -1981,8 +1999,9 @@ define([
         }
     }
 
-    function unloadTile(tileset, tile) {
-        if (!tile.hasRenderableContent) {
+    function unloadTileFromCache(tileset, tile) {
+        var node = tile.replacementNode;
+        if (!defined(node)) {
             return;
         }
 
@@ -1991,13 +2010,12 @@ define([
         var tileUnload = tileset.tileUnload;
 
         tileUnload.raiseEvent(tile);
-        replacementList.remove(tile.replacementNode);
+        replacementList.remove(node);
         decrementPointAndFeatureLoadCounts(tileset, tile.content);
         --stats.numberContentReady;
-        tile.unloadContent();
     }
 
-    function unloadTiles(tileset, frameState) {
+    function unloadTiles(tileset) {
         var trimTiles = tileset._trimTiles;
         tileset._trimTiles = false;
 
@@ -2013,7 +2031,8 @@ define([
         while ((node !== sentinel) && ((replacementList.length > maximumNumberOfLoadedTiles) || trimTiles)) {
             var tile = node.item;
             node = node.next;
-            unloadTile(tileset, tile);
+            unloadTileFromCache(tileset, tile);
+            tile.unloadContent();
         }
     }
 
@@ -2100,7 +2119,7 @@ define([
         updateTiles(this, frameState);
 
         if (outOfCore) {
-            unloadTiles(this, frameState);
+            unloadTiles(this);
         }
 
         // Events are raised (added to the afterRender queue) here since promises
diff --git a/Source/Scene/PointCloud3DTileContent.js b/Source/Scene/PointCloud3DTileContent.js
@@ -115,6 +115,7 @@ define([
         this._quantizedVolumeScale = undefined;
         this._quantizedVolumeOffset = undefined;
 
+        this._modelMatrix = Matrix4.clone(Matrix4.IDENTITY);
         this._mode = undefined;
 
         /**
@@ -1138,7 +1139,8 @@ define([
      * Part of the {@link Cesium3DTileContent} interface.
      */
     PointCloud3DTileContent.prototype.update = function(tileset, frameState) {
-        var updateModelMatrix = this._tile.transformDirty || this._mode !== frameState.mode;
+        var modelMatrixChanged = !Matrix4.equals(this._modelMatrix, this._tile.computedTransform);
+        var updateModelMatrix = modelMatrixChanged || this._mode !== frameState.mode;
         this._mode = frameState.mode;
 
         if (!defined(this._drawCommand)) {
