bruce-cesium 7.2.7 → 7.2.9

package/dist/bruce-cesium.umd.js

@@ -40604,61 +40604,27 @@
     }
 
     (function (TextureFrameSeriesAnimator) {
-        TextureFrameSeriesAnimator.LAYOUT_TILES = "tiles";
-        // The only generation this renderer draws. Anything else is refused rather than half read: the
-        // shapes differ enough that a partial reading produces a plausible wrong surface, which is worse
-        // than an empty one.
-        TextureFrameSeriesAnimator.SUPPORTED_VERSION = 3;
-        // Value in R at 8 bits, or high in R and low in G at 16.
-        TextureFrameSeriesAnimator.FORMAT_U8 = "u8";
-        TextureFrameSeriesAnimator.FORMAT_RG16 = "rg16";
-        // Declared as a field with one value, so a second mode can be added later without an absent
-        // Encoding having to mean anything.
-        TextureFrameSeriesAnimator.ENCODING_ABSOLUTE = "absolute";
-        TextureFrameSeriesAnimator.LAYER_VALUE = "Value";
-        TextureFrameSeriesAnimator.LAYER_VALUE_MIN = "ValueMin";
-        TextureFrameSeriesAnimator.LAYER_VALUE_MAX = "ValueMax";
-        TextureFrameSeriesAnimator.LAYER_BASELINE = "Baseline";
-        // The per-texel correction that was applied, published only on an archive that was transformed.
-        TextureFrameSeriesAnimator.LAYER_VALUE_SHIFT = "ValueShift";
         /**
          * Turns a published value map into the flat shape this renderer works in, or null when it cannot be drawn.
          * @param published the archive's Data.generation
          */
         function Adapt(published) {
-            if (!published || published.Version !== TextureFrameSeriesAnimator.SUPPORTED_VERSION) {
-                const found = published && published.Version != null ? published.Version : "none";
-                const at = published && published.Identity ? published.Identity.Generated : undefined;
-                // In theory should be no files.
-                console.warn("bruce-cesium: value map version " + found + " is not supported (this build reads "
-                    + TextureFrameSeriesAnimator.SUPPORTED_VERSION + "), so nothing will be drawn for it."
-                    + (at ? " The archive was generated at " + at + " and needs regenerating." : ""));
+            const refused = BModels.ClientFileValueMap.Metadata.Unreadable(published);
+            if (refused) {
+                console.warn("bruce-cesium: " + refused + " Nothing will be drawn for it.");
                 return null;
             }
             const geometry = published.Geometry || {};
-            const tiles = published.Tiles || [];
-            if (geometry.Layout !== TextureFrameSeriesAnimator.LAYOUT_TILES || tiles.length === 0) {
-                const at = published.Identity ? published.Identity.Generated : undefined;
-                console.warn("bruce-cesium: value map declares no tiles, so nothing will be drawn for it."
-                    + (at ? " The archive was generated at " + at + " and needs regenerating." : ""));
-                return null;
-            }
             const value = published.Value || {};
-            if (value.Encoding && value.Encoding !== TextureFrameSeriesAnimator.ENCODING_ABSOLUTE) {
-                const at = published.Identity ? published.Identity.Generated : undefined;
-                console.warn("bruce-cesium: value map encoding " + value.Encoding + " is not supported"
-                    + " (this build reads " + TextureFrameSeriesAnimator.ENCODING_ABSOLUTE + "), so nothing will be drawn for it."
-                    + (at ? " The archive was generated at " + at + " and needs regenerating." : ""));
-                return null;
-            }
             const series = published.Series || {};
-            const layerRange = declaredRange(published, TextureFrameSeriesAnimator.LAYER_VALUE_MIN);
+            const layerRange = BModels.ClientFileValueMap.Metadata.LayerRange(published, BModels.ClientFileValueMap.Metadata.LAYER_VALUE_MIN);
+            const tiles = BModels.ClientFileValueMap.Metadata.TilesOf(published);
             const flat = {
                 Frames: [],
                 ValueMin: value.Min,
                 ValueMax: value.Max,
-                Format: value.Format || TextureFrameSeriesAnimator.FORMAT_U8,
-                Encoding: value.Encoding || TextureFrameSeriesAnimator.ENCODING_ABSOLUTE,
+                Format: value.Format || BModels.ClientFileValueMap.Metadata.FORMAT_U8,
+                Encoding: value.Encoding || BModels.ClientFileValueMap.Metadata.ENCODING_ABSOLUTE,
                 Units: value.Units,
                 West: geometry.West,
                 East: geometry.East,
@@ -40668,8 +40634,8 @@
                 ResolutionY: geometry.ResolutionY,
                 PixelPlacement: geometry.PixelPlacement,
                 Times: series.Times,
-                ExtremesValueMin: layerRange ? layerRange.min : undefined,
-                ExtremesValueMax: layerRange ? layerRange.max : undefined,
+                ExtremesValueMin: layerRange ? layerRange.Min : undefined,
+                ExtremesValueMax: layerRange ? layerRange.Max : undefined,
                 // The delivered values are what gets drawn. What the source called them, and any shift
                 // applied on the way, travel for labels and analysis rather than for placement.
                 SourceVerticalDatum: published.ValueSource ? published.ValueSource.VerticalDatum : undefined,
@@ -40679,50 +40645,35 @@
                 SourceValueMax: published.ValueSource ? published.ValueSource.Max : undefined
             };
             flat.Tiles = tiles.map((tile) => adaptTile(tile, series.Times));
-            // The coarsest tile covers the whole extent, so it is what a caller wanting one time list reads.
+            // The tiles arrive coarsest first, so the first one covers the whole extent and is what a
+            // caller wanting one time list reads.
             flat.Frames = flat.Tiles[0].Frames;
-            warnIfUnshifted(published, flat);
+            warnIfUnshifted(published);
             return flat;
         }
         TextureFrameSeriesAnimator.Adapt = Adapt;
         /*
          * Says so when an archive's heights are not on the ellipsoid they will be drawn against.
          */
-        function warnIfUnshifted(published, flat) {
-            const datum = flat.SourceVerticalDatum;
-            if (!datum || datum === TextureFrameSeriesAnimator.DATUM_ELLIPSOIDAL || flat.Transform) {
-                return;
+        function warnIfUnshifted(published) {
+            const said = BModels.ClientFileValueMap.Metadata.UnshiftedWarning(published);
+            if (said) {
+                console.warn("bruce-cesium: " + said);
             }
-            const at = published.Identity ? published.Identity.Generated : undefined;
-            console.warn("bruce-cesium: value map heights are in " + datum + " and report no transform, so"
-                + " they are not ellipsoidal and will draw at the wrong height when placed absolutely."
-                + (at ? " The archive was generated at " + at + " and needs regenerating with the shift"
-                    + " applied." : ""));
-        }
-        /*
-         * The Min and Max a named layer declares, since a statistics layer is encoded over the true data
-         * range rather than over the frames' own.
-         */
-        function declaredRange(published, name) {
-            const layers = published.Layers || [];
-            for (const layer of layers) {
-                if (layer.Name === name && typeof layer.Min === "number" && typeof layer.Max === "number") {
-                    return { min: layer.Min, max: layer.Max };
-                }
-            }
-            return null;
         }
         /*
          * One tile, with its per-time value rasters lined up against the shared time list.
          */
         function adaptTile(tile, times) {
-            const layers = tile.Layers || {};
-            const perTime = layers[TextureFrameSeriesAnimator.LAYER_VALUE] || [];
-            const frames = perTime.map((entry, index) => ({
-                Timestamp: times && times[index] ? times[index] : "",
-                ByteOffset: entry.Bytes.Offset,
-                ByteLength: entry.Bytes.Length
-            }));
+            const perTime = (tile.Layers && tile.Layers[BModels.ClientFileValueMap.Metadata.LAYER_VALUE]) || [];
+            const frames = perTime.map((_entry, index) => {
+                const at = BModels.ClientFileValueMap.Metadata.BytesOf(tile, BModels.ClientFileValueMap.Metadata.LAYER_VALUE, index);
+                return {
+                    Timestamp: times && times[index] ? times[index] : "",
+                    ByteOffset: at ? at.Offset : 0,
+                    ByteLength: at ? at.Length : 0
+                };
+            });
             return {
                 Level: tile.Level,
                 X: tile.X,
@@ -40735,16 +40686,17 @@
                 ResolutionX: tile.ResolutionX,
                 ResolutionY: tile.ResolutionY,
                 Frames: frames,
-                Floor: single(layers[TextureFrameSeriesAnimator.LAYER_VALUE_MIN]),
-                Ceiling: single(layers[TextureFrameSeriesAnimator.LAYER_VALUE_MAX]),
-                BaselineMask: single(layers[TextureFrameSeriesAnimator.LAYER_BASELINE])
+                Floor: entryFor(tile, BModels.ClientFileValueMap.Metadata.LAYER_VALUE_MIN),
+                Ceiling: entryFor(tile, BModels.ClientFileValueMap.Metadata.LAYER_VALUE_MAX),
+                BaselineMask: entryFor(tile, BModels.ClientFileValueMap.Metadata.LAYER_BASELINE)
             };
         }
-        function single(layer) {
-            if (!layer || !layer.Bytes) {
-                return undefined;
-            }
-            return { ByteOffset: layer.Bytes.Offset, ByteLength: layer.Bytes.Length };
+        /*
+         * One tile's single copy of a layer, in the byte shape this renderer's fetching works in.
+         */
+        function entryFor(tile, name) {
+            const at = BModels.ClientFileValueMap.Metadata.BytesOf(tile, name);
+            return at ? { ByteOffset: at.Offset, ByteLength: at.Length } : undefined;
         }
         /**
          * How to turn a delivered value into the number the source published, or null when the archive
@@ -40790,7 +40742,7 @@
          * @param metadata the archive's Data.generation
          */
         function IsPackedValue(metadata) {
-            return Boolean(metadata && metadata.Format === TextureFrameSeriesAnimator.FORMAT_RG16);
+            return Boolean(metadata) && BModels.ClientFileValueMap.Metadata.IsPacked({ Value: { Format: metadata.Format } });
         }
         TextureFrameSeriesAnimator.IsPackedValue = IsPackedValue;
         /**
@@ -40800,10 +40752,7 @@
          * @param at index of the texel's red channel
          */
         function NormalisedAt(metadata, pixels, at) {
-            if (IsPackedValue(metadata)) {
-                return (pixels[at] * 256 + pixels[at + 1]) / 65535;
-            }
-            return pixels[at] / 255;
+            return BModels.ClientFileValueMap.Metadata.NormalisedAt(pixels, at, IsPackedValue(metadata) ? BModels.ClientFileValueMap.Metadata.FORMAT_RG16 : BModels.ClientFileValueMap.Metadata.FORMAT_U8);
         }
         TextureFrameSeriesAnimator.NormalisedAt = NormalisedAt;
         // Values already sit on the ellipsoid Cesium measures against, so nothing is added to place them.
@@ -40836,13 +40785,10 @@
          * @param value in the attribute's units
          */
         function NormalisePosition(metadata, value) {
-            const lo = metadata && typeof metadata.ValueMin === "number" ? metadata.ValueMin : 0;
-            const hi = metadata && typeof metadata.ValueMax === "number" ? metadata.ValueMax : 1;
-            const span = hi - lo;
-            if (!(span > 0)) {
-                return 0;
-            }
-            return Math.min(1, Math.max(0, (value - lo) / span));
+            return BModels.ClientFileValueMap.Metadata.Normalise(value, {
+                Min: metadata && typeof metadata.ValueMin === "number" ? metadata.ValueMin : 0,
+                Max: metadata && typeof metadata.ValueMax === "number" ? metadata.ValueMax : 1
+            });
         }
         TextureFrameSeriesAnimator.NormalisePosition = NormalisePosition;
         /**
@@ -41320,27 +41266,8 @@
              * Composite resolution, capped by what can be uploaded as a texture every frame.
              */
             compositeSize(tiles, target) {
-                let finest = Number.MAX_VALUE;
-                for (const tile of tiles) {
-                    if (tile.TexelMetres > 0) {
-                        finest = Math.min(finest, tile.TexelMetres);
-                    }
-                }
-                if (!(finest > 0) || finest === Number.MAX_VALUE) {
-                    finest = 1;
-                }
-                const mid = (target.South + target.North) / 2 * Math.PI / 180;
-                const widthM = Math.max((target.East - target.West) * 111320 * Math.cos(mid), 1);
-                const heightM = Math.max((target.North - target.South) * 110574, 1);
-                let width = Math.ceil(widthM / finest);
-                let height = Math.ceil(heightM / finest);
-                const longest = Math.max(width, height);
-                if (longest > MAX_COMPOSITE_TEXELS) {
-                    const shrink = MAX_COMPOSITE_TEXELS / longest;
-                    width = Math.max(1, Math.round(width * shrink));
-                    height = Math.max(1, Math.round(height * shrink));
-                }
-                return { width: Math.max(1, width), height: Math.max(1, height) };
+                const size = BModels.ClientFileValueMap.Grid.CompositeSize(tiles, target, MAX_COMPOSITE_TEXELS);
+                return { width: size.Width, height: size.Height };
             }
             /*
              * Applies the ramp, borders and baseline mask to raw value pixels, whatever produced them.
@@ -41464,20 +41391,20 @@
                 const size = this.compositeSize(tiles, target);
                 // One request for the whole extremes block. They sit contiguously after the frames, so
                 // fetching per tile would be 164 round trips for an 82 tile pyramid.
-                let lo = Number.MAX_SAFE_INTEGER;
-                let hi = 0;
+                const ranges = [];
                 for (const tile of tiles) {
                     for (const at of [tile.Floor, tile.Ceiling]) {
-                        if (!at) {
-                            continue;
+                        if (at) {
+                            ranges.push({ Offset: at.ByteOffset, Length: at.ByteLength });
                         }
-                        lo = Math.min(lo, at.ByteOffset);
-                        hi = Math.max(hi, at.ByteOffset + at.ByteLength);
                     }
                 }
-                if (!(hi > lo)) {
+                const span = BModels.ClientFileValueMap.Metadata.SpanOf(ranges);
+                if (!span) {
                     return;
                 }
+                const lo = span.Offset;
+                const hi = span.Offset + span.Length;
                 const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${lo}-${hi - 1}` } });
                 const block = await response.arrayBuffer();
                 if (this.disposed) {
@@ -41522,13 +41449,8 @@
              * background shows between them.
              */
             tileRect(tile, target, size) {
-                const spanLon = target.East - target.West;
-                const spanLat = target.North - target.South;
-                const x0 = Math.round((tile.West - target.West) / spanLon * size.width);
-                const x1 = Math.round((tile.East - target.West) / spanLon * size.width);
-                const y0 = Math.round((target.North - tile.North) / spanLat * size.height);
-                const y1 = Math.round((target.North - tile.South) / spanLat * size.height);
-                return { x: x0, y: y0, w: Math.max(1, x1 - x0), h: Math.max(1, y1 - y0) };
+                const rect = BModels.ClientFileValueMap.Grid.TileRect(tile, target, { Width: size.width, Height: size.height });
+                return { x: rect.Left, y: rect.Top, w: rect.Width, h: rect.Height };
             }
             /*
              * Decodes many tile images at once.
@@ -42424,7 +42346,7 @@
 
     (function (DisplacedSurfacePrimitive) {
         // Grid densities a tile can draw at, coarsest first.
-        const TIERS = [32, 64, 128, 192];
+        const TIERS = [32, 64, 128, 192, 256, 384];
         // Tiles per side the extent is cut into.
         const TILES_PER_SIDE = 6;
         // Screen pixels one grid cell should cover. Lower means finer meshes sooner.
@@ -43072,6 +42994,7 @@ void main() {
                 const camera = frameState.camera;
                 const fovy = camera.frustum && camera.frustum.fovy ? camera.frustum.fovy : Cesium.Math.PI_OVER_THREE;
                 const pixelsPerRadian = frameState.context.drawingBufferHeight / fovy;
+                const ceiling = this.tierCeiling();
                 for (const tile of this.tiles) {
                     if (!tile.centre) {
                         tile.tier = TIERS[0];
@@ -43082,13 +43005,33 @@ void main() {
                     const wanted = screenPixels / TARGET_CELL_PIXELS;
                     let tier = TIERS[0];
                     for (const candidate of TIERS) {
-                        if (candidate <= wanted) {
+                        if (candidate <= wanted && candidate <= ceiling) {
                             tier = candidate;
                         }
                     }
                     tile.tier = tier;
                 }
             }
+            /*
+             * The finest tier worth drawing for this surface, from the texture behind it.
+             *
+             * Subdividing past one vertex per texel spends vertices resolving detail the source does not
+             * carry, so the ladder is capped one step above the texel count rather than run to its top.
+             */
+            tierCeiling() {
+                const source = this.source;
+                if (!source || !source.width || !source.height) {
+                    return TIERS[TIERS.length - 1];
+                }
+                const perSide = Math.sqrt(this.tiles.length) || TILES_PER_SIDE;
+                const texelsPerTile = Math.max(source.width, source.height) / perSide;
+                for (const candidate of TIERS) {
+                    if (candidate >= texelsPerTile) {
+                        return candidate;
+                    }
+                }
+                return TIERS[TIERS.length - 1];
+            }
             shouldReselect(frameState, nowMs) {
                 if (this.selectionDirty) {
                     return true;
@@ -43101,9 +43044,23 @@ void main() {
                     return true;
                 }
                 const moved = Cesium.Cartesian3.distance(eye, this.lastEyePosition);
-                const anchor = this.tiles[0].centre;
-                const reference = anchor ? Math.max(1, Cesium.Cartesian3.distance(eye, anchor)) : 1;
-                return moved / reference > MOVEMENT_THRESHOLD;
+                return moved / this.nearestTileDistance(eye) > MOVEMENT_THRESHOLD;
+            }
+            /*
+             * Distance to the closest tile, measured the way selectTiers measures each one.
+             */
+            nearestTileDistance(eye) {
+                let nearest = Number.POSITIVE_INFINITY;
+                for (const tile of this.tiles) {
+                    if (!tile.centre) {
+                        continue;
+                    }
+                    const distance = Cesium.Cartesian3.distance(eye, tile.centre) - tile.radius;
+                    if (distance < nearest) {
+                        nearest = distance;
+                    }
+                }
+                return isFinite(nearest) ? Math.max(1, nearest) : 1;
             }
             commandFor(context, tile, mesh) {
                 if (!this.shaderProgram) {
@@ -44339,7 +44296,7 @@ void main() {
             return { dataUri: null, effective: null };
         }
         await api.Loading;
-        const clientFile = await BModels.ClientFile.FindGeneratedTexture({ api, entityTypeSourceId, attribute });
+        const { file: clientFile } = await BModels.ClientFileValueMap.Get({ api, entityTypeSourceId, attribute });
         if (!clientFile) {
             return { dataUri: null, effective: null };
         }
@@ -45819,7 +45776,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.2.7";
+    const VERSION = "7.2.9";
     /**
      * 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.