bruce-cesium 7.7.6 → 7.7.8

package/dist/types/bruce-cesium.d.ts

@@ -49,7 +49,12 @@ export * from "./utils/entity-utils";
 export * from "./utils/measure-utils";
 export * from "./utils/style-utils";
 export * from "./utils/view-utils";
+export * from "./utils/cesium-map-grid";
+export * from "./utils/gltf-generator";
+export * from "./utils/gltf-gizmo";
+export * from "./utils/device-profile";
 export * from "./viewer/cesium-view-monitor";
+export * from "./viewer/camera-controls";
 export * from "./viewer/view-ground-area";
 export * from "./viewer/viewer-event-tracker";
 export * from "./viewer/viewer-utils";
@@ -72,7 +77,7 @@ export * from "./widgets/widget-info-view";
 export * from "./widgets/widget-left-panel";
 export * from "./widgets/widget-nav-compass";
 export * from "./widgets/widget-view-bar";
-export declare const VERSION = "7.7.6";
+export declare const VERSION = "7.7.8";
 /**
  * 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.

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

@@ -122,10 +122,17 @@ export declare namespace TilesetRenderEngine {
     function WatchDateRange(viewer: Cesium.Viewer, renderObject: IDateRangeWatchedObject, tileset: any): void;
     function UnwatchDateRange(viewer: Cesium.Viewer, renderObject: IDateRangeWatchedObject): void;
     /**
-     * The maximum memory in MB that can be used by all tilesets.
-     * This is distributed evenly between all loaded tilesets.
+     * Total MB all tilesets may use, split evenly; null leaves it to the DeviceProfile tier.
      */
     let MAX_TILESET_MEMORY: number;
+    /**
+     * Smallest MB share a tileset gets; small, since Cesium coarsens one that needs more.
+     */
+    const MIN_TILESET_MEMORY = 32;
+    /**
+     * Returns the total MB all tilesets may use, from MAX_TILESET_MEMORY or else the device tier.
+     */
+    function GetTilesetMemoryBudget(): number;
     /**
      * Watches tileset date cutoffs and toggles their primitive visibility based on the viewer clock.
      */
