bruce-cesium 5.7.9 → 5.8.1

package/dist/types/rendering/render-managers/tilesets/tileset-entities-render-manager.d.ts

@@ -0,0 +1,41 @@
+import { ApiGetters, Entity, MenuItem } from "bruce-models";
+import { VisualsRegister } from "../../visuals-register";
+import { RenderManager } from "../render-manager";
+import * as Cesium from "cesium";
+import { TilesetRenderEngine } from "../../tileset-render-engine";
+export declare namespace TilesetEntitiesRenderManager {
+    class Manager implements RenderManager.IManager {
+        private initCounter;
+        private viewer;
+        private getters;
+        private item;
+        private disposed;
+        get Disposed(): boolean;
+        private visualsManager;
+        private cTileset;
+        get Tileset(): Cesium.Cesium3DTileset;
+        private typeId;
+        private styler;
+        get Styler(): TilesetRenderEngine.Styler;
+        private renderPriority;
+        constructor(params: {
+            viewer: Cesium.Viewer;
+            register: VisualsRegister.Register;
+            getters: ApiGetters;
+            item: MenuItem.Item.IEntitiesTileset;
+        });
+        Init(params?: {
+            item: MenuItem.Item.IEntitiesTileset;
+        }): void;
+        Dispose(): void;
+        private doDispose;
+        private onCTilesetLoad;
+        private mapCTile;
+        private mapTilesetFeature;
+        ReRender(params: {
+            entityIds?: string[];
+            entities?: Entity.IEntity[];
+            force?: boolean;
+        }): Promise<void>;
+    }
+}

package/dist/types/rendering/render-managers/tilesets/tileset-google-photos-render-manager.d.ts

@@ -0,0 +1,26 @@
+import { ApiGetters, MenuItem } from "bruce-models";
+import { RenderManager } from "../render-manager";
+import * as Cesium from "cesium";
+export declare namespace TilesetGooglePhotosRenderManager {
+    class Manager implements RenderManager.IManager {
+        private viewer;
+        private getters;
+        private item;
+        private disposed;
+        get Disposed(): boolean;
+        private cTileset;
+        get Tileset(): Cesium.Cesium3DTileset;
+        constructor(params: {
+            viewer: Cesium.Viewer;
+            getters: ApiGetters;
+            item: MenuItem.Item.IGooglePhotoTileset;
+        });
+        Dispose(): void;
+        private doDispose;
+        Init(): void;
+        ReRender(params: {
+            entityIds?: string[];
+            force?: boolean;
+        }): Promise<void>;
+    }
+}

package/dist/types/rendering/render-managers/tilesets/tileset-i3s-render-manager.d.ts

@@ -0,0 +1,25 @@
+import { ApiGetters, MenuItem } from "bruce-models";
+import { RenderManager } from "../render-manager";
+import * as Cesium from "cesium";
+export declare namespace TilesetI3sRenderManager {
+    class Manager implements RenderManager.IManager {
+        private viewer;
+        private item;
+        private disposed;
+        get Disposed(): boolean;
+        private dataProvider;
+        get DataProvider(): any;
+        constructor(params: {
+            viewer: Cesium.Viewer;
+            getters: ApiGetters;
+            item: MenuItem.Item.II3sTileset;
+        });
+        Dispose(): void;
+        private doDispose;
+        Init(): void;
+        ReRender(params: {
+            entityIds?: string[];
+            force?: boolean;
+        }): Promise<void>;
+    }
+}

package/dist/types/rendering/render-managers/tilesets/tileset-osm-render-manager.d.ts

@@ -0,0 +1,48 @@
+import { ApiGetters, MenuItem } from "bruce-models";
+import { VisualsRegister } from "../../visuals-register";
+import { RenderManager } from "../render-manager";
+import * as Cesium from "cesium";
+import { CesiumViewMonitor } from "../../../viewer/cesium-view-monitor";
+export declare namespace TilesetOsmRenderManager {
+    class Manager implements RenderManager.IManager {
+        private viewer;
+        private getters;
+        private item;
+        private monitor;
+        private disposed;
+        get Disposed(): boolean;
+        private visualsManager;
+        private cTileset;
+        get Tileset(): Cesium.Cesium3DTileset;
+        private counter;
+        private get count();
+        private _loadedCesiumEntities;
+        private totalLoaded;
+        private featureQueue;
+        private sourceId;
+        private entityTypeId;
+        private queueCheckInterval;
+        private processingQueue;
+        private _osmIdToBruceId;
+        private batchSize;
+        constructor(params: {
+            viewer: Cesium.Viewer;
+            register: VisualsRegister.Register;
+            getters: ApiGetters;
+            monitor: CesiumViewMonitor.Monitor;
+            item: MenuItem.Item.IOsm;
+        });
+        Dispose(): void;
+        Init(): void;
+        private mapCTile;
+        private processQueue;
+        private getVisualsForBatch;
+        private getIsVisualWithinRange;
+        private mapTileBatch;
+        private removeFarAwayBatch;
+        ReRender(params: {
+            entityIds?: string[];
+            force?: boolean;
+        }): Promise<void>;
+    }
+}

