bruce-cesium 7.1.4 → 7.1.6

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, Ellipsoid, Cartesian3, Transforms, Matrix4, Math as Math$1, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, Cartesian2, DistanceDisplayCondition, HeightReference, ColorBlendMode, HeadingPitchRoll, ShadowMode, ClassificationType, Model, ArcType, CornerType, ConstantPositionProperty, JulianDate, Quaternion, HorizontalOrigin, VerticalOrigin, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, SceneTransforms, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileset, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Cesium3DTileColorBlendMode, Intersect, OrthographicFrustum, EasingFunction, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, PolygonPipeline, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, CesiumInspector, ClockRange, CustomDataSource, ScreenSpaceEventHandler, ScreenSpaceEventType, GeometryInstance, Fullscreen, CzmlDataSource } from 'cesium';
-import { Cartes, Entity as Entity$1, ENVIRONMENT, Calculator, ClientFile, EntityLod, EntityTag, EntityType, LRUCache, ObjectUtils, Style, Carto, Geometry as Geometry$1, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, Api, Bounds, Color as Color$1, BruceEvent, EntityCoords, DataLab, DelayQueue, BruceApi, EntityHistoricData, EntityRelation, AccountConcept, RecordChangeFeed, ProgramKey, EntitySource, ProjectViewLegacyTile, ProjectViewTile, Camera, Account, AccountLimits, Session, UrlUtils, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType } from 'bruce-models';
+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, ClassificationType, ArcType, HeightReference, CornerType, ShadowMode, ConstantPositionProperty, HorizontalOrigin, VerticalOrigin, ColorBlendMode, Model, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, SceneTransforms, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileColorBlendMode, Cesium3DTileset, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Intersect, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, OrthographicFrustum, EasingFunction, PolygonPipeline, GeometryInstance, CustomDataSource, CesiumInspector, ClockRange, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
+import { Cartes, Entity as Entity$1, ENVIRONMENT, Calculator, Carto, EntityTag, EntityType, Geometry as Geometry$1, ObjectUtils, Style, Api, ClientFile, LRUCache, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, EntityLod, Bounds, Color as Color$1, BruceEvent, EntityCoords, DataLab, DelayQueue, BruceApi, EntityHistoricData, AccountConcept, RecordChangeFeed, EntityRelation, ProgramKey, EntitySource, ProjectViewLegacyTile, ProjectViewTile, Camera, Account, AccountLimits, Session, UrlUtils, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -3587,6 +3587,7 @@ var SimplifyGeometry;
         if (!geometry || !isTurfAvailable() || !turf.simplify) {
             return geometry;
         }
+        const original = geometry;
         // Convert to geojson so that we can interact with turf.
         const gFeature = Geometry$1.ToGeoJsonFeature({
             geometry: geometry
@@ -3607,13 +3608,97 @@ var SimplifyGeometry;
             });
         }
         // Converting back to Bruce geometry.
-        geometry = (_a = Geometry$1.FromGeoJson({
+        const simplified = (_a = Geometry$1.FromGeoJson({
             geoJson: gFeature
         })) === null || _a === void 0 ? void 0 : _a.geometry;
-        return geometry;
+        // A polygon we cannot vouch for is worse than an unsimplified one, so fall back instead of shipping it.
+        if (!simplified || !isSafeToRender(simplified)) {
+            return original;
+        }
+        return simplified;
     }
     SimplifyGeometry.Simplify = Simplify;
+    /**
+     * Whether a simplified geometry still describes something a renderer can triangulate.
+     * @param geometry the simplification result.
+     * @returns false when any polygon has a collapsed ring, a hole outside its outer ring, or a hole
+     * wound the same way as its outer ring.
+     */
+    function IsSafeToRender(geometry) {
+        return isSafeToRender(geometry);
+    }
+    SimplifyGeometry.IsSafeToRender = IsSafeToRender;
 })(SimplifyGeometry || (SimplifyGeometry = {}));
