bruce-cesium 7.3.6 → 7.3.8

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, HeightReference, DistanceDisplayCondition, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, Matrix4, ColorBlendMode, ShadowMode, ClassificationType, Model, ArcType, CornerType, ConstantPositionProperty, ShaderSource, Ellipsoid, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, Cartesian2, Cartesian4, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, HorizontalOrigin, VerticalOrigin, SceneTransforms, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileColorBlendMode, OrthographicFrustum, EasingFunction, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Cesium3DTileset, Intersect, CustomDataSource, PolygonPipeline, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, GeometryInstance, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
-import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Calculator, ClientFile, Entity as Entity$1, EntityLod, EntityTag, EntityType, ObjectUtils, Style, Carto, Geometry as Geometry$1, Bounds, ClientFileValueMap, Color as Color$1, Api, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, BruceApi, EntityRelation, RecordChangeFeed, EntitySource, Camera, ProgramKey, ProjectViewLegacyTile, Account, AccountLimits, Session, UrlUtils, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType, EntityHistoricData } from 'bruce-models';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, HeightReference, DistanceDisplayCondition, ShaderSource, Cartesian3, Math as Math$1, Ellipsoid, Transforms, Matrix4, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, JulianDate, Quaternion, HeadingPitchRoll, ClassificationType, ArcType, 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, OrthographicFrustum, EasingFunction, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, PolygonPipeline, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, CustomDataSource, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, ScreenSpaceEventHandler, ScreenSpaceEventType, GeometryInstance, Fullscreen, CzmlDataSource } from 'cesium';
+import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Calculator, Carto, Entity as Entity$1, EntityTag, EntityType, Geometry as Geometry$1, ObjectUtils, Style, Api, ClientFile, EntityLod, Bounds, ClientFileValueMap, Color as Color$1, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, RecordChangeFeed, EntityRelation, BruceApi, EntitySource, ProgramKey, ProjectViewLegacyTile, Camera, Account, AccountLimits, Session, UrlUtils, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType, EntityHistoricData } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -400,7 +400,7 @@ var DrawingUtils;
     function EnsurePosHeight(params) {
         let { pos3d, viewer, desiredHeightRef, heightRef } = params;
         const carto = Cartes.ValidateCartes3(pos3d) ? Cartographic.fromCartesian(pos3d) : null;
-        if (!(carto === null || carto === void 0 ? void 0 : carto.latitude)) {
+        if (!carto) {
             return pos3d;
         }
         if (heightRef == null) {
@@ -3346,6 +3346,12 @@ var CesiumEntityStyler;
         }
     }
     CesiumEntityStyler.Refresh = Refresh;
+    // Read the unselected colour even while a selection animation is running.
+    function GetDefaultColor(viewer, graphic) {
+        var _a;
+        return (_a = getColor$1(viewer, "default", graphic)) === null || _a === void 0 ? void 0 : _a.clone();
+    }
+    CesiumEntityStyler.GetDefaultColor = GetDefaultColor;
     function BakeDefaultColor(params) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         let { viewer, entity, override, colors, refresh } = params;
@@ -9508,6 +9514,14 @@ var VisualsRegister;
                 }
             };
         }