package/dist/types/rendering/render-managers/tilesets/tileset-pointcloud-render-manager.d.ts

@@ -0,0 +1,27 @@
+import { ApiGetters, MenuItem } from "bruce-models";
+import { RenderManager } from "../render-manager";
+import * as Cesium from "cesium";
+export declare namespace TilesetPointcloudRenderManager {
+    class Manager implements RenderManager.IManager {
+        private viewer;
+        private getters;
+        private item;
+        private disposed;
+        get Disposed(): boolean;
+        private cTileset;
+        get Tileset(): Cesium.Cesium3DTileset;
+        constructor(params: {
+            viewer: Cesium.Viewer;
+            getters: ApiGetters;
+            item: MenuItem.Item.IPointcloud;
+        });
+        Init(): void;
+        private onCTilesetLoad;
+        Dispose(): void;
+        private doDispose;
+        ReRender(params: {
+            entityIds?: string[];
+            force?: boolean;
+        }): Promise<void>;
+    }
+}

package/dist/types/rendering/tile-render-engine.d.ts

@@ -0,0 +1,80 @@
+import { ProjectViewTile, BruceApi, ProjectViewLegacyTile } from "bruce-models";
+import * as Cesium from "cesium";
+export declare namespace TileRenderEngine {
+    /**
+     * Legacy data did name comparisons instead of ids.
+     * We need to strip spacing, remove special characters, and make lowercase before comparison...
+     * @param nameA
+     * @param nameB
+     */
+    function CompareLegacyNames(nameA: string, nameB: string): boolean;
+    namespace Map {
+        namespace LegacyNavigator {
+            interface ILayerExt extends Cesium.ImageryLayer {
+                _bId?: string;
+                _bName?: string;
+            }
+            interface IViewParams {
+                bookmarkId: string;
+                viewId: string;
+                apiGetter?: BruceApi.IGetter;
+                viewer: Cesium.Viewer;
+                ignoreIds?: string[];
+            }
+            interface IParams {
+                data: ProjectViewLegacyTile.IMapSource;
+                apiGetter?: BruceApi.IGetter;
+                viewer: Cesium.Viewer;
+            }
+            function Render(params: IParams): Promise<ILayerExt>;
+            function RenderView(params: IViewParams): Promise<void>;
+        }
+        namespace Navigator {
+            interface IProviderExt extends Cesium.ImageryLayer {
+                _bMeta?: ProjectViewTile.ITileMeta;
+            }
+            interface IParams {
+                apiGetter?: BruceApi.IGetter;
+                viewer: Cesium.Viewer;
+                tiles: ProjectViewTile.IBookmarkImagery[];
+            }
+            function GetOrCreateLayer(params: {
+                viewer: Cesium.Viewer;
+                apiGetter?: BruceApi.IGetter;
+                meta: ProjectViewTile.ITileMeta;
+            }): Promise<Cesium.ImageryLayer>;
+            function Render(params: IParams): Promise<void>;
+        }
+    }
+    namespace Terrain {
+        namespace LegacyNavigator {
+            interface IProviderExt extends Cesium.CesiumTerrainProvider {
+                _bId: string;
+                _bName: string;
+            }
+            interface IParams {
+                data: ProjectViewLegacyTile.ITerrainSource;
+                viewer: Cesium.Viewer;
+            }
+            interface IViewParams {
+                bookmarkId: string;
+                viewId: string;
+                apiGetter?: BruceApi.IGetter;
+                viewer: Cesium.Viewer;
+            }
+            function Render(params: IParams): Promise<void>;
+            function RenderView(params: IViewParams): Promise<void>;
+        }
+        namespace Navigator {
+            interface IProviderExt extends Cesium.CesiumTerrainProvider {
+                _bMeta?: ProjectViewTile.ITileMeta;
+            }
+            interface IParams {
+                apiGetter?: BruceApi.IGetter;
+                viewer: Cesium.Viewer;
+                tile: ProjectViewTile.IBookmarkTerrain;
+            }
+            function Render(params: IParams): Promise<void>;
+        }
+    }
+}

