bruce-cesium 6.5.9 → 6.6.0

package/dist/bruce-cesium.umd.js

@@ -11891,6 +11891,66 @@
     }
     const VIEWER_WATCH_KEY = "bruce-viewer-watch";
     const WATCH_KEY = "bruce-tileset-watch";
+    const VIEWER_DATE_RANGE_WATCH_KEY = "bruce-viewer-date-range-watch";
+    const DATE_RANGE_WATCH_KEY = "bruce-tileset-date-range-watch";
+    function parseDate(value) {
+        if (!value) {
+            return null;
+        }
+        const date = value instanceof Date ? value : new Date(value);
+        if (isNaN(date.getTime())) {
+            return null;
+        }
+        return date;
+    }
+    function getTilesetDateRange(tileset) {
+        var _a, _b, _c;
+        const settings = (_a = tileset === null || tileset === void 0 ? void 0 : tileset.settings) !== null && _a !== void 0 ? _a : tileset === null || tileset === void 0 ? void 0 : tileset.Settings;
+        const visual = (settings === null || settings === void 0 ? void 0 : settings.visual) || (settings === null || settings === void 0 ? void 0 : settings.Visual);
+        const start = parseDate((_b = settings === null || settings === void 0 ? void 0 : settings.dateStart) !== null && _b !== void 0 ? _b : visual === null || visual === void 0 ? void 0 : visual.dateStart);
+        const end = parseDate((_c = settings === null || settings === void 0 ? void 0 : settings.dateEnd) !== null && _c !== void 0 ? _c : visual === null || visual === void 0 ? void 0 : visual.dateEnd);
+        if ((!start && !end) || (start && end && end < start)) {
+            return null;
+        }
+        return { start, end };
+    }
+    function isDateInRange(date, range) {
+        const time = date.getTime();
+        if (range.start && time < range.start.getTime()) {
+            return false;
+        }
+        if (range.end && time > range.end.getTime()) {
+            return false;
+        }
+        return true;
+    }
+    function watchTilesetDateRange(viewer, cTileset, tileset) {
+        exports.TilesetRenderEngine.WatchDateRange(viewer, cTileset, tileset);
+    }
+    function isDateRangeWatchAlive(viewer, renderObject) {
+        if (!viewer || viewer.isDestroyed() || !renderObject) {
+            return false;
+        }
+        if (typeof renderObject.isDestroyed === "function" && renderObject.isDestroyed()) {
+            return false;
+        }
+        if (typeof renderObject.setVisible === "function") {
+            return true;
+        }
+        if (typeof renderObject.isDestroyed !== "function") {
+            return true;
+        }
+        return isAlive$2(viewer, renderObject);
+    }
+    function setDateRangeVisible(renderObject, visible) {
+        if (typeof renderObject.setVisible === "function") {
+            renderObject.setVisible(visible);
+        }
+        else {
+            renderObject.show = visible;
+        }
+        renderObject._bruceDateRangeVisible = visible;
+    }
     /**
      * Creates and returns a tileset instance from a given url.
      * This is made to handle the difference between old and new cesium versions.
@@ -12161,6 +12221,7 @@
                 }
                 const cTileset = await createTileset(loadUrl, null, params.noMemoryLimit);
                 params.viewer.scene.primitives.add(cTileset);
+                watchTilesetDateRange(params.viewer, cTileset, params.tileset);
                 OnTilesetReady(cTileset).then(() => {
                     var _a, _b, _c, _d;
                     try {
@@ -12207,6 +12268,7 @@
                 }
                 const cTileset = await createTileset(loadUrl, null, params.noMemoryLimit);
                 params.viewer.scene.primitives.add(cTileset);
+                watchTilesetDateRange(params.viewer, cTileset, params.tileset);
                 return cTileset;
             }
             else if (params.tileset.type == BModels.Tileset.EType.PointCloud) {
@@ -12222,6 +12284,7 @@
                 }
                 const cTileset = await createTileset(loadUrl, null, params.noMemoryLimit);
                 params.viewer.scene.primitives.add(cTileset);
+                watchTilesetDateRange(params.viewer, cTileset, params.tileset);
                 OnTilesetReady(cTileset).then(() => {
                     var _a;
                     try {
@@ -12310,6 +12373,7 @@
                 backFaceCulling: backFaceCulling === true
             }, noMemoryLimit);
             viewer.scene.primitives.add(cTileset);
+            watchTilesetDateRange(viewer, cTileset, tileset);
             OnTilesetReady(cTileset).then(() => {
                 var _a;
                 try {
@@ -12386,11 +12450,110 @@
         class Styler extends TilesetStyler {
         }
         TilesetRenderEngine.Styler = Styler;
+        function GetTilesetDateRange(tileset) {
+            return getTilesetDateRange(tileset);
+        }
+        TilesetRenderEngine.GetTilesetDateRange = GetTilesetDateRange;
+        function WatchDateRange(viewer, renderObject, tileset) {
+            var _a;
+            const range = getTilesetDateRange(tileset);
+            if (!range) {
+                return;
+            }
+            (_a = GetDateRangeWatcher(viewer)) === null || _a === void 0 ? void 0 : _a.Watch(renderObject, range);
+        }
+        TilesetRenderEngine.WatchDateRange = WatchDateRange;
+        function UnwatchDateRange(viewer, renderObject) {
+            var _a;
+            (_a = viewer === null || viewer === void 0 ? void 0 : viewer[VIEWER_DATE_RANGE_WATCH_KEY]) === null || _a === void 0 ? void 0 : _a.Unwatch(renderObject);
+        }
+        TilesetRenderEngine.UnwatchDateRange = UnwatchDateRange;
         /**
          * The maximum memory in MB that can be used by all tilesets.
          * This is distributed evenly between all loaded tilesets.
          */
         TilesetRenderEngine.MAX_TILESET_MEMORY = 1024;