+        /**
+         * Whether this register is holding a record of a visual.
+         * @param visual
+         */
+        HasRego(visual) {
+            const vis = visual;
+            return Boolean(vis && vis._register === this && vis._rego);
+        }
         /**
          * Locates a visual corresponding to a given entity id.
          * If no menu item id is provided, then it will pick the "best" one.
@@ -12679,6 +12693,11 @@ var EntitiesRenderManager;
                 optimizeTolerance: this.item.optimizeTolerance,
             });
             if (this.disposed) {
+                EntityRenderEngine.RemoveAll({
+                    viewer: this.viewer,
+                    entities: cEntities,
+                    register: this.visualsManager
+                });
                 this.doDispose();
                 return;
             }
@@ -13686,6 +13705,11 @@ var EntitiesLoadedRenderManager;
                 force
             });
             if (this.disposed) {
+                EntityRenderEngine.RemoveAll({
+                    viewer: this.viewer,
+                    entities: cEntities,
+                    register: this.visualsManager
+                });
                 this.visualsManager.RemoveRegos({
                     menuItemId: this.item.id
                 });
@@ -14130,10 +14154,15 @@ var EntitiesIdsRenderManager;
                 zoomControl: this.item.CameraZoomSettings,
                 force: force || changed
             });
+            if (this.disposed) {
+                EntityRenderEngine.RemoveAll({
+                    viewer: this.viewer,
+                    entities: cEntities,
+                    register: this.visualsManager
+                });
+                return;
+            }
             for (let i = 0; i < entities.length; i++) {
-                if (this.disposed) {
-                    break;
-                }
                 const entity = entities[i];
                 const id = entity.Bruce.ID;
                 const cEntity = cEntities.get(id);
@@ -19514,6 +19543,11 @@ var DataLabRenderManager;
                     force
                 });
                 if (this.disposed) {
+                    EntityRenderEngine.RemoveAll({
+                        viewer: this.viewer,
+                        entities: cEntities,
+                        register: this.visualsManager
+                    });
                     return;
                 }
                 for (let i = 0; i < entities.length; i++) {
@@ -43589,6 +43623,44 @@ var DisplacedSurfacePrimitive;
     const MASK_TEXTURE_MAX_SIDE = 1024;
     // Stands in for "no floor" and "no clearance", far below anything the sheet can reach.
     const NO_LIMIT_METRES = -1e6;
+    // Ripple layers to cycle across the field's own repeat.
+    const WATER_WAVES = [
+        { x: 2, y: 1, amplitude: 6.4 },
+        { x: 1, y: 4, amplitude: 3.9 },
+        { x: -6, y: 4, amplitude: 2.5 },
+        { x: 9, y: -9, amplitude: 1.6 },
+        { x: -14, y: 18, amplitude: 1.0 },
+        { x: 38, y: 15, amplitude: 0.63 },
+        { x: -30, y: 68, amplitude: 0.39 },
+        { x: 120, y: 57, amplitude: 0.245 }
+    ];
+    const waveCycles = (wave) => Math.hypot(wave.x, wave.y);
+    // Which layer the wavelength setting names. The ladder runs either side of it.
+    const WATER_BASE_WAVE = 4;
+    // How many metres the field repeats over, as a multiple of the settings' own wavelength.
+    const WATER_PERIOD_IN_WAVELENGTHS = waveCycles(WATER_WAVES[WATER_BASE_WAVE]);
+    /*
+     * How much of the surface's total slope each layer carries, which is its amplitude against its
+     * wave number rather than its amplitude alone.
+     */
+    const WATER_WAVE_SLOPES = (() => {
+        const raw = WATER_WAVES.map((wave) => wave.amplitude * waveCycles(wave));
+        const total = raw.reduce((sum, value) => sum + value, 0);
+        return raw.map((value) => value / total);
+    })();
+    // Screen pixels a ripple layer needs to span before it counts at all, and before it counts in
+    // full. Below the first it is finer than the pixel grid and turns into moire that crawls as the
+    // camera moves; the gap between the two is there so a layer leaves gradually rather than
+    // stepping out and leaving a visible change in the surface.
+    const WATER_MIN_PIXELS_PER_WAVE = 6;
+    const WATER_FULL_PIXELS_PER_WAVE = 16;
+    const DEFAULT_WATER_WAVELENGTH_METRES = 26;
+    const DEFAULT_WATER_AMPLITUDE_METRES = 0.11;
+    const DEFAULT_WATER_SPEED_METRES_PER_SECOND = 0.6;
+    const DEFAULT_WATER_REFLECTIVITY = 0.72;
+    const DEFAULT_WATER_GLOSSINESS = 140;
+    const DEFAULT_WATER_SUN_INTENSITY = 1;
+    const DEFAULT_WATER_SKY_COLOR = { red: 150, green: 186, blue: 214, alpha: 1 };
     const GROUND_MIN_METRES = -1000;
     const GROUND_MAX_METRES = 9000;
     const DEFAULT_LOW_COLOR = { red: 255, green: 255, blue: 255, alpha: 0.12 };
@@ -43624,10 +43696,21 @@ uniform vec2 u_maskGroundSize;
 uniform vec4 u_extentDegrees;
 uniform vec4 u_maskGroundDegrees;
 uniform float u_coverageCutoffVertex;
