bruce-cesium 7.3.5 → 7.3.7

package/dist/bruce-cesium.umd.js

@@ -400,7 +400,7 @@
         function EnsurePosHeight(params) {
             let { pos3d, viewer, desiredHeightRef, heightRef } = params;
             const carto = BModels.Cartes.ValidateCartes3(pos3d) ? Cesium.Cartographic.fromCartesian(pos3d) : null;
-            if (!(carto === null || carto === void 0 ? void 0 : carto.latitude)) {
+            if (!carto) {
                 return pos3d;
             }
             if (heightRef == null) {
@@ -3339,6 +3339,12 @@
             }
         }
         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;
@@ -33467,12 +33473,11 @@
         }
     }
 
-    var ECursor;
     (function (ECursor) {
         ECursor["Select"] = "select";
         ECursor["Pan"] = "pan";
         ECursor["Measure"] = "measure";
-    })(ECursor || (ECursor = {}));
+    })(exports.ECursor || (exports.ECursor = {}));
     var ESecondaryCursor;
     (function (ESecondaryCursor) {
         ESecondaryCursor["None"] = "none";
@@ -33486,14 +33491,32 @@
         constructor(params) {
             super(params);
             this.STYLESHEET_ID = "nextspace-cursorbar-stylesheet";
-            this._selectedCursor = ECursor.Select;
+            this._selectedCursor = exports.ECursor.Select;
             this._selectedSecondaryCursor = ESecondaryCursor.None;
             this.OnCursorChange = new BModels.BruceEvent();
             this._generateStyles();
             this._generateElement();
-            if (this._selectedCursor == ECursor.Select || this._selectedSecondaryCursor == ESecondaryCursor.Select) {
+            if (this._selectedCursor == exports.ECursor.Select || this._selectedSecondaryCursor == ESecondaryCursor.Select) {
+                this._listenSelection();
+            }
+        }
+        /**
+         * @param cursor
+         */
+        SetCursor(cursor) {
+            if (cursor == this._selectedCursor) {
+                return;
+            }
+            this._disposeMeasureTool();
+            this._disposeCesiumEvent();
+            this._selectedCursor = cursor;
+            this._selectedSecondaryCursor = ESecondaryCursor.None;
+            this._secondary.style.display = "none";
+            if (cursor == exports.ECursor.Select) {
                 this._listenSelection();
             }
+            this._updateControls();
+            this.OnCursorChange.Trigger(cursor);
         }
         Dispose() {
             var _a, _b;
@@ -33745,8 +33768,8 @@
                 <path d="M11.0706 25L9 7L23 17.8592L15.3135 18.3375L11.0706 25Z" fill="white" stroke="white" strokeLinejoin="round"/>
             </svg>
         `;
-            this._generateControl("Select", ECursor.Select, () => {
-                this._selectedCursor = ECursor.Select;
+            this._generateControl("Select", exports.ECursor.Select, () => {
+                this._selectedCursor = exports.ECursor.Select;
                 this._secondary.style.display = "none";
                 this._listenSelection();
                 this.OnCursorChange.Trigger(this._selectedCursor);
@@ -33758,10 +33781,10 @@
                 <path d="M15.5652 6C14.9172 6 14.3913 6.51692 14.3913 7.15385V14.4615H13.6087V8.69231C13.6087 8.05538 13.0828 7.53846 12.4348 7.53846C11.7868 7.53846 11.2609 8.05538 11.2609 8.69231V14.4615V16.7692V19.6734C11.2609 19.6734 9.0069 18.2402 7.87211 17.7548C7.55594 17.6194 7.22575 17.5385 6.89079 17.5385C5.1401 17.5385 5 19.0769 5 19.0769L8.13043 21.3846L10.6357 24.3398C11.5279 25.3922 12.85 26 14.243 26H19.8696C21.5983 26 23 24.6223 23 22.9231V14.4615V11C23 10.3631 22.4741 9.84615 21.8261 9.84615C21.1781 9.84615 20.6522 10.3631 20.6522 11V14.4615H19.8696V8.69231C19.8696 8.05538 19.3437 7.53846 18.6957 7.53846C18.0477 7.53846 17.5217 8.05538 17.5217 8.69231V14.4615H16.7391V7.15385C16.7391 6.51692 16.2132 6 15.5652 6Z" fill="white"/>
             </svg>
         `;
-            this._generateControl("Pan", ECursor.Pan, () => {
-                this._selectedCursor = this._selectedCursor == ECursor.Pan ? ECursor.Select : ECursor.Pan;
+            this._generateControl("Pan", exports.ECursor.Pan, () => {
+                this._selectedCursor = this._selectedCursor == exports.ECursor.Pan ? exports.ECursor.Select : exports.ECursor.Pan;
                 this._secondary.style.display = "none";
-                if (this._selectedCursor == ECursor.Select) {
+                if (this._selectedCursor == exports.ECursor.Select) {
                     this._listenSelection();
                 }
                 this.OnCursorChange.Trigger(this._selectedCursor);
@@ -33773,17 +33796,17 @@
                 <path d="M26.5044 8.88032C26.1735 8.54947 23.4505 5.8265 23.1197 5.49564C22.4588 4.83479 21.3876 4.83479 20.7267 5.49564C20.6878 5.53457 20.4449 5.77742 20.0557 6.16666L21.6753 7.78623C22.0061 8.11708 22.0061 8.65186 21.6753 8.98271C21.5103 9.14771 21.2936 9.23064 21.077 9.23064C20.8604 9.23064 20.6438 9.14771 20.4788 8.98271L18.8592 7.36314C18.4581 7.76423 18.0063 8.21608 17.5172 8.70517L18.2906 9.47857C18.6214 9.80942 18.6214 10.3442 18.2906 10.6751C18.1256 10.8401 17.909 10.923 17.6923 10.923C17.4757 10.923 17.2591 10.8401 17.0941 10.6751L16.3207 9.90165C15.8875 10.3349 15.4381 10.7842 14.9787 11.2437L16.5982 12.8632C16.9291 13.1941 16.9291 13.7289 16.5982 14.0597C16.4332 14.2247 16.2166 14.3077 16 14.3077C15.7834 14.3077 15.5668 14.2247 15.4018 14.0597L13.7822 12.4402C13.3363 12.8861 12.8869 13.3354 12.4402 13.7822L13.2136 14.5556C13.5444 14.8864 13.5444 15.4212 13.2136 15.7521C13.0486 15.9171 12.8319 16 12.6153 16C12.3987 16 12.1821 15.9171 12.0171 15.7521L11.2437 14.9787C10.7842 15.4381 10.3349 15.8875 9.90165 16.3207L11.5212 17.9403C11.8521 18.2711 11.8521 18.8059 11.5212 19.1368C11.3562 19.3018 11.1396 19.3847 10.923 19.3847C10.7064 19.3847 10.4897 19.3018 10.3247 19.1368L8.70517 17.5172C8.21608 18.0063 7.76423 18.4581 7.36314 18.8592L8.13654 19.6326C8.46739 19.9635 8.46739 20.4982 8.13654 20.8291C7.97154 20.9941 7.75492 21.077 7.5383 21.077C7.32168 21.077 7.10506 20.9941 6.94006 20.8291L6.16666 20.0557C5.77742 20.4449 5.53457 20.6878 5.49564 20.7267C4.83479 21.3876 4.83479 22.4588 5.49564 23.1197C5.8265 23.4505 8.54947 26.1735 8.88032 26.5044C9.54118 27.1652 10.6124 27.1652 11.2733 26.5044C11.6041 26.1735 26.1735 11.6041 26.5044 11.2733C27.1652 10.6124 27.1652 9.54118 26.5044 8.88032Z" fill="white"/>
             </svg>
         `;
-            this._generateControl("Measure", ECursor.Measure, () => {
+            this._generateControl("Measure", exports.ECursor.Measure, () => {
                 this._selectedSecondaryCursor = ESecondaryCursor.Pan;
-                this._selectedCursor = this._selectedCursor == ECursor.Measure ? ECursor.Select : ECursor.Measure;
-                if (this._selectedCursor == ECursor.Measure) {
+                this._selectedCursor = this._selectedCursor == exports.ECursor.Measure ? exports.ECursor.Select : exports.ECursor.Measure;
+                if (this._selectedCursor == exports.ECursor.Measure) {
                     this._generateMeasureSecondary();
                     this._updateSecondary();
                 }
                 else {
                     this._secondary.style.display = "none";
                 }
-                if (this._selectedCursor == ECursor.Select) {
+                if (this._selectedCursor == exports.ECursor.Select) {
                     this._listenSelection();
                 }
                 this.OnCursorChange.Trigger(this._selectedCursor);
@@ -43449,6 +43472,44 @@
         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 };
@@ -43484,10 +43545,17 @@ uniform vec2 u_maskGroundSize;
 uniform vec4 u_extentDegrees;
 uniform vec4 u_maskGroundDegrees;
 uniform float u_coverageCutoffVertex;
+uniform vec2 u_extentMetres;
+uniform vec2 u_waveOrigin;
 
 out vec2 v_st;
 out float v_value;
 out float v_coverage;
+out vec3 v_positionEC;
+out vec3 v_eastEC;
+out vec3 v_northEC;
+out vec3 v_upEC;
+out vec2 v_waveMetres;
 
 float decodeGround(vec2 uv) {
     // Channels arrive normalised to 0..1, so they go back to bytes before being reassembled.
@@ -43606,6 +43674,25 @@ 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);
+
+    // 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.
+     *
+     * Subtracted here rather than in the fragment shader because the position it is subtracted from
+     * spans the whole archive, which over a sound is tens of kilometres. A wave number times that
+     * is thousands of radians, and no fragment shader that may only have mediump can step through a
+     * cosine at that magnitude: the ripples come out as a flat surface, which is what a first cut of
+     * this did. What crosses into the fragment shader is a small number the camera is standing in.
+     */
+    v_waveMetres = st * u_extentMetres - u_waveOrigin;
+
     gl_Position = czm_modelViewProjectionRelativeToEye * p;
 }
 `;
@@ -43618,10 +43705,27 @@ uniform float u_valuePacked;
 uniform float u_valueRange;
 uniform float u_exaggeration;
 uniform float u_metresPerTexel;
+uniform float u_waterOn;
+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;
 
 in vec2 v_st;
 in float v_value;
 in float v_coverage;
+in vec3 v_positionEC;
+in vec3 v_eastEC;
+in vec3 v_northEC;
+in vec3 v_upEC;
+in vec2 v_waveMetres;
 
 /*
  * Scaled per channel for the same reason the vertex shader's decode is: reassembling the pair reaches
@@ -43633,6 +43737,82 @@ float valueAt(vec2 uv) {
     return mix(texel.r, packed16, u_valuePacked);
 }
 
+/*
+ * 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);
+}
+
 void main() {
     if (v_coverage < u_coverageCutoff) {
         discard;
@@ -43653,6 +43833,12 @@ 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));
+
+    if (u_waterOn > 0.5) {
+        out_FragColor = water(n, color);
+        return;
+    }
+
     float lambert = clamp(dot(n, normalize(vec3(-0.5, -0.6, 0.62))), 0.0, 1.0);
     color.rgb *= 0.45 + 0.9 * lambert;
 
@@ -44003,6 +44189,9 @@ void main() {
                 this.maskGroundBox = null;
                 this.maskGroundRequested = false;
                 this.maskGroundLevel = 0;
+                this.water = null;
+                this.waterStartMs = now();
+                this.waveOrigin = new Cesium.Cartesian2(0, 0);
                 this.followGround = Boolean(options.followGround);
                 this.terrainProvider = options.terrainProvider || null;
                 this.extent = options.extent;
@@ -44018,6 +44207,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;
@@ -44188,6 +44394,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;
@@ -44399,6 +44611,60 @@ 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() {
+                const southWest = Cesium.Cartesian3.fromDegrees(this.extent.West, this.extent.South, 0);
+                const southEast = Cesium.Cartesian3.fromDegrees(this.extent.East, this.extent.South, 0);
+                const northWest = Cesium.Cartesian3.fromDegrees(this.extent.West, this.extent.North, 0);
+                return new Cesium.Cartesian2(Math.max(1, Cesium.Cartesian3.distance(southWest, southEast)), Math.max(1, Cesium.Cartesian3.distance(southWest, northWest)));
+            }
+            /*
+             * Where each ripple layer has scrolled to, wrapped into one turn.
+             */
+            wavePhase(from) {
+                var _a;
+                const water = this.water;
+                if (!water) {
+                    return new Cesium.Cartesian4(0, 0, 0, 0);
+                }
+                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 phases = WATER_WAVES.slice(from, from + 4).map((wave) => {
+                    const cycles = waveCycles(wave);
+                    const waveNumber = 2 * Math.PI * cycles / period;
+                    const travels = Math.sqrt(base / cycles);
+                    const travelled = seconds * speed * travels * waveNumber;
+                    return travelled % (2 * Math.PI);
+                });
+                return new Cesium.Cartesian4(phases[0] || 0, phases[1] || 0, phases[2] || 0, phases[3] || 0);
+            }
+            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 = Cesium.Cartographic.fromCartesian(frameState.camera.positionWC);
+                if (!carto) {
+                    return;
+                }
+                const metres = this.extentMetres();
+                const longitude = Cesium.Math.toDegrees(carto.longitude);
+                const latitude = Cesium.Math.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 Cesium.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.
@@ -44625,7 +44891,33 @@ void main() {
                                 : 0,
                             u_coverageCutoff: () => COVERAGE_CUTOFF,
                             u_rampTexture: () => self.rampTexture,
-                            u_texelSize: () => new Cesium.Cartesian2(1 / self.source.width, 1 / self.source.height)
+                            u_texelSize: () => new Cesium.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 new Cesium.Cartesian3(sky.red / 255, sky.green / 255, sky.blue / 255);
+                            },
+                            u_wavePhase: () => self.wavePhase(0),
+                            u_wavePhaseB: () => self.wavePhase(4),
+                            u_wavePeriod: () => self.wavePeriod(),
+                            u_waveOrigin: () => self.waveOrigin,
+                            u_extentMetres: () => self.extentMetres()
                         }
                     });
                 }
@@ -45278,6 +45570,23 @@ void main() {
             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).
          */
@@ -45435,6 +45744,7 @@ void main() {
         if (reusable && existingSurface.GetFollowsGround() === placement.followGround) {
             existingSurface.SetBaseHeight(placement.baseHeight);
             existingSurface.SetExaggeration(exaggerationFor(style));
+            existingSurface.SetWater(waterFor(style));
             return;
         }
         disposeDisplacedSurface(cEntity, viewer);
@@ -45474,6 +45784,7 @@ void main() {
             valueMax: extrusionArchive.metadata.ValueMax,
             packedValue: exports.TextureFrameSeriesAnimator.IsPackedValue(extrusionArchive.metadata),
             exaggeration: exaggerationFor(style),
+            water: waterFor(style),
             lowColor: mask ? BModels.Color.ColorFromStr(mask.minColor) : null,
             highColor: mask ? BModels.Color.ColorFromStr(mask.maxColor) : null,
             // Normalised the same way the animator normalises them, so the surface and the flat drape
@@ -45519,6 +45830,14 @@ void main() {
         }
         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.
      */
@@ -47376,7 +47695,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.3.5";
+    const VERSION = "7.3.7";
     /**
      * 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.