bruce-cesium 7.2.2 → 7.2.4

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, ShaderSource, Cartesian3, Math as Math$1, Ellipsoid, Transforms, Matrix4, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, Cartesian2, DistanceDisplayCondition, JulianDate, Quaternion, HeadingPitchRoll, HeightReference, ColorBlendMode, ShadowMode, ClassificationType, Model, ArcType, CornerType, ConstantPositionProperty, HorizontalOrigin, VerticalOrigin, SceneTransforms, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, NearFarScalar, Matrix3, GeoJsonDataSource, SceneMode, KmlDataSource, Ion, IonResource, Cesium3DTileStyle, HeadingPitchRange, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Cesium3DTileColorBlendMode, Cesium3DTileset, Intersect, OrthographicFrustum, EasingFunction, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, PolygonPipeline, CustomDataSource, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, GeometryInstance, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, CzmlDataSource } from 'cesium';
-import { Cartes, Entity as Entity$1, ProjectViewTile, ENVIRONMENT, Calculator, ClientFile, EntityLod, EntityTag, EntityType, LRUCache, ObjectUtils, Style, Carto, Geometry as Geometry$1, Api, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, Bounds, Color as Color$1, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, RecordChangeFeed, BruceApi, EntityRelation, EntitySource, ProgramKey, ProjectViewLegacyTile, Camera, Account, AccountLimits, Session, UrlUtils, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType, EntityHistoricData } from 'bruce-models';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, DistanceDisplayCondition, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, Matrix4, HeightReference, ColorBlendMode, ShadowMode, ClassificationType, Model, ShaderSource, Ellipsoid, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, Cartesian2, HorizontalOrigin, VerticalOrigin, ConstantPositionProperty, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, ArcType, CornerType, Rectangle, SceneTransforms, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, SceneMode, HeadingPitchRange, Ion, IonResource, Cesium3DTileStyle, Cesium3DTileColorBlendMode, Cesium3DTileset, OrthographicFrustum, EasingFunction, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Intersect, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, CustomDataSource, GeometryInstance, PolygonPipeline, CesiumInspector, defined, ClockRange, DynamicEnvironmentMapManager, EllipsoidGeodesic, sampleTerrainMostDetailed, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
+import { Cartes, Entity as Entity$1, ProjectViewTile, ENVIRONMENT, Calculator, ClientFile, EntityLod, EntityTag, EntityType, LRUCache, ObjectUtils, Style, Api, Bounds, Color as Color$1, Geometry as Geometry$1, Carto, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, BruceApi, AccountConcept, RecordChangeFeed, EntityRelation, Camera, ProgramKey, ProjectViewLegacyTile, EntitySource, Account, AccountLimits, Session, UrlUtils, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType, EntityHistoricData } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -40400,38 +40400,229 @@ function loadImage(src) {
 
 var TextureFrameSeriesAnimator;
 (function (TextureFrameSeriesAnimator) {
-    // Values are measured up from the ground beneath them.
-    TextureFrameSeriesAnimator.QUANTITY_THICKNESS = "thickness";
-    // Values are heights against a vertical datum, so they need that datum to be placed.
-    TextureFrameSeriesAnimator.QUANTITY_ELEVATION = "elevation";
     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";
     /**
-     * The generator that produced an archive, for telling a stale one from a current one.
+     * 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." : ""));
+            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 flat = {
+            Frames: [],
+            ValueMin: value.Min,
+            ValueMax: value.Max,
+            Format: value.Format || TextureFrameSeriesAnimator.FORMAT_U8,
+            Encoding: value.Encoding || TextureFrameSeriesAnimator.ENCODING_ABSOLUTE,
+            Units: value.Units,
+            West: geometry.West,
+            East: geometry.East,
+            South: geometry.South,
+            North: geometry.North,
+            ResolutionX: geometry.ResolutionX,
+            ResolutionY: geometry.ResolutionY,
+            PixelPlacement: geometry.PixelPlacement,
+            Times: series.Times,
+            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,
+            Transform: published.ValueSource ? published.ValueSource.Transform : undefined,
+            SourceUnits: published.ValueSource ? published.ValueSource.Units : undefined,
+            SourceValueMin: published.ValueSource ? published.ValueSource.Min : undefined,
+            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.
+        flat.Frames = flat.Tiles[0].Frames;
+        warnIfUnshifted(published, flat);
+        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;
+        }
+        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
+        }));
+        return {
+            Level: tile.Level,
+            X: tile.X,
+            Y: tile.Y,
+            West: tile.West,
+            East: tile.East,
+            South: tile.South,
+            North: tile.North,
+            TexelMetres: tile.TexelMetres,
+            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])
+        };
+    }
+    function single(layer) {
+        if (!layer || !layer.Bytes) {
+            return undefined;
+        }
+        return { ByteOffset: layer.Bytes.Offset, ByteLength: layer.Bytes.Length };
+    }
+    /**
+     * How to turn a delivered value into the number the source published, or null when the archive
+     * does not say enough to do it.
+     * @param metadata the archive's Data.generation
+     */
+    function SourceMap(metadata) {
+        if (!metadata) {
+            return null;
+        }
+        const { ValueMin, ValueMax, SourceValueMin, SourceValueMax } = metadata;
+        if (typeof ValueMin !== "number" || typeof ValueMax !== "number"
+            || typeof SourceValueMin !== "number" || typeof SourceValueMax !== "number") {
+            return null;
+        }
+        const delivered = ValueMax - ValueMin;
+        // A single delivered value describes no line, so all that can be recovered is where it sits.
+        const scale = delivered !== 0 ? (SourceValueMax - SourceValueMin) / delivered : 1;
+        return { scale, offset: SourceValueMin - ValueMin * scale };
+    }
+    TextureFrameSeriesAnimator.SourceMap = SourceMap;
+    /**
+     * Whether anything was applied to the values on the way out of the source.
+     * @param metadata the archive's Data.generation
+     */
+    function IsTransformed(metadata) {
+        return Boolean(metadata && metadata.Transform);
+    }
+    TextureFrameSeriesAnimator.IsTransformed = IsTransformed;
+    /**
+     * A delivered value in the source's own terms, or unchanged when it cannot be turned back.
+     * @param map from SourceMap(), null when the archive does not say enough
+     */
+    function ToSource(map, value) {
+        return map ? value * map.scale + map.offset : value;
+    }
+    TextureFrameSeriesAnimator.ToSource = ToSource;
+    /**
+     * Whether the archive's frames carry a 16 bit value packed across R and G.
      *
-     * Read the version rather than sniffing for fields: an archive can legitimately omit Tiles or
-     * GeoidSeparation and still be current, so their absence says nothing about its age.
+     * Every consumer that reads a texel has to ask: taking R alone from a packed frame yields a
+     * plausible surface quantised to 255 steps of the full range rather than an obvious failure.
+     * @param metadata the archive's Data.generation
+     */
+    function IsPackedValue(metadata) {
+        return Boolean(metadata && metadata.Format === TextureFrameSeriesAnimator.FORMAT_RG16);
+    }
+    TextureFrameSeriesAnimator.IsPackedValue = IsPackedValue;
+    /**
+     * The normalised 0 to 1 value at a texel, from whichever format the archive packed it in.
      * @param metadata the archive's Data.generation
+     * @param pixels untinted RGBA value pixels
+     * @param at index of the texel's red channel
      */
-    function GeneratorVersion(metadata) {
-        if (!metadata || typeof metadata.GeneratorVersion !== "number") {
-            return 1;
+    function NormalisedAt(metadata, pixels, at) {
+        if (IsPackedValue(metadata)) {
+            return (pixels[at] * 256 + pixels[at + 1]) / 65535;
         }
-        return metadata.GeneratorVersion;
+        return pixels[at] / 255;
     }
-    TextureFrameSeriesAnimator.GeneratorVersion = GeneratorVersion;
+    TextureFrameSeriesAnimator.NormalisedAt = NormalisedAt;
+    // Values already sit on the ellipsoid Cesium measures against, so nothing is added to place them.
+    TextureFrameSeriesAnimator.DATUM_ELLIPSOIDAL = "WGS84";
     /**
-     * Whether an archive is an adaptive pyramid rather than one raster.
+     * Whether the values are heights against a vertical datum rather than a thickness.
+     *
+     * A thickness rises from wherever the polygon sits and a height already knows where it belongs, so
+     * this is what decides whether the polygon's own altitude may be added underneath it.
      * @param metadata the archive's Data.generation
      */
-    function IsTiledLayout(metadata) {
-        return (Boolean(metadata && metadata.Layout === TextureFrameSeriesAnimator.LAYOUT_TILES &&
-            metadata.Tiles && metadata.Tiles.length > 0));
-    }
-    TextureFrameSeriesAnimator.IsTiledLayout = IsTiledLayout;
-    // Frames carry the value as the source reported it.
-    TextureFrameSeriesAnimator.MEASURE_ABSOLUTE = "absolute";
-    // Frames carry the value minus each cell's own minimum over the series.
-    TextureFrameSeriesAnimator.MEASURE_ANOMALY = "anomaly";
+    function IsDatumHeight(metadata) {
+        return Boolean(metadata && metadata.SourceVerticalDatum);
+    }
+    TextureFrameSeriesAnimator.IsDatumHeight = IsDatumHeight;
+    /**
+     * The archive's tiles, which Adapt() guarantees are present.
+     * @param metadata the archive's Data.generation
+     */
+    function TilesOf(metadata) {
+        return (metadata && metadata.Tiles) || [];
+    }
+    TextureFrameSeriesAnimator.TilesOf = TilesOf;
     /**
      * Turns a value in the attribute's own units into the 0 to 1 position the ramp is indexed by.
      *
@@ -40450,44 +40641,18 @@ var TextureFrameSeriesAnimator;
         return Math.min(1, Math.max(0, (value - lo) / span));
     }
     TextureFrameSeriesAnimator.NormalisePosition = NormalisePosition;
-    /**
-     * Whether the frames are a departure from each cell's own normal rather than a raw reading.
-     *
-     * Worth asking before labelling anything: the two measures need different words for the same
-     * number, and calling an anomaly "water depth" is a worse error than the coarse ramp it replaced.
-     * @param metadata the archive's Data.generation
-     */
-    function IsAnomalyMeasure(metadata) {
-        return Boolean(metadata && metadata.Measure === TextureFrameSeriesAnimator.MEASURE_ANOMALY);
-    }
-    TextureFrameSeriesAnimator.IsAnomalyMeasure = IsAnomalyMeasure;
-    /**
-     * How much the value moves anywhere in the series, in source units.
-     *
-     * Falls back to the published range, which is the right answer for an anomaly archive (its range
-     * IS the movement) and the only available one for an archive predating AnomalyMax.
-     * @param metadata the archive's Data.generation
-     */
-    function MovingRange(metadata) {
-        if (!metadata) {
-            return undefined;
-        }
-        if (typeof metadata.AnomalyMax === "number" && metadata.AnomalyMax > 0) {
-            return metadata.AnomalyMax;
-        }
-        if (typeof metadata.ValueMin === "number" && typeof metadata.ValueMax === "number") {
-            return Math.abs(metadata.ValueMax - metadata.ValueMin);
-        }
-        return undefined;
-    }
-    TextureFrameSeriesAnimator.MovingRange = MovingRange;
     /**
      * Detects whether a ClientFile's `Data.generation` metadata describes a frame archive rather than a single static image,
      * so a caller can decide whether to construct an Animator or fall back to the existing static-texture path.
-     * @param data ClientFile.Data (the `IFile.Data` field), as returned by ClientFile.Get().
+     * @param data ClientFile.Data
      */
     function IsFrameArchiveMetadata(data) {
-        return Boolean(data && data.generation && Array.isArray(data.generation.Frames) && data.generation.Frames.length > 0);
+        const generation = data && data.generation;
+        if (!generation) {
+            return false;
+        }
+        return (typeof generation.Version === "number" ||
+            (Array.isArray(generation.Frames) && generation.Frames.length > 0));
     }
     TextureFrameSeriesAnimator.IsFrameArchiveMetadata = IsFrameArchiveMetadata;
     // First resolvable static number out of a calculator field list, since that is all a border needs.
@@ -40533,10 +40698,27 @@ var TextureFrameSeriesAnimator;
     TextureFrameSeriesAnimator.AppearanceSignature = AppearanceSignature;
     const MAX_COMPOSITE_TEXELS = 2048;
     const VALUE_DILATE_PASSES = 2;
+    /*
+     * Rewrites a packed 16 bit value as the 8 bit grey the colour ramps index on.
+     *
+     * All three channels, since a ramp is free to read any of them and a leftover low byte in G would
+     * show up as a green cast on the one that reads them all.
+     */
+    function flattenPacked(pixels, packed) {
+        if (!packed) {
+            return;
+        }
+        for (let i = 0; i < pixels.length; i += 4) {
+            const grey = Math.round((pixels[i] * 256 + pixels[i + 1]) / 65535 * 255);
+            pixels[i] = grey;
+            pixels[i + 1] = grey;
+            pixels[i + 2] = grey;
+        }
+    }
     /*
      * Bleeds covered values outward into uncovered texels, leaving alpha untouched.
      */
-    function dilateValues(value, width, height, passes) {
+    function dilateValues(value, width, height, passes, packed) {
         const texels = width * height;
         const filled = new Uint8Array(texels);
         for (let p = 0; p < texels; p++) {
@@ -40560,15 +40742,25 @@ var TextureFrameSeriesAnimator;
                             if (nx < 0 || ny < 0 || nx >= width || ny >= height || !wasFilled[ny * width + nx]) {
                                 continue;
                             }
-                            sum += source[(ny * width + nx) * 4];
+                            const at = (ny * width + nx) * 4;
+                            // Averaged as a value rather than per byte: averaging a packed low byte
+                            // on its own wraps at every 256th step and speckles the bled edge.
+                            sum += packed ? source[at] * 256 + source[at + 1] : source[at];
                             hits++;
                         }
                     }
                     if (hits > 0) {
                         const v = Math.round(sum / hits);
-                        value[p * 4] = v;
-                        value[p * 4 + 1] = v;
-                        value[p * 4 + 2] = v;
+                        if (packed) {
+                            value[p * 4] = (v >> 8) & 255;
+                            value[p * 4 + 1] = v & 255;
+                            value[p * 4 + 2] = 0;
+                        }
+                        else {
+                            value[p * 4] = v;
+                            value[p * 4 + 1] = v;
+                            value[p * 4 + 2] = v;
+                        }
                         filled[p] = 1;
                     }
                 }
@@ -40606,7 +40798,6 @@ var TextureFrameSeriesAnimator;
             // forcing Cesium to re-upload the texture only when something changed.
             this.pool = [document.createElement("canvas"), document.createElement("canvas")];
             this.poolIdx = 0;
-            this.scratch = null;
             this.valueDims = null;
             this.presentVersion = 0;
             this.extremesLoad = null;
@@ -40629,7 +40820,7 @@ var TextureFrameSeriesAnimator;
             this.highColor = (mask && Color$1.ColorFromStr(mask.maxColor)) || DEFAULT_HIGH_COLOR;
             // Positions are authored in the attribute's units and normalised once here, so the
             // per-pixel loop stays a comparison against 0 to 1 like the two-colour path.
-            const points = mask === null || mask === void 0 ? void 0 : mask.points;
+            const points = mask && mask.points;
             this.rampStops = (points && points.length > 0)
                 ? points.map((p) => ({
                     position: NormalisePosition(options.metadata, p.position),
@@ -40655,9 +40846,8 @@ var TextureFrameSeriesAnimator;
             this.produceValueCanvas = Boolean(options.produceValueCanvas);
             this.metadata = options.metadata;
             this.drapeExtent = options.drapeExtent;
-            this.tiles = IsTiledLayout(options.metadata) ? options.metadata.Tiles : undefined;
-            this.baselineMaskEntry = options.baselineMask || null;
-            this.maskBaseline = (_c = options.maskBaseline) !== null && _c !== void 0 ? _c : Boolean(options.baselineMask);
+            this.tiles = TilesOf(options.metadata);
+            this.maskBaseline = (_c = options.maskBaseline) !== null && _c !== void 0 ? _c : this.tiles.some((tile) => Boolean(tile.BaselineMask));
             this.valueCanvas = this.produceValueCanvas ? document.createElement("canvas") : null;
             this.driveMaterial = options.driveMaterial !== false;
             this.originalMaterial = options.entity.polygon.material;
@@ -40833,32 +41023,20 @@ var TextureFrameSeriesAnimator;
         }
         async fetchAndTint(idx) {
             const tiles = this.tiles;
-            let buffer;
-            let span = 0;
-            if (tiles) {
-                // Every tile's frame for one timestep sits contiguously, because the generator writes
-                // frame major. So a tiled frame is still ONE range request, not one per tile.
-                let lo = Number.MAX_SAFE_INTEGER;
-                let hi = 0;
-                for (const tile of tiles) {
-                    const at = tile.Frames[idx];
-                    if (!at) {
-                        continue;
-                    }
-                    lo = Math.min(lo, at.ByteOffset);
-                    hi = Math.max(hi, at.ByteOffset + at.ByteLength);
+            // Every tile's frame for one timestep sits contiguously, because the generator writes
+            // frame major. So a tiled frame is still ONE range request, not one per tile.
+            let lo = Number.MAX_SAFE_INTEGER;
+            let hi = 0;
+            for (const tile of tiles) {
+                const at = tile.Frames[idx];
+                if (!at) {
+                    continue;
                 }
-                span = lo;
-                const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${lo}-${hi - 1}` } });
-                buffer = await response.arrayBuffer();
-            }
-            else {
-                const entry = this.frames[idx];
-                const start = entry.ByteOffset;
-                const end = entry.ByteOffset + entry.ByteLength - 1;
-                const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${start}-${end}` } });
-                buffer = await response.arrayBuffer();
+                lo = Math.min(lo, at.ByteOffset);
+                hi = Math.max(hi, at.ByteOffset + at.ByteLength);
             }
+            const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${lo}-${hi - 1}` } });
+            const buffer = await response.arrayBuffer();
             if (this.disposed) {
                 return;
             }
@@ -40868,9 +41046,7 @@ var TextureFrameSeriesAnimator;
             if (this.disposed) {
                 return;
             }
-            const decoded = tiles
-                ? await this.composeTiles(tiles, idx, buffer, span)
-                : await this.decodeAndTint(buffer);
+            const decoded = await this.composeTiles(tiles, idx, buffer, lo);
             if (this.disposed) {
                 return;
             }
@@ -40881,26 +41057,6 @@ var TextureFrameSeriesAnimator;
                 this.beginCrossfadeTo(idx);
             }
         }
-        /**
-         * Decodes one frame's raw PNG bytes (as returned by a Range GET) and applies the grayscale color mask.
-         */
-        async decodeAndTint(buffer) {
-            const blob = new Blob([buffer], { type: "image/png" });
-            const objectUrl = URL.createObjectURL(blob);
-            let image;
-            try {
-                image = await loadImage(objectUrl);
-            }
-            finally {
-                URL.revokeObjectURL(objectUrl);
-            }
-            const canvas = document.createElement("canvas");
-            canvas.width = image.width;
-            canvas.height = image.height;
-            const ctx = canvas.getContext("2d");
-            ctx.drawImage(image, 0, 0);
-            return this.tint(ctx.getImageData(0, 0, canvas.width, canvas.height));
-        }
         /*
          * Draws every tile of one frame into a single raster covering the drape extent.
          */
@@ -40973,6 +41129,10 @@ var TextureFrameSeriesAnimator;
             // Copied before tinting: the ramp is a lerp between two colours, so the value cannot be
             // recovered from the tinted pixels afterwards.
             const valuePixels = this.produceValueCanvas ? new Uint8ClampedArray(imageData.data) : undefined;
+            // The ramp indexes on R as an 8 bit grey, so a packed frame is flattened to one here
+            // rather than teaching every ramp function a second format.
+            // The copy above keeps the packed pair, which is what displacement and labels read.
+            flattenPacked(imageData.data, IsPackedValue(this.metadata));
             // Stops win when supplied: they can express a band and a hidden floor, which a two
             // colour ramp cannot. The pair stays the fallback so an older style still draws.
             if (this.rampStops && this.rampStops.length > 0) {
@@ -40986,72 +41146,20 @@ var TextureFrameSeriesAnimator;
             }
             this.applyBaselineMask(imageData.data, valuePixels, canvas.width, canvas.height);
             if (valuePixels) {
-                dilateValues(valuePixels, canvas.width, canvas.height, VALUE_DILATE_PASSES);
+                dilateValues(valuePixels, canvas.width, canvas.height, VALUE_DILATE_PASSES, IsPackedValue(this.metadata));
             }
             return { pixels: imageData.data, width: canvas.width, height: canvas.height, valuePixels };
         }
         /*
-         * Paints one frame's pixels onto a canvas, resampled into the drape extent when there is one.
+         * Paints one frame's composited pixels onto a canvas.
          */
         writeInto(canvas, pixels, dims) {
-            const rect = this.sourceRect(dims);
-            if (!rect) {
-                canvas.width = dims.width;
-                canvas.height = dims.height;
-                const direct = canvas.getContext("2d");
-                const image = direct.createImageData(dims.width, dims.height);
-                image.data.set(pixels);
-                direct.putImageData(image, 0, 0);
-                return;
-            }
-            if (!this.scratch) {
-                this.scratch = document.createElement("canvas");
-            }
-            this.scratch.width = dims.width;
-            this.scratch.height = dims.height;
-            const scratchCtx = this.scratch.getContext("2d");
-            const image = scratchCtx.createImageData(dims.width, dims.height);
-            image.data.set(pixels);
-            scratchCtx.putImageData(image, 0, 0);
             canvas.width = dims.width;
             canvas.height = dims.height;
             const ctx = canvas.getContext("2d");
-            // Nearest neighbour: a value texel has to survive the resample exactly, or a label reads
-            // a blend of two cells rather than the cell it points at.
-            ctx.imageSmoothingEnabled = false;
-            ctx.clearRect(0, 0, dims.width, dims.height);
-            ctx.drawImage(this.scratch, rect.x, rect.y, rect.width, rect.height, 0, 0, dims.width, dims.height);
-        }
-        /*
-         * The part of the archive raster that the drape extent covers, in source pixels.
-         */
-        sourceRect(dims) {
-            const drape = this.drapeExtent;
-            const m = this.metadata;
-            // A composited frame was drawn into the drape extent already, so resampling it again
-            // would apply the same correction twice.
-            if (this.tiles) {
-                return null;
-            }
-            if (!drape || !m || m.West == null || m.East == null || m.South == null || m.North == null) {
-                return null;
-            }
-            const spanLon = m.East - m.West;
-            const spanLat = m.North - m.South;
-            if (!(spanLon > 0) || !(spanLat > 0)) {
-                return null;
-            }
-            const x = (drape.West - m.West) / spanLon * dims.width;
-            const width = (drape.East - drape.West) / spanLon * dims.width;
-            const y = (m.North - drape.North) / spanLat * dims.height;
-            const height = (drape.North - drape.South) / spanLat * dims.height;
-            // A drape that already matches the archive is the common case and must not pay for a
-            // resample, nor lose a half pixel to rounding.
-            if (Math.abs(x) < 0.01 && Math.abs(y) < 0.01
-                && Math.abs(width - dims.width) < 0.01 && Math.abs(height - dims.height) < 0.01) {
-                return null;
-            }
-            return { x, y, width, height };
+            const image = ctx.createImageData(dims.width, dims.height);
+            image.data.set(pixels);
+            ctx.putImageData(image, 0, 0);
         }
         /**
          * The archive's per-cell floor and ceiling rasters, once EnsureExtremes has resolved.
@@ -41063,45 +41171,16 @@ var TextureFrameSeriesAnimator;
          * Fetches and decodes the floor and ceiling rasters, at most once.
          */
         EnsureExtremes() {
-            if (this.extremesLoad) {
-                return this.extremesLoad;
-            }
-            if (this.tiles) {
+            if (!this.extremesLoad) {
                 this.extremesLoad = this.loadTiledExtremes();
-                return this.extremesLoad;
-            }
-            const floor = this.metadata && this.metadata.Floor;
-            const ceiling = this.metadata && this.metadata.Ceiling;
-            if (!floor && !ceiling) {
-                this.extremesLoad = Promise.resolve();
-                return this.extremesLoad;
-            }
-            this.extremesLoad = Promise.all([
-                floor ? this.loadImageDataAt(floor) : Promise.resolve(null),
-                ceiling ? this.loadImageDataAt(ceiling) : Promise.resolve(null)
-            ]).then(([f, c]) => {
-                if (this.disposed) {
-                    return;
-                }
-                this.floorPixels = f;
-                this.ceilingPixels = c;
-            }).catch((e) => {
-                // Missing extremes cost a label its range, and must not take the animation with them.
-                console.warn("TextureFrameSeriesAnimator: could not load the extremes rasters.", e);
-            });
+            }
             return this.extremesLoad;
         }
         /*
          * Composites each tile's baseline mask into one covering the composited frames.
-         *
-         * A tiled archive publishes the mask per tile, so reading the archive level BaselineMask
-         * finds nothing and hiding dry cells silently does nothing at all.
          */
         async loadTiledBaselineMask() {
             const tiles = this.tiles;
-            if (!tiles) {
-                return;
-            }
             const entries = tiles.map((tile) => tile.BaselineMask);
             let lo = Number.MAX_SAFE_INTEGER;
             let hi = 0;
@@ -41155,14 +41234,11 @@ var TextureFrameSeriesAnimator;
         /*
          * Composites each tile's floor and ceiling into rasters matching the composited frames.
          *
-         * A tiled archive has no whole-extent extremes to fetch, only per-tile ones, and a label
-         * indexes them by the same texel as the value canvas, so they have to be laid out the same way.
+         * A label indexes them by the same texel as the value canvas, so they have to be laid out the
+         * same way rather than fetched as whole-extent rasters.
          */
         async loadTiledExtremes() {
             const tiles = this.tiles;
-            if (!tiles) {
-                return;
-            }
             const target = this.compositeExtent();
             const size = this.compositeSize(tiles, target);
             // One request for the whole extremes block. They sit contiguously after the frames, so
@@ -41257,70 +41333,6 @@ var TextureFrameSeriesAnimator;
                 }
             }));
         }
-        /*
-         * Range GETs one entry and decodes it to an image.
-         */
-        async loadImageAt(entry) {
-            const start = entry.ByteOffset;
-            const end = entry.ByteOffset + entry.ByteLength - 1;
-            const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${start}-${end}` } });
-            const buffer = await response.arrayBuffer();
-            const objectUrl = URL.createObjectURL(new Blob([buffer], { type: "image/png" }));
-            try {
-                return await loadImage(objectUrl);
-            }
-            finally {
-                URL.revokeObjectURL(objectUrl);
-            }
-        }
-        /*
-         * Puts a static raster through the same resample the frames get.
-         */
-        remap(image) {
-            if (!image) {
-                return null;
-            }
-            const rect = this.sourceRect({ width: image.width, height: image.height });
-            if (!rect) {
-                return image;
-            }
-            const from = document.createElement("canvas");
-            from.width = image.width;
-            from.height = image.height;
-            from.getContext("2d").putImageData(image, 0, 0);
-            const to = document.createElement("canvas");
-            to.width = image.width;
-            to.height = image.height;
-            const ctx = to.getContext("2d");
-            ctx.imageSmoothingEnabled = false;
-            ctx.clearRect(0, 0, image.width, image.height);
-            ctx.drawImage(from, rect.x, rect.y, rect.width, rect.height, 0, 0, image.width, image.height);
-            return ctx.getImageData(0, 0, image.width, image.height);
-        }
-        /*
-         * Range GETs one entry out of the blob and decodes it to pixels.
-         */
-        async loadImageDataAt(entry) {
-            const start = entry.ByteOffset;
-            const end = entry.ByteOffset + entry.ByteLength - 1;
-            const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${start}-${end}` } });
-            const buffer = await response.arrayBuffer();
-            const blob = new Blob([buffer], { type: "image/png" });
-            const objectUrl = URL.createObjectURL(blob);
-            let image;
-            try {
-                image = await loadImage(objectUrl);
-            }
-            finally {
-                URL.revokeObjectURL(objectUrl);
-            }
-            const canvas = document.createElement("canvas");
-            canvas.width = image.width;
-            canvas.height = image.height;
-            const ctx = canvas.getContext("2d");
-            ctx.drawImage(image, 0, 0);
-            return ctx.getImageData(0, 0, canvas.width, canvas.height);
-        }
         /**
          * Fetches and decodes the archive's static baseline mask, at most once.
          */
@@ -41515,6 +41527,52 @@ var TextureValueLabels;
         return out;
     }
     TextureValueLabels.ClipOutline = ClipOutline;
+    /**
+     * One cell's numbers as a label should print them, or null where the texture has no data there.
+     * @param params at is the index of the cell's red channel. sourceMap is derived from the metadata
+     * when omitted, which a caller reading many cells should hoist rather than repeat.
+     */
+    function ReadingAt(params) {
+        const { metadata, source, floor, ceiling, at } = params;
+        if (source.data[at + 3] < 128) {
+            return null;
+        }
+        const lo = metadata && typeof metadata.ValueMin === "number" ? metadata.ValueMin : 0;
+        const hi = metadata && typeof metadata.ValueMax === "number" ? metadata.ValueMax : 1;
+        const normalised = TextureFrameSeriesAnimator.NormalisedAt(metadata, source.data, at);
+        const toSource = params.sourceMap !== undefined
+            ? params.sourceMap
+            : TextureFrameSeriesAnimator.SourceMap(metadata);
+        const inSource = (value) => TextureFrameSeriesAnimator.ToSource(toSource, value);
+        const reading = { value: inSource(lo + normalised * (hi - lo)) };
+        if (TextureFrameSeriesAnimator.IsTransformed(metadata)) {
+            return reading;
+        }
+        const eLo = metadata && metadata.ExtremesValueMin;
+        const eHi = metadata && metadata.ExtremesValueMax;
+        if (typeof eLo === "number" && typeof eHi === "number") {
+            if (floor) {
+                reading.floor = inSource(eLo + decode16(floor.data, at) * (eHi - eLo));
+            }
+            if (ceiling) {
+                reading.ceiling = inSource(eLo + decode16(ceiling.data, at) * (eHi - eLo));
+            }
+        }
+        return reading;
+    }
+    TextureValueLabels.ReadingAt = ReadingAt;
+    /**
+     * The unit a label's value line should name, or undefined when the archive states none.
+     * @param metadata the archive's Data.generation
+     */
+    function LabelUnits(metadata) {
+        if (!metadata) {
+            return undefined;
+        }
+        const recovered = TextureFrameSeriesAnimator.SourceMap(metadata);
+        return (recovered && metadata.SourceUnits) || metadata.Units;
+    }
+    TextureValueLabels.LabelUnits = LabelUnits;
     /**
      * How many cells apart labels should sit, as a power of two.
      * @param options cellPixels is one cell's size on screen, held is the stride already in use
@@ -41541,6 +41599,7 @@ var TextureValueLabels;
     TextureValueLabels.ChooseLabelStride = ChooseLabelStride;
     class Labels {
         constructor(options) {
+            this.sourceMap = null;
             this.source = null;
             this.painted = null;
             this.floor = null;
@@ -41552,6 +41611,9 @@ var TextureValueLabels;
             this.extent = options.extent;
             this.settings = options.settings || {};
             this.metadata = options.metadata;
+            // Once per overlay rather than once per cell: a label pass probes thousands of texels
+            // looking for one worth labelling, and the map cannot change while the metadata does not.
+            this.sourceMap = TextureFrameSeriesAnimator.SourceMap(options.metadata);
             this.tiles = options.tiles;
             this.clipRing = options.clipRing;
             this.canvas = document.createElement("canvas");
@@ -41967,13 +42029,14 @@ var TextureValueLabels;
         widestLabel(parts) {
             const sample = [];
             if (parts.indexOf("value") >= 0) {
-                sample.push("-000.00");
+                sample.push(valueLine("-000.00", LabelUnits(this.metadata)));
             }
             const range = [];
-            if (parts.indexOf("floor") >= 0) {
+            const showsRange = !TextureFrameSeriesAnimator.IsTransformed(this.metadata);
+            if (showsRange && parts.indexOf("floor") >= 0) {
                 range.push("min: -000.00");
             }
-            if (parts.indexOf("ceiling") >= 0) {
+            if (showsRange && parts.indexOf("ceiling") >= 0) {
                 range.push("max: -000.00");
             }
             if (range.length) {
@@ -42007,7 +42070,7 @@ var TextureValueLabels;
             const dp = (_a = this.settings.decimals) !== null && _a !== void 0 ? _a : (Math.abs(reading.value) < 10 ? 2 : 1);
             const lines = [];
             if (parts.indexOf("value") >= 0) {
-                lines.push(reading.value.toFixed(dp));
+                lines.push(valueLine(reading.value.toFixed(dp), LabelUnits(this.metadata)));
             }
             // Named rather than a bare pair: two numbers under a third say nothing about which is
             // the series low and which is its high.
@@ -42081,29 +42144,17 @@ var TextureValueLabels;
         }
         // Decodes one cell, skipping anything the texture marks as having no data.
         readAt(col, row, cols) {
-            var _a, _b;
-            const i = (row * cols + col) * 4;
-            if (!this.source || this.source.data[i + 3] < 128) {
+            if (!this.source) {
                 return null;
             }
-            const lo = this.metadata && typeof this.metadata.ValueMin === "number" ? this.metadata.ValueMin : 0;
-            const hi = this.metadata && typeof this.metadata.ValueMax === "number" ? this.metadata.ValueMax : 1;
-            const value = lo + (this.source.data[i] / 255) * (hi - lo);
-            const reading = { value };
-            const eLo = (_a = this.metadata) === null || _a === void 0 ? void 0 : _a.ExtremesValueMin;
-            const eHi = (_b = this.metadata) === null || _b === void 0 ? void 0 : _b.ExtremesValueMax;
-            if (this.floor && typeof eLo === "number" && typeof eHi === "number") {
-                reading.floor = eLo + decode16(this.floor.data, i) * (eHi - eLo);
-                // An anomaly archive's frames are already floor-relative, so the reading a user
-                // wants is the absolute one. This is the whole reason the floor is published.
-                if (TextureFrameSeriesAnimator.IsAnomalyMeasure(this.metadata)) {
-                    reading.value += reading.floor;
-                }
-            }
-            if (this.ceiling && typeof eLo === "number" && typeof eHi === "number") {
-                reading.ceiling = eLo + decode16(this.ceiling.data, i) * (eHi - eLo);
-            }
-            return reading;
+            return ReadingAt({
+                metadata: this.metadata,
+                source: this.source,
+                floor: this.floor,
+                ceiling: this.ceiling,
+                at: (row * cols + col) * 4,
+                sourceMap: this.sourceMap
+            });
         }
         lonAt(col, cols) {
             return this.extent.West + ((col + 0.5) / cols) * (this.extent.East - this.extent.West);
@@ -42142,6 +42193,13 @@ var TextureValueLabels;
         }
     }
     TextureValueLabels.Labels = Labels;
+    /*
+     * The value line. Units go on it alone: repeating them on the range underneath doubles the widest
+     * label to say nothing, and the two lines are plainly the same quantity.
+     */
+    function valueLine(value, units) {
+        return units ? `${value} (${units})` : value;
+    }
     function decode16(data, i) {
         return (data[i] * 256 + data[i + 1]) / 65535;
     }
@@ -42167,11 +42225,6 @@ var DisplacedSurfacePrimitive;
     const SKIRT_FRACTION = 0.015;
     // Alpha below which a texel counts as no-data and is not drawn at all.
     const COVERAGE_CUTOFF = 0.35;
-    // With no exaggeration stated, the full value range is drawn as this fraction of the extent's shorter side.
-    const AUTO_RELIEF_FRACTION = 0.02;
-    // Ceiling on the derived relief. Sizing purely off the extent is fine for a parcel and absurd for
-    // a whole estuary: 4 m of water over an 82 km extent came out 1.6 km tall.
-    const AUTO_MAX_RELIEF_METRES = 250.0;
     // Terrain is sampled on this grid and interpolated between samples.
     // Per-texel sampling would be hundreds of thousands of lookups for a surface whose own data is far coarser than that.
     const GROUND_SAMPLES_PER_SIDE = 64;
@@ -42192,6 +42245,7 @@ in float skirt;
 
 uniform sampler2D u_valueTexture;
 uniform sampler2D u_groundTexture;
+uniform float u_valuePacked;
 uniform float u_valueMin;
 uniform float u_valueRange;
 uniform float u_exaggeration;
@@ -42229,18 +42283,37 @@ float sampleGround(vec2 uv) {
     return mix(mix(h00, h10, f.x), mix(h01, h11, f.x), f.y);
 }
 
+/*
+ * The texel's normalised value, whichever way the archive packed it.
+ *
+ * A packed frame keeps the high byte in R, so reading R alone would quantise the whole range to 255
+ * steps and draw a plausible wrong surface rather than an obviously broken one.
+ *
+ * Each channel is scaled and then added, rather than reassembled to a 0..65535 integer and divided.
+ * That integer is outside the range mediump guarantees, and a fragment shader only gets highp where
+ * the device offers it, so the obvious form loses the low byte on exactly the older mobile hardware
+ * that Cesium falls back to mediump for.
+ */
+float decodeValue(vec4 texel) {
+    float packed16 = texel.r * (255.0 * 256.0 / 65535.0) + texel.g * (255.0 / 65535.0);
+    return mix(texel.r, packed16, u_valuePacked);
+}
+
 void main() {
     vec4 texel = texture(u_valueTexture, st);
     v_st = st;
-    v_value = texel.r;
+    v_value = decodeValue(texel);
     v_coverage = texel.a;
 
-    float metres = u_valueMin + texel.r * u_valueRange;
+    // Exaggeration stretches the span above the archive's minimum rather than the height itself. On an
+    // elevation the height is measured from the ellipsoid, tens of metres from any of the data, so
+    // scaling that instead translates the whole sheet underground rather than spreading it out.
+    float metres = u_valueMin + v_value * u_valueRange * u_exaggeration;
 
     // Value zero sits at the polygon's own altitude, plus the terrain underneath when the polygon
     // is following the ground rather than absolutely positioned.
     float ground = sampleGround(st) * u_groundWeight;
-    float displacement = u_baseHeight + ground + metres * u_exaggeration * texel.a - skirt * u_skirtDepth;
+    float displacement = u_baseHeight + ground + metres * texel.a - skirt * u_skirtDepth;
 
     // Added to the LOW half of the encoded position: a metre-scale offset added to the high half
     // would be lost to float32 rounding at an earth radius.
@@ -42253,6 +42326,7 @@ uniform sampler2D u_valueTexture;
 uniform sampler2D u_rampTexture;
 uniform float u_coverageCutoff;
 uniform vec2 u_texelSize;
+uniform float u_valuePacked;
 uniform float u_valueRange;
 uniform float u_exaggeration;
 uniform float u_metresPerTexel;
@@ -42261,6 +42335,16 @@ in vec2 v_st;
 in float v_value;
 in float v_coverage;
 
+/*
+ * Scaled per channel for the same reason the vertex shader's decode is: reassembling the pair reaches
+ * 65535, which mediump does not have to represent, and this is the shader that may not get highp.
+ */
+float valueAt(vec2 uv) {
+    vec4 texel = texture(u_valueTexture, uv);
+    float packed16 = texel.r * (255.0 * 256.0 / 65535.0) + texel.g * (255.0 / 65535.0);
+    return mix(texel.r, packed16, u_valuePacked);
+}
+
 void main() {
     if (v_coverage < u_coverageCutoff) {
         discard;
@@ -42275,10 +42359,10 @@ void main() {
 
     // Relief shading from the value gradient, so the displacement reads at a distance without
     // recomputing vertex normals every time the texture changes.
-    float left = texture(u_valueTexture, v_st - vec2(u_texelSize.x, 0.0)).r;
-    float right = texture(u_valueTexture, v_st + vec2(u_texelSize.x, 0.0)).r;
-    float down = texture(u_valueTexture, v_st - vec2(0.0, u_texelSize.y)).r;
-    float up = texture(u_valueTexture, v_st + vec2(0.0, u_texelSize.y)).r;
+    float left = valueAt(v_st - vec2(u_texelSize.x, 0.0));
+    float right = valueAt(v_st + vec2(u_texelSize.x, 0.0));
+    float down = valueAt(v_st - vec2(0.0, u_texelSize.y));
+    float up = valueAt(v_st + vec2(0.0, u_texelSize.y));
     float scale = u_valueRange * u_exaggeration;
     vec3 n = normalize(vec3((left - right) * scale, (down - up) * scale, 2.0 * u_metresPerTexel));
     float lambert = clamp(dot(n, normalize(vec3(-0.5, -0.6, 0.62))), 0.0, 1.0);
@@ -42488,8 +42572,9 @@ void main() {
             this.source = options.source || null;
             this.valueMin = (_a = options.valueMin) !== null && _a !== void 0 ? _a : 0;
             this.valueMax = (_b = options.valueMax) !== null && _b !== void 0 ? _b : 1;
-            this.exaggeration = (_c = options.exaggeration) !== null && _c !== void 0 ? _c : autoExaggeration(this.extent, this.valueMin, this.valueMax);
+            this.exaggeration = (_c = options.exaggeration) !== null && _c !== void 0 ? _c : 1;
             this.baseHeight = (_d = options.baseHeight) !== null && _d !== void 0 ? _d : 0;
+            this.packedValue = Boolean(options.packedValue);
             this.pixelPlacement = options.pixelPlacement;
             this.tileSkirts = Boolean(options.tileSkirts);
             this.rampPixels = RampLookup(options.rampStops || null, options.lowColor || DEFAULT_LOW_COLOR, options.highColor || DEFAULT_HIGH_COLOR);
@@ -42713,6 +42798,14 @@ void main() {
                 if (this.texture) {
                     this.texture.destroy();
                 }
+                // Nearest for a packed value, because filtering would blend the two bytes of the
+                // packing rather than the values they encode, the same trap sampleGround avoids.
+                const minification = this.packedValue
+                    ? TextureMinificationFilter.NEAREST
+                    : TextureMinificationFilter.LINEAR;
+                const magnification = this.packedValue
+                    ? TextureMagnificationFilter.NEAREST
+                    : TextureMagnificationFilter.LINEAR;
                 this.texture = new Texture({
                     context,
                     source: this.source,
@@ -42722,8 +42815,8 @@ void main() {
                     sampler: new Sampler({
                         wrapS: TextureWrap.CLAMP_TO_EDGE,
                         wrapT: TextureWrap.CLAMP_TO_EDGE,
-                        minificationFilter: TextureMinificationFilter.LINEAR,
-                        magnificationFilter: TextureMagnificationFilter.LINEAR
+                        minificationFilter: minification,
+                        magnificationFilter: magnification
                     })
                 });
                 this.textureDirty = false;
@@ -42824,6 +42917,7 @@ void main() {
                     uniformMap: {
                         u_valueTexture: () => self.texture,
                         u_groundTexture: () => self.groundTexture,
+                        u_valuePacked: () => (self.packedValue ? 1 : 0),
                         u_groundWeight: () => (self.followGround && self.groundPixels ? 1 : 0),
                         u_groundRange: () => new Cartesian2(GROUND_MIN_METRES, GROUND_MAX_METRES),
                         u_groundSize: () => new Cartesian2(self.groundPixels ? GROUND_SAMPLES_PER_SIDE : 1, self.groundPixels ? GROUND_SAMPLES_PER_SIDE : 1),
@@ -42876,31 +42970,6 @@ void main() {
         }
         return tiles;
     }
-    /**
-     * Exaggeration that makes the full value range stand AUTO_RELIEF_FRACTION of the extent tall.
-     *
-     * Derived from the whole extent rather than per tile: scaling each tile to its own size would
-     * make neighbours disagree along their shared edge and tear the surface apart.
-     * @param extent
-     * @param valueMin
-     * @param valueMax
-     */
-    function autoExaggeration(extent, valueMin, valueMax) {
-        const range = Math.abs(valueMax - valueMin);
-        if (!(range > 0)) {
-            return 1;
-        }
-        const southWest = Cartesian3.fromDegrees(extent.West, extent.South, 0);
-        const southEast = Cartesian3.fromDegrees(extent.East, extent.South, 0);
-        const northWest = Cartesian3.fromDegrees(extent.West, extent.North, 0);
-        const shorterSide = Math.min(Cartesian3.distance(southWest, southEast), Cartesian3.distance(southWest, northWest));
-        if (!(shorterSide > 0)) {
-            return 1;
-        }
-        const relief = Math.min(shorterSide * AUTO_RELIEF_FRACTION, AUTO_MAX_RELIEF_METRES);
-        return relief / range;
-    }
-    DisplacedSurfacePrimitive.autoExaggeration = autoExaggeration;
     function now() {
         return typeof performance !== "undefined" ? performance.now() : Date.now();
     }
@@ -43639,12 +43708,12 @@ function syncDisplacedSurface(params) {
         && existingAnimator.GetArchiveUrl() === extrusionArchive.url
         && existingSurface
         && !existingSurface.isDestroyed();
-    const placement = surfacePlacement(entity, heightRef);
+    const placement = surfacePlacement(entity, heightRef, extrusionArchive && TextureFrameSeriesAnimator.IsDatumHeight(extrusionArchive.metadata));
     // Whether the surface follows terrain is baked into its ground sampling, so a change there has
     // to rebuild rather than update in place.
     if (reusable && existingSurface.GetFollowsGround() === placement.followGround) {
         existingSurface.SetBaseHeight(placement.baseHeight);
-        existingSurface.SetExaggeration(exaggerationFor(style, extrusionArchive.metadata, existingSurface.GetExtent()));
+        existingSurface.SetExaggeration(exaggerationFor(style));
         return;
     }
     disposeDisplacedSurface(cEntity, viewer);
@@ -43668,8 +43737,6 @@ function syncDisplacedSurface(params) {
         produceValueCanvas: true,
         metadata: extrusionArchive.metadata,
         cellTexels: 1,
-        baselineMask: extrusionArchive.metadata.BaselineMask,
-        // Off-type for the same reason as the fill path: the pinned bruce-models predates the field.
         maskBaseline: style.maskTextureBaseline
     });
     cEntity[EXTRUSION_ANIMATOR_KEY] = animator;
@@ -43684,12 +43751,13 @@ function syncDisplacedSurface(params) {
         terrainProvider: viewer && viewer.terrainProvider,
         valueMin: extrusionArchive.metadata.ValueMin,
         valueMax: extrusionArchive.metadata.ValueMax,
-        exaggeration: exaggerationFor(style, extrusionArchive.metadata, extent),
+        packedValue: TextureFrameSeriesAnimator.IsPackedValue(extrusionArchive.metadata),
+        exaggeration: exaggerationFor(style),
         lowColor: mask ? Color$1.ColorFromStr(mask.minColor) : null,
         highColor: mask ? Color$1.ColorFromStr(mask.maxColor) : null,
         // Normalised the same way the animator normalises them, so the surface and the flat drape
         // agree about which values the style hides.
-        rampStops: (mask && mask.points || []).map((stop) => ({
+        rampStops: ((mask && mask.points) || []).map((stop) => ({
             position: TextureFrameSeriesAnimator.NormalisePosition(extrusionArchive.metadata, stop.position),
             color: Color$1.ColorFromStr(stop.color)
         })).filter((stop) => Boolean(stop.color))
@@ -43705,7 +43773,7 @@ function syncDisplacedSurface(params) {
  * @param entity
  * @param heightRef
  */
-function surfacePlacement(entity, heightRef) {
+function surfacePlacement(entity, heightRef, datumHeight) {
     const rawAltitude = Entity$1.GetValue({
         entity,
         path: ["Bruce", "Location", "altitude"]
@@ -43717,32 +43785,18 @@ function surfacePlacement(entity, heightRef) {
     if (heightRef === HeightReference.RELATIVE_TO_GROUND) {
         return { baseHeight: altitude, followGround: true };
     }
-    return { baseHeight: altitude, followGround: false };
+    // Values that ARE heights against a datum already say where they belong, so adding the entity's
+    // altitude on top would move a measured surface off the datum it was measured against.
+    return { baseHeight: datumHeight ? 0 : altitude, followGround: false };
 }
-/**
- * The archive's own extent when it recorded one, otherwise the polygon's own bounds so archives
- * generated before the extent was written still render somewhere sensible.
- * @param metadata
- * @param posses
- */
 /*
- * The factor a displaced surface should use, honouring an explicit style setting first.
- *
- * An elevation is a real height against a datum, so scaling it is not a display choice: it lifts the
- * surface off the datum it belongs to. Only a thickness is safe to exaggerate, which is why an
- * elevation archive defaults to 1 rather than to a derived factor.
+ * The factor a displaced surface should use, which is the style's or nothing.
  */
-function exaggerationFor(style, metadata, extent) {
+function exaggerationFor(style) {
     if (style.extrusionExaggeration != null) {
         return style.extrusionExaggeration;
     }
-    if (metadata.Quantity === TextureFrameSeriesAnimator.QUANTITY_ELEVATION) {
-        return 1;
-    }
-    if (!extent) {
-        return undefined;
-    }
-    return DisplacedSurfacePrimitive.autoExaggeration(extent, metadata.ValueMin, metadata.ValueMax);
+    return 1;
 }
 /*
  * The lon/lat bounding rectangle of a ring, which is the frame Cesium drapes an image material in.
@@ -43843,7 +43897,6 @@ function syncTextureFrameArchive(cEntity, frameArchive, viewer, textureColorMask
         metadata: frameArchive.metadata,
         cellBorder,
         cellTexels,
-        baselineMask: frameArchive.metadata.BaselineMask,
         maskBaseline: maskTextureBaseline,
         produceValueCanvas,
         drapeExtent
@@ -43904,20 +43957,19 @@ function syncTextureValueLabels(params) {
     }
     const labels = new TextureValueLabels.Labels({
         viewer, extent, settings, metadata,
-        tiles: TextureFrameSeriesAnimator.IsTiledLayout(metadata)
-            ? metadata.Tiles.map((tile) => ({
-                West: tile.West, East: tile.East, South: tile.South, North: tile.North,
-                ResolutionX: tile.ResolutionX, ResolutionY: tile.ResolutionY
-            }))
-            : undefined,
+        tiles: TextureFrameSeriesAnimator.TilesOf(metadata).map((tile) => ({
+            West: tile.West, East: tile.East, South: tile.South, North: tile.North,
+            ResolutionX: tile.ResolutionX, ResolutionY: tile.ResolutionY
+        })),
         clipRing: params.clipRing
     });
     let lastVersion = -1;
     let appliedFloor = null;
     let appliedCeiling = null;
-    // The extremes are what turn an anomaly frame back into a reading, so they are worth two extra
-    // Range GETs here even though nothing else in the render path wants them.
-    animator.EnsureExtremes();
+    // Two extra Range GETs, and worth it only because a label draws the cell's own range from them.
+    if (!TextureFrameSeriesAnimator.IsTransformed(metadata)) {
+        animator.EnsureExtremes();
+    }
     const remove = viewer.scene.preRender.addEventListener(() => {
         if (animator.IsDisposed()) {
             return;
@@ -44043,10 +44095,14 @@ async function resolveTextureValue(params) {
             url = clientFile.URL;
             const clientFileData = clientFile.Data;
             if (TextureFrameSeriesAnimator.IsFrameArchiveMetadata(clientFileData)) {
+                const adapted = TextureFrameSeriesAnimator.Adapt(clientFileData.generation);
+                if (!adapted) {
+                    return { dataUri: null, effective: textureTrace.effective };
+                }
                 return {
                     dataUri: null,
                     effective: textureTrace.effective,
-                    frameArchive: { url, metadata: clientFileData.generation }
+                    frameArchive: { url, metadata: adapted }
                 };
             }
         }
@@ -44075,7 +44131,11 @@ async function resolveTextureCondition(params) {
     const url = clientFile.URL;
     const clientFileData = clientFile.Data;
     if (TextureFrameSeriesAnimator.IsFrameArchiveMetadata(clientFileData)) {
-        return { dataUri: null, effective: null, frameArchive: { url, metadata: clientFileData.generation } };
+        const adapted = TextureFrameSeriesAnimator.Adapt(clientFileData.generation);
+        if (adapted) {
+            return { dataUri: null, effective: null, frameArchive: { url, metadata: adapted } };
+        }
+        return { dataUri: null, effective: null };
     }
     const cacheKey = "texture-" + url + "-none";
     let prom = _textureCache.Get(cacheKey);
@@ -45559,7 +45619,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.2.2";
+const VERSION = "7.2.4";
 /**
  * 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.
@@ -45576,5 +45636,5 @@ const getENVIRONMENT = () => {
     return ENVIRONMENT;
 };
 
-export { VERSION, setENVIRONMENT, getENVIRONMENT, CesiumAnimatedInOut, DisplacedSurfacePrimitive, CesiumAnimatedProperty, isStyleChanged, isOutlineChanged$1 as isOutlineChanged, StyleEffective, EntityRenderEngine, EntityRenderEngineModel3d, EntityRenderEnginePoint, EntityRenderEnginePolygon, EntityRenderEnginePolyline, TextureValueLabels, MenuItemCreator, MenuItemManager, CesiumParabola, EntityLabel, LiveCursor, SharedGetters, DataSourceStaticKmlManager, DataLabRenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, AssemblyRenderManager, GoogleSearchRenderManager, RelationsRenderManager, RenderManager, TilesetArbRenderManager, TilesetCadRenderManager, TilesetEntitiesRenderManager, TilesetGooglePhotosRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TileRenderEngine, createTileset, TilesetRenderEngine, ViewRenderEngine, VisualRegisterCuller, VisualsRegister, XGridsRenderEngine, CesiumEntityStyler, DrawingUtils, EntityUtils, MeasureUtils, StyleUtils, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_KEY, CESIUM_TIMELINE_INTERVAL_KEY, CESIUM_MODEL_SPACE_KEY, DEFAULT_LIVE_PADDING_SECONDS, DEFAULT_BRIGHTNESS_SHIFT, DEFAULT_LIGHT_INTENSITY, LIGHTING_SETTINGS_VERSION, LIGHT_INTENSITY_COMPENSATION, MAX_COMPENSATED_LIGHT_INTENSITY, ViewUtils, CesiumViewMonitor, ViewGroundArea, ViewerEventTracker, ViewerUtils, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, WidgetControlViewBar, WidgetControlViewBarSearch, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks, WidgetLeftPanelTabDashboard, EMenuItemState, WidgetLeftPanelTabMenuItems, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, WidgetLeftPanel, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar };
+export { VERSION, setENVIRONMENT, getENVIRONMENT, CesiumAnimatedInOut, DisplacedSurfacePrimitive, CesiumAnimatedProperty, isStyleChanged, isOutlineChanged$1 as isOutlineChanged, StyleEffective, EntityRenderEngine, EntityRenderEngineModel3d, EntityRenderEnginePoint, EntityRenderEnginePolygon, EntityRenderEnginePolyline, TextureFrameSeriesAnimator, TextureValueLabels, MenuItemCreator, MenuItemManager, CesiumParabola, EntityLabel, LiveCursor, SharedGetters, DataSourceStaticKmlManager, DataLabRenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, AssemblyRenderManager, GoogleSearchRenderManager, RelationsRenderManager, RenderManager, TilesetArbRenderManager, TilesetCadRenderManager, TilesetEntitiesRenderManager, TilesetGooglePhotosRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TileRenderEngine, createTileset, TilesetRenderEngine, ViewRenderEngine, VisualRegisterCuller, VisualsRegister, XGridsRenderEngine, CesiumEntityStyler, DrawingUtils, EntityUtils, MeasureUtils, StyleUtils, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_KEY, CESIUM_TIMELINE_INTERVAL_KEY, CESIUM_MODEL_SPACE_KEY, DEFAULT_LIVE_PADDING_SECONDS, DEFAULT_BRIGHTNESS_SHIFT, DEFAULT_LIGHT_INTENSITY, LIGHTING_SETTINGS_VERSION, LIGHT_INTENSITY_COMPENSATION, MAX_COMPENSATED_LIGHT_INTENSITY, ViewUtils, CesiumViewMonitor, ViewGroundArea, ViewerEventTracker, ViewerUtils, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, WidgetControlViewBar, WidgetControlViewBarSearch, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks, WidgetLeftPanelTabDashboard, EMenuItemState, WidgetLeftPanelTabMenuItems, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, WidgetLeftPanel, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar };
 //# sourceMappingURL=bruce-cesium.es5.js.map