@@ -149,6 +156,7 @@ export declare namespace TilesetRenderEngine {
     class MemoryWatcher {
         private viewer;
         private watched;
+        private removeChanged;
         constructor(viewer: Cesium.Viewer);
         private distributeMemory;
         destroy(): void;

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

@@ -2,6 +2,10 @@ import { ApiGetters, BruceApi, ProjectView, ProjectViewBookmark } from "bruce-mo
 import * as Cesium from "cesium";
 import { MenuItemManager } from "./menu-item-manager";
 export declare namespace ViewRenderEngine {
+    /**
+     * A bookmark's own shadows, else the view's defaults unless it is model-space, which reads brighter without.
+     */
+    function ResolveShadows(bSettings: ProjectViewBookmark.IWeb3dSettings, defaults: ProjectViewBookmark.IWeb3dSettings, contentType: ProjectViewBookmark.EContentType): ProjectViewBookmark.Web3d.IShadows;
     /**
      * Returns where a model-space bookmark's camera goes, measured from the origin in effect.
      * @param viewer

package/dist/types/rendering/visuals-register.d.ts

@@ -127,6 +127,8 @@ export declare namespace VisualsRegister {
         private sourceOrderDirty;
         private labelGroups;
         private simulationRemoval;
+        private shadowsRemoval;
+        private entityShadows;
         private labelGroupsChanged;
         get OnLabelGroupsChanged(): BruceEvent<void>;
         private labelHover;
@@ -138,6 +140,7 @@ export declare namespace VisualsRegister {
             viewer: Cesium.Viewer;
             apiGetters?: ApiGetters;
         });
+        private syncEntityShadows;
         private reloadLabels;
         /**
          * Returns the collection a menu item's visuals belong in, creating its data source on first use.
@@ -480,6 +483,7 @@ export declare namespace VisualsRegister {
             keepVisual?: Visual;
             onComplete?: () => void;
         }): void;
+        private promoteTileSibling;
         /**
          * Removes regos matching given visuals.
          * This is used when we cannot unpack properties from the visual any longer to determine its ID.

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

@@ -1,5 +1,6 @@
 import { BruceApi, Cartes, Tileset } from "bruce-models";
 import * as Cesium from "cesium";
+import { DeviceProfile } from "../utils/device-profile";
 /**
  * Render engine to handle LCC / XGrids data through the XGrids library.
  */
@@ -11,6 +12,7 @@ export declare namespace XGridsRenderEngine {
         tileset: Tileset.ITileset;
         flyTo?: boolean;
     }): TRenderObject | null;
+    function GetSplatBudget(sdkBudget: number | undefined, profile: DeviceProfile.IProfile): number;
     function Remove(viewer: Cesium.Viewer, renderObject: TRenderObject): void;
     class AdaptiveLod {
         private viewer;

package/dist/types/utils/cesium-map-grid.d.ts

@@ -0,0 +1,23 @@
+import * as Cesium from "cesium";
+export declare namespace CesiumMapGrid {
+    interface ISettings {
+        enabled: boolean;
+        spacing: number;
+        modelSpace?: boolean;
+    }
+    function GetCurrentSpacing(viewer: Cesium.Viewer): number;
+    function Remove(viewer: Cesium.Viewer): void;
+    function Draw(viewer: Cesium.Viewer, spacingInMeters: number, modelSpace?: boolean): void;
+    /**
+     * Draws a bookmark's grid, or removes the grid when it has none; only model-space draws one.
+     */
+    function Apply(viewer: Cesium.Viewer, grid: {
+        enabled?: boolean;
+        spacing?: number;
+    } | null | undefined, modelSpace: boolean): void;
+    function GetIsEnabled(viewer: Cesium.Viewer): boolean;
+    /**
+     * Returns the last applied grid settings.
+     */
+    function GetSettings(viewer: Cesium.Viewer): ISettings;
+}

package/dist/types/utils/device-profile.d.ts

@@ -0,0 +1,84 @@
+import * as Cesium from "cesium";
+/**
+ * Picks how much the scene may hold in memory on this device, from a hardware guess and past sessions.
+ */
+export declare namespace DeviceProfile {
+    enum ETier {
+        Low = "LOW",
+        Mid = "MID",
+        High = "HIGH"
+    }
+    type TGpuClass = "software" | "mobile" | "integrated" | "discrete" | "unknown";
+    interface IEnvironment {
+        userAgent?: string;
+        maxTouchPoints?: number;
+        deviceMemory?: number;
+        hardwareConcurrency?: number;
+        gpuRenderer?: string;
+        maxTextureSize?: number;
+    }
+    interface IClassification {
+        tier: ETier;
+        gpuClass: TGpuClass;
+        mobile: boolean;
+        reasons: string[];
+    }
+    interface IProfile {
+        tier: ETier;
+        detectedTier: ETier;
+        gpuClass: TGpuClass;
+        mobile: boolean;
+        demoted: number;
+        overridden: boolean;
+        reasons: string[];
+        environment: IEnvironment;
+    }
+    interface IBudget {
+        tilesetMb: number;
+        splats: number;
+    }
+    const BUDGETS: {
+        [key in ETier]: IBudget;
+    };
+    /**
+     * Raised after the override or a demotion changes the tier, so live budgets can be redistributed.
+     */
+    const Changed: Cesium.Event<(...args: any[]) => void>;
+    function ClassifyGpu(renderer: string | undefined): TGpuClass;
+    /**
+     * Guesses a tier from the hardware alone. Unknown hardware stays mid; only clear evidence moves it.
+     */
+    function Classify(env: IEnvironment): IClassification;
+    /**
+     * Returns this device's profile, detecting it once per page. Pass the viewer to read its GL context.
+     */
+    function Get(viewer?: Cesium.Viewer): IProfile;
+    /**
+     * Returns the memory budgets for this device's tier, or for a given tier.
+     */
+    function GetBudget(tier?: ETier): IBudget;
+    /**
+     * Forces a tier, for a user who knows better than the guess. Null returns to detection.
+     */
+    function SetOverride(tier: ETier | null): void;
+    /**
+     * Returns the forced tier, or null while detection decides.
+     */
+    function GetOverride(): ETier | null;
+    /**
+     * Records that a WebGL context was lost, so this and later sessions start a tier lower.
+     */
+    function RecordContextLost(): void;
+    /**
+     * Forgets earlier context losses, for a host that offers a reset.
+     */
+    function ClearDemotion(): void;
+    /**
+     * Reports the viewer's context losses. Safe to call repeatedly.
+     */
+    function WatchViewer(viewer: Cesium.Viewer): void;
+    /**
+     * Forgets the detected hardware and override, for tests.
+     */
+    function Reset(): void;
+}

package/dist/types/utils/gltf-generator.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Writes meshes as binary glTF (GLB), for models simple enough to describe in code rather than ship as files.
+ */
+export declare namespace GltfGenerator {
+    type TVec3 = [number, number, number];
+    type TMatrix = number[];
+    /**
+     * Vertices and triangles collected by the shape functions, one material's worth.
+     */
+    class Mesh {
+        positions: number[];
+        normals: number[];
+        indices: number[];
+        AddVertex(position: TVec3, normal: TVec3): number;
+        /**
+         * Adds a triangle wound so its front faces along normal, whichever order the corners come in.
+         * Per corner normals smooth it; without them every corner takes the face normal.
+         */
+        AddTriangle(a: TVec3, b: TVec3, c: TVec3, normal: TVec3, corners?: [TVec3, TVec3, TVec3]): void;
+        /**
+         * Joins three added vertices into a triangle facing along normal, so shapes can share corners.
+         */
+        AddIndexedTriangle(ia: number, ib: number, ic: number, normal: TVec3): void;
+        get VertexCount(): number;
+    }
+    interface IMaterial {
+        color: [number, number, number, number];
+        metallic?: number;
+        roughness?: number;
+        doubleSided?: boolean;
+    }
+    function Add(a: TVec3, b: TVec3): TVec3;
+    function Sub(a: TVec3, b: TVec3): TVec3;
+    function Scale(a: TVec3, s: number): TVec3;
+    function Dot(a: TVec3, b: TVec3): number;
+    function Cross(a: TVec3, b: TVec3): TVec3;
+    function Normalize(a: TVec3): TVec3;
+    /**
+     * Adds a flat disc facing along normal.
+     */
+    function AddDisc(mesh: Mesh, params: {
+        centre: TVec3;
+        normal: TVec3;
+        radius: number;
+        sides: number;
+        start?: TVec3;
+    }): void;
+    /**
+     * Adds a smooth sided cylinder between two points, closed at the start by default.
+     */
+    function AddCylinder(mesh: Mesh, params: {
+        start: TVec3;
+        end: TVec3;
+        radius: number;
+        sides: number;
+        capStart?: boolean;
+        capEnd?: boolean;
+    }): void;
+    /**
+     * Adds a cone from a base circle to a tip, closed at the base by default.
+     */
+    function AddCone(mesh: Mesh, params: {
+        base: TVec3;
+        tip: TVec3;
+        radius: number;
+        sides: number;
+        faceted?: boolean;
+        start?: TVec3;
+        cap?: boolean;
+    }): void;
+    /**
+     * Adds a smooth ring of tube around an axis through centre.
+     */
+    function AddTorus(mesh: Mesh, params: {
+        centre: TVec3;
+        axis: TVec3;
+        radius: number;
+        tube: number;
+        segments: number;
+        sides: number;
+    }): void;
+    /**
+     * Adds a flat convex outline, given in a plane's own across and up coordinates, facing along normal.
+     */
+    function AddConvexOutline(mesh: Mesh, params: {
+        points: [number, number][];
+        origin: TVec3;
+        across: TVec3;
+        up: TVec3;
+        normal: TVec3;
+    }): void;
+    /**
+     * Packs a mesh into GLB bytes, under a chain of node matrices (outermost first) when given.
+     */
+    function ToGlb(params: {
+        mesh: Mesh;
+        material: IMaterial;
+        matrices?: TMatrix[];
+    }): Uint8Array;
+    /**
+     * Packs a mesh into a GLB data URI, which loads as a model url with nothing to fetch.
+     */
+    function ToDataUri(params: Parameters<typeof ToGlb>[0]): string;
+}

package/dist/types/utils/gltf-gizmo.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The transform gizmo's pieces as GLB data URIs, built on first use so there are no model files to host.
+ * Sizes, colours and frames match the models they replaced (Navigator's public/res/gizmo), scales included.
+ */
+export declare namespace GltfGizmo {
+    enum EPiece {
+        X = "x",
+        Y = "y",
+        Z = "z",
+        XRotation = "x-rot",
+        YRotation = "y-rot",
+        ZRotation = "z-rot"
+    }
+    /**
+     * Returns a piece's model as a data URI, to pass wherever a model url is taken.
+     */
+    function GetUri(piece: EPiece): string;
+}

package/dist/types/utils/view-utils.d.ts

@@ -135,6 +135,10 @@ export declare namespace ViewUtils {
      */
     function SetDefaultImageBasedLighting(imageBasedLighting: any): void;
     function GetDefaultImageBasedLighting(): any;
+    /**
+     * Shadow mode for the Entity graphics this library draws, following the scene's shadow switch.
+     */
+    function GetEntityShadowMode(viewer: Cesium.Viewer): Cesium.ShadowMode;
     function EngineShadesModelsDarker(): boolean;
     /**
      * Resolves the sun colour and intensity to apply for a bookmark's lighting settings.

package/dist/types/viewer/camera-controls.d.ts

@@ -0,0 +1,19 @@
+import * as Cesium from "cesium";
+/**
+ * Mouse navigation that keeps moving near, through and below the ground, where CesiumJS's own controller stalls.
+ */
+export declare namespace CameraControls {
+    /**
+     * Takes over mouse drag and wheel navigation close to the ground; CesiumJS keeps planet scale, pinch and look.
+     */
+    function Attach(viewer: Cesium.Viewer): void;
+    /**
+     * Hands navigation back to CesiumJS's own camera controller, as it was before Attach.
+     */
+    function Detach(viewer: Cesium.Viewer): void;
+    function IsAttached(viewer: Cesium.Viewer): boolean;
+    /**
+     * Switches to navigating model-space measured from the frame getFrame returns, or back to geospatial with null.
+     */
+    function SetModelSpace(viewer: Cesium.Viewer, getFrame: (() => Cesium.Matrix4) | null): void;
+}

package/dist/types/viewer/viewer-utils.d.ts

@@ -19,6 +19,7 @@ export declare namespace ViewerUtils {
         styleContainer?: boolean;
         nextspaceWidgets?: boolean;
         widgetParams?: any;
+        cameraControls?: boolean;
     }): {
         widgets: IDictionary<Widget.AWidget>;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bruce-cesium",
-  "version": "7.7.6",
+  "version": "7.7.8",
   "description": "",
   "keywords": [],
   "main": "dist/bruce-cesium.umd.js",
@@ -66,6 +66,7 @@
     "jest": "^29.7.0",
     "jest-config": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
+    "jest-junit": "^16.0.0",
     "lodash.camelcase": "^4.3.0",
     "prompt": "^1.0.0",
     "replace-in-file": "^3.4.2",
@@ -84,7 +85,7 @@
     "typescript": "^5.0.4"
   },
   "dependencies": {
-    "bruce-models": "^7.1.135",
+    "bruce-models": "^7.1.138",
     "tslib": "^2.4.1"
   }
 }