+// A ring needs three distinct corners plus the closing repeat before it encloses any area.
+const MIN_RING_POSITIONS = 4;
+function isSafeToRender(geometry) {
+    let safe = true;
+    const check = (g) => {
+        if (!safe) {
+            return;
+        }
+        if (g === null || g === void 0 ? void 0 : g.MultiGeometry) {
+            g.MultiGeometry.forEach(check);
+            return;
+        }
+        if (!(g === null || g === void 0 ? void 0 : g.Polygon) || g.Polygon.length === 0) {
+            return;
+        }
+        let outer = null;
+        let outerIsClockwise = false;
+        for (let i = 0; i < g.Polygon.length; i++) {
+            const points = Geometry$1.ParsePoints(g.Polygon[i].LinearRing);
+            if (!points || points.length < MIN_RING_POSITIONS) {
+                safe = false;
+                return;
+            }
+            const clockwise = signedRingArea(points) < 0;
+            if (g.Polygon[i].Facing !== "in") {
+                outer = points;
+                outerIsClockwise = clockwise;
+                continue;
+            }
+            // A hole with no outer ring ahead of it cannot be subtracted from anything.
+            if (!outer) {
+                safe = false;
+                return;
+            }
+            if (clockwise === outerIsClockwise) {
+                safe = false;
+                return;
+            }
+            for (let j = 0; j < points.length; j++) {
+                if (!isPointInRing(points[j], outer)) {
+                    safe = false;
+                    return;
+                }
+            }
+        }
+    };
+    check(geometry);
+    return safe;
+}
+function signedRingArea(points) {
+    let sum = 0;
+    for (let i = 0; i < points.length; i++) {
+        const a = points[i];
+        const b = points[(i + 1) % points.length];
+        sum += a.longitude * b.latitude - b.longitude * a.latitude;
+    }
+    return sum / 2;
+}
+function isPointInRing(point, ring) {
+    let inside = false;
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+        const a = ring[i];
+        const b = ring[j];
+        if ((a.latitude > point.latitude) !== (b.latitude > point.latitude)
+            && point.longitude < (b.longitude - a.longitude) * (point.latitude - a.latitude) / (b.latitude - a.latitude) + a.longitude) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
 /**
  * Runs through all found polygons and runs unkink through turf on them.
  * @param feature
@@ -3655,9 +3740,26 @@ function untangleFeature(feature) {
             }
             // Recreate the rings and reapply to the collection.
             if (outer.length > 0) {
-                const combinedCoords = [outer[0]];
+                // Unkinking a self touching boundary splits it into pieces. Keeping whichever piece
+                // happened to come back first can discard most of the shape, so keep the biggest one.
+                let keep = outer[0];
+                if (outer.length > 1) {
+                    let best = Math.abs(ringArea(keep));
+                    for (let i = 1; i < outer.length; i++) {
+                        const area = Math.abs(ringArea(outer[i]));
+                        if (area > best) {
+                            best = area;
+                            keep = outer[i];
+                        }
+                    }
+                }
+                const combinedCoords = [keep];
                 for (let i = 0; i < inner.length; i++) {
-                    combinedCoords.push(inner[i]);
+                    // A hole belonging to a piece that was just discarded is no longer inside anything,
+                    // and a hole crossing the boundary is what tears the fill.
+                    if (isRingInsideRing(inner[i], keep)) {
+                        combinedCoords.push(inner[i]);
+                    }
                 }
                 // Add the combined coordinates to the collection
                 const polygon = {
@@ -3805,6 +3907,30 @@ function unionFeature(feature) {
         feature.geometry = collection;
     }
 }
+function ringArea(ring) {
+    let sum = 0;
+    for (let i = 0; i < ring.length; i++) {
+        const a = ring[i];
+        const b = ring[(i + 1) % ring.length];
+        sum += a[0] * b[1] - b[0] * a[1];
+    }
+    return sum / 2;
+}
+function isRingInsideRing(inner, outer) {
+    for (let i = 0; i < inner.length; i++) {
+        let inside = false;
+        for (let a = 0, b = outer.length - 1; a < outer.length; b = a++) {
+            if ((outer[a][1] > inner[i][1]) !== (outer[b][1] > inner[i][1])
+                && inner[i][0] < (outer[b][0] - outer[a][0]) * (inner[i][1] - outer[a][1]) / (outer[b][1] - outer[a][1]) + outer[a][0]) {
+                inside = !inside;
+            }
+        }
+        if (!inside) {
+            return false;
+        }
+    }
+    return true;
+}
 function dedupeCoordinates(inputCoords) {
     return inputCoords.map(ring => {
         if (ring.length < 2) {
@@ -39734,15 +39860,68 @@ var TextureFrameSeriesAnimator;
         return Boolean(data && data.generation && Array.isArray(data.generation.Frames) && data.generation.Frames.length > 0);
     }
     TextureFrameSeriesAnimator.IsFrameArchiveMetadata = IsFrameArchiveMetadata;
+    // How far covered values bleed outward into uncovered texels before the GPU samples them.
+    const VALUE_DILATE_PASSES = 2;
+    /*
+     * Bleeds covered values outward into uncovered texels, leaving alpha untouched.
+     *
+     * The GPU samples the value texture with linear filtering, so an uncovered texel's RGB still gets
+     * averaged into the vertices next to it even though its alpha is zero. Land sits at one end of the
+     * ramp, so without this the coastline grows a row of spikes exactly where the data stops. Masking the
+     * baseline creates more of these edges, which is what makes this necessary rather than cosmetic.
+     */
+    function dilateValues(value, width, height, passes) {
+        const texels = width * height;
+        const filled = new Uint8Array(texels);
+        for (let p = 0; p < texels; p++) {
+            filled[p] = value[p * 4 + 3] !== 0 ? 1 : 0;
+        }
+        for (let pass = 0; pass < passes; pass++) {
+            const source = value.slice();
+            const wasFilled = filled.slice();
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const p = y * width + x;
+                    if (wasFilled[p]) {
+                        continue;
+                    }
+                    let sum = 0;
+                    let hits = 0;
+                    for (let dy = -1; dy <= 1; dy++) {
+                        for (let dx = -1; dx <= 1; dx++) {
+                            const nx = x + dx;
+                            const ny = y + dy;
+                            if (nx < 0 || ny < 0 || nx >= width || ny >= height || !wasFilled[ny * width + nx]) {
+                                continue;
+                            }
+                            sum += source[(ny * width + nx) * 4];
+                            hits++;
+                        }
+                    }
+                    if (hits > 0) {
+                        const v = Math.round(sum / hits);
+                        value[p * 4] = v;
+                        value[p * 4 + 1] = v;
+                        value[p * 4 + 2] = v;
+                        filled[p] = 1;
+                    }
+                }
+            }
+        }
+    }
     const DEFAULT_CROSSFADE_MS = 900;
     const DEFAULT_LOW_COLOR = { red: 255, green: 255, blue: 255, alpha: 0.12 };
     const DEFAULT_HIGH_COLOR = { red: 21, green: 96, blue: 196, alpha: 0.92 };
     class Animator {
         constructor(options) {
-            var _a;
+            var _a, _b;
             this.removeOnTick = null;
             this.removeCrossfadeTick = null;
             this.disposed = false;
+            // One alpha byte per texel, 1 meaning the texel is baseline. Fetched once, the mesh does not move.
+            this.baselineFlags = null;
+            this.baselineDims = null;
+            this.baselineLoad = null;
             this.currentFrameIndex = -1;
             // Single-in-flight fetch queue: only one Range GET outstanding at a time, and the NEXT one
             // is chosen right before sending, this is what makes reprioritizing mid-scrub take effect
@@ -39782,6 +39961,8 @@ var TextureFrameSeriesAnimator;
             this.frameDims = new Array(this.frames.length).fill(null);
             this.valueCache = new Array(this.frames.length).fill(null);
             this.produceValueCanvas = Boolean(options.produceValueCanvas);
+            this.baselineMaskEntry = options.baselineMask || null;
+            this.maskBaseline = (_b = options.maskBaseline) !== null && _b !== void 0 ? _b : Boolean(options.baselineMask);
             this.valueCanvas = this.produceValueCanvas ? document.createElement("canvas") : null;
             this.driveMaterial = options.driveMaterial !== false;
             this.originalMaterial = options.entity.polygon.material;
@@ -39951,6 +40132,12 @@ var TextureFrameSeriesAnimator;
             if (this.disposed) {
                 return;
             }
+            // Awaited before decoding rather than applied later, so no frame is ever cached unmasked and
+            // then corrected once the mask lands.
+            await this.ensureBaselineMask();
+            if (this.disposed) {
+                return;
+            }
             const decoded = await this.decodeAndTint(buffer);
             if (this.disposed) {
                 return;
@@ -39985,8 +40172,81 @@ var TextureFrameSeriesAnimator;
             // recovered from the tinted pixels afterwards.
             const valuePixels = this.produceValueCanvas ? new Uint8ClampedArray(imageData.data) : undefined;
             ApplyGrayscaleColorMask(imageData, this.lowColor, this.highColor);
+            this.applyBaselineMask(imageData.data, valuePixels, canvas.width, canvas.height);
+            if (valuePixels) {
+                dilateValues(valuePixels, canvas.width, canvas.height, VALUE_DILATE_PASSES);
+            }
             return { pixels: imageData.data, width: canvas.width, height: canvas.height, valuePixels };
         }
+        /**
+         * Fetches and decodes the archive's static baseline mask, at most once.
+         */
+        ensureBaselineMask() {
+            if (!this.maskBaseline || !this.baselineMaskEntry) {
+                return Promise.resolve();
+            }
+            if (this.baselineLoad) {
+                return this.baselineLoad;
+            }
+            const entry = this.baselineMaskEntry;
+            const start = entry.ByteOffset;
+            const end = entry.ByteOffset + entry.ByteLength - 1;
+            this.baselineLoad = fetch(this.archiveUrl, { headers: { Range: `bytes=${start}-${end}` } })
+                .then((response) => response.arrayBuffer())
+                .then(async (buffer) => {
+                if (this.disposed) {
+                    return;
+                }
+                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);
+                const pixels = ctx.getImageData(0, 0, canvas.width, canvas.height).data;
+                const flags = new Uint8Array(canvas.width * canvas.height);
+                for (let p = 0; p < flags.length; p++) {
+                    flags[p] = pixels[p * 4 + 3] >= 128 ? 1 : 0;
+                }
+                this.baselineFlags = flags;
+                this.baselineDims = { width: canvas.width, height: canvas.height };
+            })
+                .catch((e) => {
+                // A missing or unreadable mask must not stop the animation; it just means nothing is hidden.
+                console.warn("TextureFrameSeriesAnimator: could not load the baseline mask, drawing it instead.", e);
+            });
+            return this.baselineLoad;
+        }
+        /**
+         * Clears alpha on baseline texels, which is what makes hiding the dry/land sentinel a render choice.
+         */
+        applyBaselineMask(pixels, valuePixels, width, height) {
+            const flags = this.baselineFlags;
+            if (!flags || !this.baselineDims) {
+                return;
+            }
+            // A mask from a different raster size cannot be indexed against this frame, and guessing a
+            // resampling would silently hide the wrong ground.
+            if (this.baselineDims.width !== width || this.baselineDims.height !== height) {
+                return;
+            }
+            for (let p = 0; p < flags.length; p++) {
+                if (flags[p]) {
+                    pixels[p * 4 + 3] = 0;
+                    if (valuePixels) {
+                        valuePixels[p * 4 + 3] = 0;
+                    }
+                }
+            }
+        }
         beginCrossfadeTo(idx) {
             const to = this.frameCache[idx];
             this.fadeFromValuePixels = this.displayedValuePixels === null && this.valueCache[idx]
@@ -40233,11 +40493,13 @@ void main() {
         return _glsl300Support;
     }
     /*
-     * Places grid node (fx, fy) on the ellipsoid, walking equal steps of east/north metres.
-     * Cesium maps a polygon's material across a tangent-plane rectangle and the generated raster is
-     * linear in a projected CRS, so stepping in degrees instead would skew the surface against the flat-textured polygon it replaces.
+     * Places grid node (fx, fy) on the ellipsoid, stepping the way the raster was sampled.
+     * A raster sampled at lon/lat has to be walked in degrees; one sampled linearly across a projected CRS has to be walked in tangent-plane metres.
      */
-    function makePlacer(extent) {
+    function makePlacer(extent, pixelPlacement) {
+        if (pixelPlacement === "lonlat") {
+            return (fx, fy) => Cartesian3.fromDegrees(Math$1.lerp(extent.West, extent.East, fx), Math$1.lerp(extent.North, extent.South, fy), 0);
+        }
         const ellipsoid = Ellipsoid.WGS84;
         const centre = Cartesian3.fromDegrees((extent.West + extent.East) / 2, (extent.South + extent.North) / 2, 0);
         const frame = Transforms.eastNorthUpToFixedFrame(centre);
@@ -40251,21 +40513,21 @@ void main() {
         };
     }
     /*
-     * Builds one tile's grid, plus a duplicated perimeter ring the shader pushes downwards to cover
-     * the crack where a neighbouring tile at a different density interpolates the shared edge.
+     * Builds one tile's grid, optionally plus a duplicated perimeter ring the shader pushes downwards to
+     * cover the crack where a neighbouring tile at a different density interpolates the shared edge.
      */
-    function buildGeometry(extent, resolution, patch) {
+    function buildGeometry(extent, resolution, patch, pixelPlacement, withSkirt = false) {
         const cols = resolution;
         const rows = resolution;
         const gridCount = (cols + 1) * (rows + 1);
-        const perimeterCount = 2 * (cols + 1) + 2 * (rows + 1) - 4;
+        const perimeterCount = withSkirt ? 2 * (cols + 1) + 2 * (rows + 1) - 4 : 0;
         const count = gridCount + perimeterCount;
         const positions = new Float64Array(count * 3);
         const normals = new Float32Array(count * 3);
         const sts = new Float32Array(count * 2);
         const skirts = new Float32Array(count);
         const ellipsoid = Ellipsoid.WGS84;
-        const place = makePlacer(extent);
+        const place = makePlacer(extent, pixelPlacement);
         let v = 0;
         for (let row = 0; row <= rows; row++) {
             // Texture row 0 is the north edge, so t runs opposite to northing.
@@ -40316,26 +40578,28 @@ void main() {
             loop.push(row * (cols + 1));
         }
         const skirtStart = gridCount;
-        loop.forEach((gridIndex, k) => {
-            const target = skirtStart + k;
-            positions[target * 3] = positions[gridIndex * 3];
-            positions[target * 3 + 1] = positions[gridIndex * 3 + 1];
-            positions[target * 3 + 2] = positions[gridIndex * 3 + 2];
-            normals[target * 3] = normals[gridIndex * 3];
-            normals[target * 3 + 1] = normals[gridIndex * 3 + 1];
-            normals[target * 3 + 2] = normals[gridIndex * 3 + 2];
-            sts[target * 2] = sts[gridIndex * 2];
-            sts[target * 2 + 1] = sts[gridIndex * 2 + 1];
-            skirts[target] = 1;
-        });
-        for (let k = 0; k < loop.length; k++) {
-            const nextK = (k + 1) % loop.length;
-            indices[i++] = loop[k];
-            indices[i++] = skirtStart + k;
-            indices[i++] = loop[nextK];
-            indices[i++] = loop[nextK];
-            indices[i++] = skirtStart + k;
-            indices[i++] = skirtStart + nextK;
+        if (withSkirt) {
+            loop.forEach((gridIndex, k) => {
+                const target = skirtStart + k;
+                positions[target * 3] = positions[gridIndex * 3];
+                positions[target * 3 + 1] = positions[gridIndex * 3 + 1];
+                positions[target * 3 + 2] = positions[gridIndex * 3 + 2];
+                normals[target * 3] = normals[gridIndex * 3];
+                normals[target * 3 + 1] = normals[gridIndex * 3 + 1];
+                normals[target * 3 + 2] = normals[gridIndex * 3 + 2];
+                sts[target * 2] = sts[gridIndex * 2];
+                sts[target * 2 + 1] = sts[gridIndex * 2 + 1];
+                skirts[target] = 1;
+            });
+            for (let k = 0; k < loop.length; k++) {
+                const nextK = (k + 1) % loop.length;
+                indices[i++] = loop[k];
+                indices[i++] = skirtStart + k;
+                indices[i++] = loop[nextK];
+                indices[i++] = loop[nextK];
+                indices[i++] = skirtStart + k;
+                indices[i++] = skirtStart + nextK;
+            }
         }
         const geometry = new Geometry({
             attributes: {
@@ -40393,6 +40657,8 @@ void main() {
             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.baseHeight = (_d = options.baseHeight) !== null && _d !== void 0 ? _d : 0;
+            this.pixelPlacement = options.pixelPlacement;
+            this.tileSkirts = Boolean(options.tileSkirts);
             this.lowColor = toCesiumColor(options.lowColor || DEFAULT_LOW_COLOR);
             this.highColor = toCesiumColor(options.highColor || DEFAULT_HIGH_COLOR);
             this.tiles = buildTiles(hasCoverage);
@@ -40400,6 +40666,9 @@ void main() {
         GetFollowsGround() {
             return this.followGround;
         }
+        GetPixelPlacement() {
+            return this.pixelPlacement;
+        }
         GetBaseHeight() {
             return this.baseHeight;
         }
@@ -40614,7 +40883,7 @@ void main() {
             if (cached) {
                 return cached;
             }
-            const geometry = buildGeometry(this.extent, tier, tile.patch);
+            const geometry = buildGeometry(this.extent, tier, tile.patch, this.pixelPlacement, this.tileSkirts);
             const attributeLocations = GeometryPipeline.createAttributeLocations(geometry);
             const mesh = {
                 attributeLocations,
@@ -40707,7 +40976,9 @@ void main() {
                         u_valueRange: () => self.valueMax - self.valueMin,
                         u_exaggeration: () => self.exaggeration,
                         u_baseHeight: () => self.baseHeight,
-                        u_skirtDepth: () => Math.max(2, Math.abs(self.valueMax - self.valueMin) * self.exaggeration * SKIRT_FRACTION),
+                        u_skirtDepth: () => self.tileSkirts
+                            ? Math.max(2, Math.abs(self.valueMax - self.valueMin) * self.exaggeration * SKIRT_FRACTION)
+                            : 0,
                         u_coverageCutoff: () => COVERAGE_CUTOFF,
                         u_lowColor: () => self.lowColor,
                         u_highColor: () => self.highColor,
@@ -40840,6 +41111,8 @@ var EntityRenderEnginePolygon;
             }
         }
         const drawsDisplacedSurface = Boolean(extrusionArchive);
+        // The displaced surface IS the entity's fill, drawn as its own primitive at the value's height.
+        // Leaving the flat polygon filled as well shows a second copy of the parcel on the ground under it.
         const hasFill = (drawsDisplacedSurface ? true
             : fillType === Style.EPolygonFillType.Texture
                 ? Boolean(textureDataUri || frameArchive || cFillColor.alpha > 0)
@@ -40928,6 +41201,7 @@ var EntityRenderEnginePolygon;
                 polygon: {
                     hierarchy: new PolygonHierarchy(posses, holePosses.map(x => new PolygonHierarchy(x))),
                     material: fillMaterial,
+                    fill: !drawsDisplacedSurface,
                     extrudedHeight: extrusion.value,
                     extrudedHeightReference: extrusion.exHeightRef,
                     shadows: ShadowMode.ENABLED,
@@ -40958,6 +41232,12 @@ var EntityRenderEnginePolygon;
             if (!CompareCPolygonHierarchies(oldHierarchy, newHierarchy)) {
                 cEntity.polygon.hierarchy = new ConstantProperty(newHierarchy);
             }
+            // Toggling extrusion styling on an already-rendered entity flips this,
+            // so it has to be reconciled rather than set only at creation.
+            const oldFill = GetCValue(params.viewer, cEntity.polygon.fill);
+            if (oldFill !== !drawsDisplacedSurface) {
+                cEntity.polygon.fill = new ConstantProperty(!drawsDisplacedSurface);
+            }
             const oldExtrusion = GetCValue(params.viewer, cEntity.polygon.extrudedHeight);
             if (oldExtrusion != extrusion.value) {
                 cEntity.polygon.extrudedHeight = new ConstantProperty(extrusion.value);
@@ -41011,7 +41291,7 @@ var EntityRenderEnginePolygon;
         }
         // Must run before any material is baked below: the Animator takes over polygon.material, so a bake
         // has to know whether it is baking over a live animation or over a disposed one's restored material.
-        const animator = syncTextureFrameArchive(cEntity, drawsDisplacedSurface ? null : frameArchive, params.viewer, style.textureColorMask);
+        const animator = syncTextureFrameArchive(cEntity, drawsDisplacedSurface ? null : frameArchive, params.viewer, style.textureColorMask, style.maskTextureBaseline);
         syncDisplacedSurface({
             cEntity,
             extrusionArchive,
@@ -41496,12 +41776,17 @@ function syncDisplacedSurface(params) {
         frames: extrusionArchive.metadata.Frames,
         textureColorMask: style.textureColorMask,
         driveMaterial: false,
-        produceValueCanvas: true
+        produceValueCanvas: true,
+        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;
     const mask = style.textureColorMask;
     const surface = new DisplacedSurfacePrimitive.Surface({
         extent,
+        // The grid has to be walked the way the raster was sampled, or the surface skews across the extent.
+        pixelPlacement: extrusionArchive.metadata.PixelPlacement,
         source: null,
         baseHeight: placement.baseHeight,
         followGround: placement.followGround,
@@ -41593,7 +41878,7 @@ function disposeDisplacedSurface(cEntity, viewer) {
  * @param viewer
  * @param textureColorMask
  */
-function syncTextureFrameArchive(cEntity, frameArchive, viewer, textureColorMask) {
+function syncTextureFrameArchive(cEntity, frameArchive, viewer, textureColorMask, maskTextureBaseline) {
     const existing = cEntity[TEXTURE_FRAME_SERIES_ANIMATOR_KEY];
     if (frameArchive && existing && !existing.IsDisposed() && existing.GetArchiveUrl() === frameArchive.url) {
         return existing;
@@ -41610,7 +41895,9 @@ function syncTextureFrameArchive(cEntity, frameArchive, viewer, textureColorMask
         entity: cEntity,
         archiveUrl: frameArchive.url,
         frames: frameArchive.metadata.Frames,
-        textureColorMask
+        textureColorMask,
+        baselineMask: frameArchive.metadata.BaselineMask,
+        maskBaseline: maskTextureBaseline
     });
     cEntity[TEXTURE_FRAME_SERIES_ANIMATOR_KEY] = animator;
     return animator;
@@ -43222,7 +43509,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.1.4";
+const VERSION = "7.1.6";
 /**
  * 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.