+        /**
+         * Watches tileset date cutoffs and toggles their primitive visibility based on the viewer clock.
+         */
+        class DateRangeWatcher {
+            constructor(viewer) {
+                this.watched = [];
+                this.clockRemoval = null;
+                this.viewer = viewer;
+                this.clockRemoval = viewer.clock.onTick.addEventListener(() => {
+                    this.update();
+                });
+            }
+            clean() {
+                this.watched = this.watched.filter(x => isDateRangeWatchAlive(this.viewer, x));
+                if (!this.viewer || this.viewer.isDestroyed()) {
+                    this.destroy();
+                }
+            }
+            updateTileset(tileset) {
+                if (!(tileset === null || tileset === void 0 ? void 0 : tileset._bruceDateRange) || !isDateRangeWatchAlive(this.viewer, tileset)) {
+                    return false;
+                }
+                const currentDate = Cesium.JulianDate.toDate(this.viewer.clock.currentTime);
+                const shouldShow = isDateInRange(currentDate, tileset._bruceDateRange);
+                if (tileset._bruceDateRangeVisible === shouldShow && (typeof tileset.setVisible === "function" || tileset.show === shouldShow)) {
+                    return false;
+                }
+                setDateRangeVisible(tileset, shouldShow);
+                return true;
+            }
+            update() {
+                this.clean();
+                let changed = false;
+                this.watched.forEach(x => {
+                    changed = this.updateTileset(x) || changed;
+                });
+                if (changed) {
+                    this.viewer.scene.requestRender();
+                }
+            }
+            destroy() {
+                var _a;
+                (_a = this.clockRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+                this.clockRemoval = null;
+                this.watched = [];
+            }
+            Watch(tileset, range) {
+                if (!tileset) {
+                    return;
+                }
+                if (!(range === null || range === void 0 ? void 0 : range.start) && !(range === null || range === void 0 ? void 0 : range.end)) {
+                    this.Unwatch(tileset);
+                    return;
+                }
+                if (!tileset[DATE_RANGE_WATCH_KEY]) {
+                    tileset[DATE_RANGE_WATCH_KEY] = BModels.ObjectUtils.UId();
+                }
+                tileset._bruceDateRange = range;
+                const index = this.watched.findIndex(x => x[DATE_RANGE_WATCH_KEY] === tileset[DATE_RANGE_WATCH_KEY]);
+                if (index < 0) {
+                    this.watched.push(tileset);
+                }
+                if (this.updateTileset(tileset)) {
+                    this.viewer.scene.requestRender();
+                }
+            }
+            Unwatch(tileset) {
+                if (!tileset) {
+                    return;
+                }
+                if (!tileset[DATE_RANGE_WATCH_KEY]) {
+                    tileset[DATE_RANGE_WATCH_KEY] = BModels.ObjectUtils.UId();
+                }
+                const index = this.watched.findIndex(x => (x === null || x === void 0 ? void 0 : x[DATE_RANGE_WATCH_KEY]) === tileset[DATE_RANGE_WATCH_KEY]);
+                if (index > -1) {
+                    this.watched.splice(index, 1);
+                }
+                tileset._bruceDateRange = null;
+            }
+        }
+        TilesetRenderEngine.DateRangeWatcher = DateRangeWatcher;
         /**
          * Watches tilesets in the viewer.
          * This will regulate their max memory param.
@@ -12444,9 +12607,11 @@
                 this.distributeMemory();
             }
             Unwatch(tileset) {
+                var _a, _b;
                 if (!tileset) {
                     return;
                 }
+                (_b = (_a = this.viewer) === null || _a === void 0 ? void 0 : _a[VIEWER_DATE_RANGE_WATCH_KEY]) === null || _b === void 0 ? void 0 : _b.Unwatch(tileset);
                 if (!tileset[WATCH_KEY]) {
                     tileset[WATCH_KEY] = BModels.ObjectUtils.UId();
                 }
@@ -12469,6 +12634,17 @@
             return viewer[VIEWER_WATCH_KEY];
         }
         TilesetRenderEngine.GetMemoryWatcher = GetMemoryWatcher;
+        function GetDateRangeWatcher(viewer) {
+            // If viewer is dead return nothing.
+            if (!viewer || viewer.isDestroyed()) {
+                return null;
+            }
+            if (!viewer[VIEWER_DATE_RANGE_WATCH_KEY]) {
+                viewer[VIEWER_DATE_RANGE_WATCH_KEY] = new DateRangeWatcher(viewer);
+            }
+            return viewer[VIEWER_DATE_RANGE_WATCH_KEY];
+        }
+        TilesetRenderEngine.GetDateRangeWatcher = GetDateRangeWatcher;
     })(exports.TilesetRenderEngine || (exports.TilesetRenderEngine = {}));
 
     /**
@@ -16289,6 +16465,10 @@
                     }
                 }
             });
+            if (typeof (obj === null || obj === void 0 ? void 0 : obj.setVisible) === "function") {
+                obj.setVisible(true);
+            }
+            exports.TilesetRenderEngine.WatchDateRange(viewer, obj, tileset);
             // Highest LOD.
             obj.setStartLod(0);
             // Max distance for rendering.
@@ -16308,6 +16488,7 @@
                 console.warn("[XGridsRenderEngine] Remove() LCCRender library not available.");
                 return;
             }
+            exports.TilesetRenderEngine.UnwatchDateRange(viewer, renderObject);
             LCCRender.unload(renderObject);
         }
         XGridsRenderEngine.Remove = Remove;
@@ -35249,7 +35430,7 @@
         }
     }
 
-    const VERSION = "6.5.9";
+    const VERSION = "6.6.0";
     /**
      * Updates the environment instance used by bruce-cesium to one specified.
      * This can be used to ensure that the instance a parent is referencing is shared between bruce-cesium, bruce-models, and the parent app.