package/dist/types/rendering/tileset-render-engine.d.ts

@@ -0,0 +1,99 @@
+import { BruceApi, Carto, EntityCoords, Tileset, Transform } from "bruce-models";
+import * as Cesium from "cesium";
+import { TilesetStyler } from "./tileset-styler";
+declare const WATCH_KEY = "bruce-tileset-watch";
+interface IWatchedTileset extends Cesium.Cesium3DTileset {
+    [WATCH_KEY]?: string;
+}
+export declare namespace TilesetRenderEngine {
+    interface IPositionParams {
+        ucs?: {
+            location?: Carto.ICarto;
+            transform?: Transform.ITransform;
+        };
+        location?: Carto.ICarto;
+        transform?: Transform.ITransform;
+        isLegacy?: boolean;
+        legacyProps?: {
+            usingBoundingBox?: boolean;
+            transform?: boolean;
+            rotate?: boolean;
+        };
+    }
+    interface ISettingsParams {
+        maxScreenSpaceError?: number;
+        attenuation?: boolean;
+        maximumAttenuation?: number;
+        colorMask?: string;
+    }
+    interface ITilesetExt extends Cesium.Cesium3DTileset {
+        _bruceCoords?: IPositionParams;
+        _bruceSettings?: ISettingsParams;
+    }
+    interface IParams {
+        accountId: string;
+        apiGetter: BruceApi.IGetter;
+        tileset: Tileset.ITileset;
+        viewer: Cesium.Viewer;
+        coords?: EntityCoords.IEntityCoords;
+        viaCdn?: boolean;
+        noMemoryLimit?: boolean;
+        modelSpace?: boolean;
+    }
+    /**
+     * Returns when a tileset is ready to be used.
+     * This should be waited for after adding at tileset to the scene and BEFORE any settings are applied to it.
+     * @param cTileset
+     * @returns
+     */
+    function OnTilesetReady(cTileset: Cesium.Cesium3DTileset): Promise<void>;
+    function ApplyPosition(params: {
+        cTileset: Cesium.Cesium3DTileset;
+        position: IPositionParams;
+        modelSpace?: boolean;
+    }): void;
+    function ApplySettings(params: {
+        cTileset: Cesium.Cesium3DTileset;
+        settings: ISettingsParams;
+    }): void;
+    function Render(params: IParams): Promise<Cesium.Cesium3DTileset>;
+    function RenderLegacy(params: {
+        apiGetter: BruceApi.IGetter;
+        accountId: string;
+        viewer: Cesium.Viewer;
+        ionId?: string | number;
+        ionAccessToken?: string;
+        tileset?: any;
+        loadUrl?: string;
+        viaCdn?: boolean;
+        noMemoryLimit?: boolean;
+        backFaceCulling?: boolean;
+    }): Promise<Cesium.Cesium3DTileset>;
+    class Styler extends TilesetStyler {
+    }
+    /**
+     * The maximum memory in MB that can be used by all tilesets.
+     * This is distributed evenly between all loaded tilesets.
+     */
+    let MAX_TILESET_MEMORY: number;
+    /**
+     * Watches tilesets in the viewer.
+     * This will regulate their max memory param.
+     * As more get watched their memory will be reduced.
+     */
+    class MemoryWatcher {
+        private viewer;
+        private watched;
+        constructor(viewer: Cesium.Viewer);
+        private distributeMemory;
+        destroy(): void;
+        /**
+         * Remove all dead tilesets.
+         */
+        private clean;
+        Watch(tileset: IWatchedTileset): void;
+        Unwatch(tileset: IWatchedTileset): void;
+    }
+    function GetMemoryWatcher(viewer: Cesium.Viewer): MemoryWatcher;
+}
+export {};

package/dist/types/rendering/tileset-styler.d.ts