+//#water
+uniform vec2 u_extentMetres;
+uniform vec2 u_waveOrigin;
+//#endwater
 
 out vec2 v_st;
 out float v_value;
 out float v_coverage;
+//#water
+out vec3 v_positionEC;
+out vec3 v_eastEC;
+out vec3 v_northEC;
+out vec3 v_upEC;
+out vec2 v_waveMetres;
+//#endwater
 
 float decodeGround(vec2 uv) {
     // Channels arrive normalised to 0..1, so they go back to bytes before being reassembled.
@@ -43746,6 +43829,19 @@ void main() {
     // 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.
     vec4 p = czm_translateRelativeToEye(position3DHigh, position3DLow + normal * displacement);
+
+//#water
+    // The local frame at this vertex so a shading normal built in east/north/up meters can be turned into something usable.
+    v_upEC = czm_normal * normal;
+    vec3 east = normalize(cross(vec3(0.0, 0.0, 1.0), normal));
+    v_eastEC = czm_normal * east;
+    v_northEC = czm_normal * cross(normal, east);
+    v_positionEC = (czm_modelViewRelativeToEye * p).xyz;
+
+    // Where this vertex sits in the ripple field, in metres from an origin that follows the camera.
+    v_waveMetres = st * u_extentMetres - u_waveOrigin;
+//#endwater
+
     gl_Position = czm_modelViewProjectionRelativeToEye * p;
 }
 `;
@@ -43758,10 +43854,30 @@ uniform float u_valuePacked;
 uniform float u_valueRange;
 uniform float u_exaggeration;
 uniform float u_metresPerTexel;
+//#water
+uniform float u_waterWavelength;
+uniform float u_waterAmplitude;
+uniform float u_waterReflectivity;
+uniform float u_waterGloss;
+uniform float u_waterSun;
+uniform vec3 u_waterSky;
+// One scrolled phase per ripple layer, wrapped into a turn on the CPU.
+uniform vec4 u_wavePhase;
+uniform vec4 u_wavePhaseB;
+// Metres the whole ripple field repeats over.
+uniform float u_wavePeriod;
+//#endwater
 
 in vec2 v_st;
 in float v_value;
 in float v_coverage;
+//#water
+in vec3 v_positionEC;
+in vec3 v_eastEC;
+in vec3 v_northEC;
+in vec3 v_upEC;
+in vec2 v_waveMetres;
+//#endwater
 
 /*
  * Scaled per channel for the same reason the vertex shader's decode is: reassembling the pair reaches
@@ -43773,6 +43889,84 @@ float valueAt(vec2 uv) {
     return mix(texel.r, packed16, u_valuePacked);
 }
 
+//#water
+/*
+ * Slope of the ripple field at a point, in metres of rise per metre travelled.
+ */
+vec2 rippleSlope(vec2 metres, float metresPerPixel, out float detail) {
+    vec2 slope = vec2(0.0);
+    detail = 0.0;
+    float amplitude = u_waterAmplitude * 0.5;
+${WATER_WAVES.map((wave, index) => {
+        const cycles = waveCycles(wave);
+        return `
+    {
+        vec2 lattice = vec2(${wave.x.toFixed(1)}, ${wave.y.toFixed(1)});
+        float k = 6.2831853 * ${cycles.toFixed(4)} / u_wavePeriod;
+        float pixels = u_wavePeriod / ${cycles.toFixed(4)} / max(metresPerPixel, 1e-6);
+        float weight = smoothstep(${WATER_MIN_PIXELS_PER_WAVE.toFixed(1)},
+            ${WATER_FULL_PIXELS_PER_WAVE.toFixed(1)}, pixels);
+        vec2 direction = lattice / ${cycles.toFixed(4)};
+        float phase = 6.2831853 * dot(lattice, metres) / u_wavePeriod
+            + ${index < 4 ? `u_wavePhase[${index}]` : `u_wavePhaseB[${index - 4}]`};
+        slope += direction * (amplitude * ${wave.amplitude.toFixed(4)} * k * cos(phase) * weight);
+        detail += ${WATER_WAVE_SLOPES[index].toFixed(5)} * weight;
+    }`;
+    }).join("")}
+    return slope;
+}
+
+/*
+ * The sheet shaded as a water surface: a flat body colour seen through a sun glint and a grazing
+ * sky reflection, with the ripple field standing in for a geometry it is far too fine to carry.
+ */
+vec4 water(vec3 relief, vec4 color) {
+    float metresPerPixel = czm_metersPerPixel(vec4(v_positionEC, 1.0));
+    float detail;
+    vec2 slope = rippleSlope(v_waveMetres, metresPerPixel, detail);
+
+    // relief arrives normalised, so its horizontal part over its vertical part is the slope it means.
+    vec2 reliefSlope = relief.xy / max(relief.z, 1e-3);
+    vec3 local = normalize(vec3(-(slope + reliefSlope), 1.0));
+    vec3 normalEC = normalize(local.x * v_eastEC + local.y * v_northEC + local.z * v_upEC);
+
+    vec3 view = normalize(-v_positionEC);
+    // Drawn with culling off, so the underside of the sheet arrives with its normal pointing away.
+    normalEC = dot(normalEC, view) < 0.0 ? -normalEC : normalEC;
+    vec3 sun = normalize(czm_sunDirectionEC);
+
+    // Water at a grazing angle is almost a mirror and water looked straight down is almost clear.
+    // That split is the single strongest cue that a blue surface is wet, more than any ripple is.
+    float fresnel = u_waterReflectivity
+        * (0.02 + 0.98 * pow(1.0 - clamp(dot(normalEC, view), 0.0, 1.0), 5.0));
+
+    // Softened by the roughness the shading has had to give up.
+    fresnel *= mix(0.55, 1.0, detail);
+
+    // Where the ripples have faded out the surface is not smooth, it is rough below one pixel, so
+    // the glint has to widen to cover what the normal no longer says.
+    float gloss = mix(u_waterGloss * 0.12, u_waterGloss, detail);
+    vec3 halfway = normalize(sun + view);
+    // Weighted by the same reflectance as the sky, because a glint is a reflection too.
+    float glint = pow(max(dot(normalEC, halfway), 0.0), gloss) * u_waterSun * fresnel;
+    float lambert = clamp(dot(normalEC, sun), 0.0, 1.0);
+
+    vec3 body = color.rgb * (0.55 + 0.6 * lambert);
+    vec3 lit = min(mix(body, u_waterSky, fresnel) + vec3(glint), vec3(1.0));
+
+    /*
+     * The same fog the globe under it is already drawing with.
+     */
+    lit = czm_fog(length(v_positionEC), lit, u_waterSky);
+
+    // A reflection seen through a half-transparent sheet is not a reflection, so the surface is
+    // allowed to close up exactly where it is being reflective.
+    float alpha = color.a * v_coverage;
+    alpha = clamp(alpha + (1.0 - alpha) * (fresnel * 0.55 + glint), 0.0, 1.0);
+    return vec4(lit, alpha);
+}
+//#endwater
+
 void main() {
     if (v_coverage < u_coverageCutoff) {
         discard;
@@ -43793,12 +43987,27 @@ void main() {
     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));
+
+//#water
+    out_FragColor = water(n, color);
+    return;
+//#endwater
+
     float lambert = clamp(dot(n, normalize(vec3(-0.5, -0.6, 0.62))), 0.0, 1.0);
     color.rgb *= 0.45 + 0.9 * lambert;
 
     out_FragColor = vec4(color.rgb, color.a * v_coverage);
 }
 `;
+    /*
+     * Strips the water-only regions out of a shader source unless this surface is drawing water.
+     */
+    function withWater(source, water) {
+        if (water) {
+            return source.replace(/^\/\/#(end)?water\n/gm, "");
+        }
+        return source.replace(/^\/\/#water\n[\s\S]*?^\/\/#endwater\n/gm, "");
+    }
     /*
      * Rewrites a GLSL 300 es source into the GLSL 100 dialect older Cesium builds author in.
      */
@@ -44127,6 +44336,7 @@ void main() {
             this.texture = null;
             this.textureDirty = true;
             this.shaderProgram = null;
+            this.shaderProgramWater = false;
             this.renderState = null;
             this.destroyed = false;
             this.lastEyePosition = null;
@@ -44143,6 +44353,13 @@ void main() {
             this.maskGroundBox = null;
             this.maskGroundRequested = false;
             this.maskGroundLevel = 0;
+            this.water = null;
+            this.waterStartMs = now();
+            this.waveOrigin = new Cartesian2(0, 0);
+            this.extentMetresCache = null;
+            // Written in place each frame rather than reallocated, since they are read per tile.
+            this.wavePhaseScratch = [new Cartesian4(), new Cartesian4()];
+            this.waterSkyScratch = new Cartesian3();
             this.followGround = Boolean(options.followGround);
             this.terrainProvider = options.terrainProvider || null;
             this.extent = options.extent;
@@ -44158,6 +44375,23 @@ void main() {
             this.maskFillValue = firstOpaqueStop(this.rampPixels);
             this.tiles = buildTiles(hasCoverage);
             this.SetGroundClearance(options.groundClearance || null);
+            this.SetWater(options.water || null);
+        }
+        GetWater() {
+            return this.water;
+        }
+        /**
+         * Shades the sheet as water, or stops. Null goes back to the relief shading.
+         *
+         * Nothing is rebuilt: no mesh, no texture and no shader, since the water path is a branch in
+         * the fragment shader the whole scene already carries. So this is cheap enough to drive from
+         * a control the user is dragging.
+         */
+        SetWater(water) {
+            if (water && !this.water) {
+                this.waterStartMs = now();
+            }
+            this.water = water;
         }
         GetFollowsGround() {
             return this.followGround;
@@ -44328,6 +44562,12 @@ void main() {
                 const mesh = this.ensureMesh(context, tile, tile.tier);
                 frameState.commandList.push(this.commandFor(context, tile, mesh));
             }
+            if (this.water) {
+                this.updateWaveOrigin(frameState);
+                if (frameState.afterRender) {
+                    frameState.afterRender.push(() => true);
+                }
+            }
         }
         isDestroyed() {
             return this.destroyed;
@@ -44539,6 +44779,73 @@ void main() {
                 })
             });
         }
+        /*
+         * Metres the extent spans west to east and north to south, which is what turns the shader's
+         * 0..1 surface coordinate into the real distance the ripple wavelength is measured in.
+         */
+        extentMetres() {
+            // The extent never moves, and this is read once per tile per frame.
+            if (this.extentMetresCache) {
+                return this.extentMetresCache;
+            }
+            const southWest = Cartesian3.fromDegrees(this.extent.West, this.extent.South, 0);
+            const southEast = Cartesian3.fromDegrees(this.extent.East, this.extent.South, 0);
+            const northWest = Cartesian3.fromDegrees(this.extent.West, this.extent.North, 0);
+            this.extentMetresCache = new Cartesian2(Math.max(1, Cartesian3.distance(southWest, southEast)), Math.max(1, Cartesian3.distance(southWest, northWest)));
+            return this.extentMetresCache;
+        }
+        /*
+         * Where each ripple layer has scrolled to, wrapped into one turn.
+         */
+        wavePhase(from) {
+            var _a;
+            const into = this.wavePhaseScratch[from / 4];
+            const water = this.water;
+            if (!water) {
+                return Cartesian4.clone(Cartesian4.ZERO, into);
+            }
+            const speed = (_a = water.speed) !== null && _a !== void 0 ? _a : DEFAULT_WATER_SPEED_METRES_PER_SECOND;
+            const period = this.wavePeriod();
+            const seconds = (now() - this.waterStartMs) / 1000;
+            const base = waveCycles(WATER_WAVES[WATER_BASE_WAVE]);
+            const phaseAt = (index) => {
+                const wave = WATER_WAVES[from + index];
+                if (!wave) {
+                    return 0;
+                }
+                const cycles = waveCycles(wave);
+                const waveNumber = 2 * Math.PI * cycles / period;
+                const travels = Math.sqrt(base / cycles);
+                return (seconds * speed * travels * waveNumber) % (2 * Math.PI);
+            };
+            into.x = phaseAt(0);
+            into.y = phaseAt(1);
+            into.z = phaseAt(2);
+            into.w = phaseAt(3);
+            return into;
+        }
+        wavePeriod() {
+            const wavelength = (this.water && this.water.wavelength) || DEFAULT_WATER_WAVELENGTH_METRES;
+            return wavelength * WATER_PERIOD_IN_WAVELENGTHS;
+        }
+        /*
+         * The point the ripple phase is measured from, kept near the camera and snapped to a whole
+         * number of periods in each direction.
+         */
+        updateWaveOrigin(frameState) {
+            const period = this.wavePeriod();
+            const carto = Cartographic.fromCartesian(frameState.camera.positionWC);
+            if (!carto) {
+                return;
+            }
+            const metres = this.extentMetres();
+            const longitude = Math$1.toDegrees(carto.longitude);
+            const latitude = Math$1.toDegrees(carto.latitude);
+            const u = (longitude - this.extent.West) / (this.extent.East - this.extent.West);
+            // North is v zero, the way the vertex shader places the surface.
+            const v = (this.extent.North - latitude) / (this.extent.North - this.extent.South);
+            this.waveOrigin = new Cartesian2(Math.floor(u * metres.x / period) * period, Math.floor(v * metres.y / period) * period);
+        }
         /*
          * Ground distance between neighbouring texels, so the shading normal is built from a real
          * slope rather than a made up one.
@@ -44702,14 +45009,22 @@ void main() {
             return isFinite(nearest) ? Math.max(1, nearest) : 1;
         }
         commandFor(context, tile, mesh) {
+            // Rebuilt when the effect is switched, since which program is wanted is part of it.
+            const wantsWater = Boolean(this.water);
+            if (this.shaderProgram && this.shaderProgramWater !== wantsWater) {
+                this.shaderProgram = null;
+            }
             if (!this.shaderProgram) {
                 const glsl300 = usesGlsl300(context);
+                const vertex = withWater(VERTEX_SHADER_GLSL300, wantsWater);
+                const fragment = withWater(FRAGMENT_SHADER_GLSL300, wantsWater);
                 this.shaderProgram = ShaderProgram.fromCache({
                     context,
-                    vertexShaderSource: glsl300 ? VERTEX_SHADER_GLSL300 : toGlsl100(VERTEX_SHADER_GLSL300, false),
-                    fragmentShaderSource: glsl300 ? FRAGMENT_SHADER_GLSL300 : toGlsl100(FRAGMENT_SHADER_GLSL300, true),
+                    vertexShaderSource: glsl300 ? vertex : toGlsl100(vertex, false),
+                    fragmentShaderSource: glsl300 ? fragment : toGlsl100(fragment, true),
                     attributeLocations: mesh.attributeLocations
                 });
+                this.shaderProgramWater = wantsWater;
                 this.renderState = RenderState.fromCache({
                     depthTest: { enabled: true },
                     // Translucent ramp: blend, and leave the depth buffer to the opaque world.
@@ -44765,11 +45080,38 @@ void main() {
                             : 0,
                         u_coverageCutoff: () => COVERAGE_CUTOFF,
                         u_rampTexture: () => self.rampTexture,
-                        u_texelSize: () => new Cartesian2(1 / self.source.width, 1 / self.source.height)
+                        u_texelSize: () => new Cartesian2(1 / self.source.width, 1 / self.source.height),
+                        u_waterOn: () => (self.water ? 1 : 0),
+                        u_waterWavelength: () => (self.water && self.water.wavelength)
+                            || DEFAULT_WATER_WAVELENGTH_METRES,
+                        u_waterAmplitude: () => {
+                            var _a;
+                            return (_a = (self.water && self.water.amplitude)) !== null && _a !== void 0 ? _a : DEFAULT_WATER_AMPLITUDE_METRES;
+                        },
+                        u_waterReflectivity: () => {
+                            var _a;
+                            return (_a = (self.water && self.water.reflectivity)) !== null && _a !== void 0 ? _a : DEFAULT_WATER_REFLECTIVITY;
+                        },
+                        u_waterGloss: () => (self.water && self.water.glossiness)
+                            || DEFAULT_WATER_GLOSSINESS,
+                        u_waterSun: () => {
+                            var _a;
+                            return (_a = (self.water && self.water.sunIntensity)) !== null && _a !== void 0 ? _a : DEFAULT_WATER_SUN_INTENSITY;
+                        },
+                        u_waterSky: () => {
+                            const sky = (self.water && self.water.skyColor) || DEFAULT_WATER_SKY_COLOR;
+                            return Cartesian3.fromElements(sky.red / 255, sky.green / 255, sky.blue / 255, self.waterSkyScratch);
+                        },
+                        u_wavePhase: () => self.wavePhase(0),
+                        u_wavePhaseB: () => self.wavePhase(4),
+                        u_wavePeriod: () => self.wavePeriod(),
+                        u_waveOrigin: () => self.waveOrigin,
+                        u_extentMetres: () => self.extentMetres()
                     }
                 });
             }
             // Bounding volume belongs to the mesh, so it follows whichever tier is drawing.
+            tile.command.shaderProgram = this.shaderProgram;
             tile.command.vertexArray = mesh.vertexArray;
             tile.command.boundingVolume = mesh.boundingSphere;
             return tile.command;
@@ -45419,6 +45761,23 @@ var EntityRenderEnginePolygon;
         return touched;
     }
     EntityRenderEnginePolygon.SetGroundClearance = SetGroundClearance;
+    /**
+     * Shades every rendered polygon in a set as water rather than as a coloured surface.
+     * @param cEntities
+     * @param water Pass null to go back to the relief shading.
+     */
+    function SetWater(cEntities, water) {
+        let touched = 0;
+        for (const cEntity of cEntities || []) {
+            const surface = GetDisplacedSurface(cEntity);
+            if (surface) {
+                surface.SetWater(water);
+                touched++;
+            }
+        }
+        return touched;
+    }
+    EntityRenderEnginePolygon.SetWater = SetWater;
     /**
      * Disposes a cEntity's TextureFrameSeriesAnimator.Animator (if any).
      */
@@ -45576,6 +45935,7 @@ function syncDisplacedSurface(params) {
     if (reusable && existingSurface.GetFollowsGround() === placement.followGround) {
         existingSurface.SetBaseHeight(placement.baseHeight);
         existingSurface.SetExaggeration(exaggerationFor(style));
+        existingSurface.SetWater(waterFor(style));
         return;
     }
     disposeDisplacedSurface(cEntity, viewer);
@@ -45615,6 +45975,7 @@ function syncDisplacedSurface(params) {
         valueMax: extrusionArchive.metadata.ValueMax,
         packedValue: TextureFrameSeriesAnimator.IsPackedValue(extrusionArchive.metadata),
         exaggeration: exaggerationFor(style),
+        water: waterFor(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
@@ -45660,6 +46021,14 @@ function exaggerationFor(style) {
     }
     return 1;
 }
+const WATER_EFFECT = "WATER";
+/*
+ * The water settings a style asks a displaced surface for, or null for the plain relief shading.
+ */
+function waterFor(style) {
+    var _a;
+    return ((_a = style.effect) === null || _a === void 0 ? void 0 : _a.type) === WATER_EFFECT ? {} : null;
+}
 /*
  * The lon/lat bounding rectangle of a ring, which is the frame Cesium drapes an image material in.
  */
@@ -46704,6 +47073,28 @@ var EntityRenderEngine;
         };
     }
     EntityRenderEngine.Render = Render;
+    /**
+     * Removes what a render produced that nothing has a record of, for a render whose caller has gone away.
+     * @param params
+     */
+    function RemoveAll(params) {
+        const { viewer, entities, register } = params;
+        if (!entities || viewer.isDestroyed()) {
+            return;
+        }
+        entities.forEach((entity) => {
+            if (!entity || (register === null || register === void 0 ? void 0 : register.HasRego(entity))) {
+                return;
+            }
+            try {
+                Remove({ viewer, entity });
+            }
+            catch (e) {
+                console.error("EntityRenderEngine.RemoveAll: failed to remove a visual:", e);
+            }
+        });
+    }
+    EntityRenderEngine.RemoveAll = RemoveAll;
     function Remove(params) {
         function doRemove(params) {
             const { viewer, entity, ignoreParent } = params;
@@ -47532,7 +47923,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.3.6";
+const VERSION = "7.3.8";
 /**
  * Updates the environment instance used by bruce-cesium to one specified.
  * This can be used to ensure that the instance a parent is referencing is shared between bruce-cesium, bruce-models, and the parent app.