Expire temp

Author: lilleyse

Source/Scene/Cesium3DTile.js

@@ -17,6 +17,7 @@ define([
         '../Core/getStringFromTypedArray',
         '../Core/Intersect',
         '../Core/joinUrls',
+        '../Core/JulianDate',
         '../Core/loadArrayBuffer',
         '../Core/Matrix3',
         '../Core/Matrix4',
@@ -60,6 +61,7 @@ define([
         getStringFromTypedArray,
         Intersect,
         joinUrls,
+        JulianDate,
         loadArrayBuffer,
         Matrix3,
         Matrix4,
@@ -268,6 +270,30 @@ define([
          */
         this.replacementNode = undefined;
 
+        var expire = header.expire;
+        var expireDuration;
+        var expireDate;
+        if (defined(expire)) {
+            expireDuration = expire.duration;
+            if (defined(expire.date)) {
+                expireDate = JulianDate.fromIso8601(expire.date);
+            }
+        }
+
+        /**
+         * The time in seconds after the tile's content is ready when the content expires and new content is requested.
+         *
+         * @type {Number}
+         */
+        this.expireDuration = expireDuration;
+
+        /**
+         * The date when the content expires and new content is requested.
+         *
+         * @type {JulianDate}
+         */
+        this.expireDate = expireDate;
+
         // Members that are updated every frame for tree traversal and rendering optimizations:
 
         /**
@@ -449,6 +475,21 @@ define([
             }
         },
 
+        /**
+         * Determines if the tile's content is expired. <code>true</code> if tile's
+         * content is expired; otherwise, <code>false</code>.
+         *
+         * @memberof Cesium3DTile.prototype
+         *
+         * @type {Boolean}
+         * @readonly
+         */
+        contentExpired : {
+            get : function() {
+                return this._contentState === Cesium3DTileContentState.EXPIRED;
+            }
+        },
+
         /**
          * Gets the promise that will be resolved when the tile's content is ready to process.
          * This happens after the content is downloaded but before the content is ready
@@ -490,6 +531,32 @@ define([
         }
     });
 
+    var scratchJulianDate = new JulianDate();
+
+    function updateExpiration(tile) {
+        if (defined(tile.expireDate) && tile.contentReady && !tile.hasEmptyContent) {
+            var now = JulianDate.now(scratchJulianDate);
+            if (JulianDate.lessThan(tile.expireDate, now)) {
+                tile._contentState = Cesium3DTileContentState.EXPIRED;
+            }
+        }
+    }
+
+    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);
+            }
+        }
+    }
+
     /**
      * Requests the tile's content.
      * <p>
@@ -509,9 +576,16 @@ define([
             return false;
         }
 
+        var url = this._contentUrl;
+        if (defined(this.expireDate)) {
+            // Append a query parameter of the tile expiration date to prevent caching
+            var timestampQuery = '?expired=' + this.expireDate.toString();
+            url = joinUrls(url, timestampQuery, false);
+        }
+
         var distance = this.distanceToCamera;
         var promise = RequestScheduler.schedule(new Request({
-            url : this._contentUrl,
+            url : url,
             server : this._requestServer,
             requestFunction : loadArrayBuffer,
             type : RequestType.TILES3D,
@@ -530,6 +604,10 @@ define([
             if (that.isDestroyed()) {
                 return when.reject('tileset is destroyed');
             }
+
+            // Destroy expired content to make way for the new content
+            that._content = that._content && that._content.destroy();
+
             var uint8Array = new Uint8Array(arrayBuffer);
             var magic = getMagic(uint8Array);
             var contentFactory = Cesium3DTileContentFactory[magic];
@@ -549,6 +627,7 @@ define([
             that._contentReadyToProcessPromise.resolve(content);
 
             content.readyPromise.then(function(content) {
+                updateExpireDate(that);
                 that._contentState = Cesium3DTileContentState.READY;
                 that._contentReadyPromise.resolve(content);
             }).otherwise(function(error) {
@@ -861,6 +940,7 @@ define([
      */
     Cesium3DTile.prototype.update = function(tileset, frameState) {
         applyDebugSettings(this, tileset, frameState);
+        updateExpiration(this);
         this._content.update(tileset, frameState);
         this._transformDirty = false;
     };

Source/Scene/Cesium3DTileContentState.js

@@ -13,8 +13,9 @@ define([
         LOADING : 1,    // Is waiting on a pending request
         PROCESSING : 2, // Request received.  Contents are being processed for rendering.  Depending on the content, it might make its own requests for external data.
         READY : 3,      // Ready to render.
-        FAILED : 4      // Request failed.
+        EXPIRED : 4,    // Is expired and will be unloaded once new content is loaded.
+        FAILED : 5      // Request failed.
     };
 
     return freezeObject(Cesium3DTileContentState);
-});
+});

Source/Scene/Cesium3DTileset.js

@@ -450,7 +450,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>
@@ -1222,6 +1222,25 @@ define([
 
     ///////////////////////////////////////////////////////////////////////////
 
+    function unloadSubtree(tileset, tile) {
+        var stats = tileset._statistics;
+        var stack = [];
+        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];
+                --stats.numberTotal;
+                stack.push(child);
+            }
+        }
+
+        tile.children = [];
+    }
+
     function isVisible(visibilityPlaneMask) {
         return visibilityPlaneMask !== CullingVolume.MASK_OUTSIDE;
     }
@@ -1236,14 +1255,18 @@ define([
         }
 
         var stats = tileset._statistics;
-
+        var expired = tile.contentExpired;
         var requested = tile.requestContent();
 
         if (!requested) {
             ++stats.numberOfAttemptedRequests;
             return;
         }
 
+        if (expired && tile.hasTilesetContent) {
+            unloadSubtree(tileset, tile);
+        }
+
         ++stats.numberOfPendingRequests;
 
         var removeFunction = removeFromProcessingQueue(tileset, tile);
@@ -1551,7 +1574,7 @@ define([
     }
 
     function loadTile(tile) {
-        if (tile.contentUnloaded) {
+        if (tile.contentUnloaded || tile.contentExpired) {
             tile._requestHeap.insert(tile);
         }
     }
@@ -1958,14 +1981,28 @@ define([
         }
     }
 
+    function unloadTile(tileset, tile) {
+        if (!tile.hasRenderableContent) {
+            return;
+        }
+
+        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;
+        tile.unloadContent();
+    }
+
     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.
@@ -1975,16 +2012,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);
         }
     }