@@ -0,0 +1,86 @@
+import { BruceApi, BruceEvent, Entity, Style } from "bruce-models";
+import * as Cesium from "cesium";
+import { VisualsRegister } from "./visuals-register";
+/**
+ * Returns if the outline metadata is different.
+ * @param rego
+ * @param entity
+ */
+export declare function isOutlineChanged(rego: VisualsRegister.IVisualRego, entity: Entity.IEntity): boolean;
+export declare class TilesetStyler {
+    private api;
+    private disposed;
+    get Disposed(): boolean;
+    private loaded;
+    get Loaded(): boolean;
+    private viewer;
+    private register;
+    private menuItemId;
+    private cTileset;
+    private styleMapping;
+    private styleMappingLoaded;
+    private styleMappingsLoaded;
+    private stylePendingEntityIds;
+    private fallbackStyleId;
+    private fallbackStyle;
+    private loadingCounter;
+    private overrideFeatureColor;
+    private scenario;
+    private expandSources;
+    private historic;
+    private entityGatherer;
+    private shouldUpdateRegoStates;
+    private styledEntityIds;
+    private _styleProgress;
+    get StyleProgress(): number;
+    private _styleProgressQueue;
+    OnStyleProgress: BruceEvent<number>;
+    Init(params: {
+        api: BruceApi.Api;
+        viewer: Cesium.Viewer;
+        register: VisualsRegister.Register;
+        cTileset: Cesium.Cesium3DTileset;
+        fallbackStyleId?: number | string;
+        styleMapping?: any[];
+        expandSources?: boolean;
+        menuItemId?: string;
+        scenario?: number | string;
+        historic?: boolean;
+    }): void;
+    /**
+     * Updates style mapping and fallback style.
+     * This will trigger a re-style of all entities, and will stop existing style loads.
+     * @param params
+     */
+    UpdateStyleMapping(params: {
+        styleMapping?: any[];
+        fallbackStyleId?: number | string;
+        fallbackStyle?: Style.IStyle;
+        expandSources?: boolean;
+        scenario?: number | string;
+        historic?: boolean;
+    }): void;
+    /**
+     * Updates a cache of Entity objects to use when styling.
+     * When a cache is available, a request won't be performed to get that Entity's data.
+     * @param entityIds
+     * @param entities If an object is not available for a supplied Entity ID, then the cache for it is removed.
+     */
+    SetEntityCache(entityIds: string[], entities?: Entity.IEntity[]): void;
+    QueueEntities(regos: VisualsRegister.IVisualRego[], highPriority?: boolean): void;
+    /**
+     * Calculates the current progress % and updates the progress if there is a change.
+     */
+    private updateStyleProgress;
+    private getEntityRego;
+    Dispose(): void;
+    private loadStyles;
+    private disposeGatherer;
+    private getEntityTypeIdsFromModelTree;
+    private digEntityTypeIdsFromModelTreeBranch;
+    private queueTilesetFeatureStyle;
+    private styleTilesetFeature;
+    private styleTilesetFeatureFullData;
+    private getTilesetFeatureStyle;
+    private getTilesetFeatureNeedsFullData;
+}

package/dist/types/rendering/view-render-engine.d.ts

@@ -0,0 +1,32 @@
+import { BruceApi, ProjectView, ProjectViewBookmark, ApiGetters } from "bruce-models";
+import { MenuItemManager } from "./menu-item-manager";
+import * as Cesium from "cesium";
+export declare namespace ViewRenderEngine {
+    interface IRenderParams {
+        viewer?: Cesium.Viewer;
+        manager?: MenuItemManager.Manager;
+        viewId?: string;
+        view?: ProjectView.IView;
+        bookmarkId?: string;
+        bookmark?: ProjectViewBookmark.IBookmark;
+        skipTransition?: boolean;
+        skipCamera?: boolean;
+        getters?: ApiGetters;
+        apiGetter?: BruceApi.IGetter;
+    }
+    function Render(params: IRenderParams): Promise<void>;
+    /**
+     * Moves the camera to a given view + bookmark.
+     * @param params
+     */
+    function FlyTo(params: {
+        viewer?: Cesium.Viewer;
+        manager?: MenuItemManager.Manager;
+        viewId?: string;
+        view?: ProjectView.IView;
+        bookmarkId?: string;
+        bookmark?: ProjectViewBookmark.IBookmark;
+        skipTransition?: boolean;
+        getters?: ApiGetters;
+    }): Promise<void>;
+}

package/dist/types/rendering/visual-register-culler.d.ts

@@ -0,0 +1,18 @@
+import { VisualsRegister } from "./visuals-register";
+import * as Cesium from "cesium";
+export declare namespace VisualRegisterCuller {
+    const VISUAL_CULL_KEY: unique symbol;
+    interface IMonitorDispose {
+        uncull?: boolean;
+    }
+    /**
+     * Will monitor the visuals within a visual register and cull ones that are out of the viewport.
+     * @param params
+     * @returns a dispose function.
+     */
+    function Monitor(params: {
+        register: VisualsRegister.Register;
+    }): (params: IMonitorDispose) => void;
+    function IsCulled(viewer: Cesium.Viewer, rego: VisualsRegister.IVisualRego, visual: VisualsRegister.Visual): any;
+    function MarkShouldRecheck(viewer: Cesium.Viewer): void;
+}