bruce-cesium 7.3.6 → 7.3.7

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, ColorBlendMode, HeadingPitchRoll, Math as Math$1, Transforms, ShadowMode, Cartesian3, ClassificationType, Model, JulianDate, Quaternion, Matrix4, ArcType, CornerType, ConstantPositionProperty, HorizontalOrigin, VerticalOrigin, ShaderSource, Ellipsoid, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, Cartesian4, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, DistanceDisplayCondition, ImageMaterialProperty, SceneTransforms, PolygonHierarchy, PolylineGraphics, Rectangle, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, Cesium3DTileColorBlendMode, HeadingPitchRange, Ion, IonResource, OrthographicFrustum, EasingFunction, Cesium3DTileset, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, Intersect, PolygonPipeline, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, GeometryInstance, CustomDataSource, 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, Api, ClientFileValueMap, Color as Color$1, Bounds, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, BruceApi, EntityRelation, EntitySource, RecordChangeFeed, Camera, ProgramKey, ProjectViewLegacyTile, Account, AccountLimits, Session, UrlUtils, ProjectViewBookmarkGroup, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, 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;
@@ -43589,6 +43595,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 +43668,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.
@@ -43746,6 +43797,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;
 }
 `;
@@ -43758,10 +43828,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
@@ -43773,6 +43860,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;
@@ -43793,6 +43956,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;
 
@@ -44143,6 +44312,9 @@ void main() {
             this.maskGroundBox = null;
             this.maskGroundRequested = false;
             this.maskGroundLevel = 0;
+            this.water = null;
+            this.waterStartMs = now();
+            this.waveOrigin = new Cartesian2(0, 0);
             this.followGround = Boolean(options.followGround);
             this.terrainProvider = options.terrainProvider || null;
             this.extent = options.extent;
@@ -44158,6 +44330,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 +44517,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 +44734,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 = 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);
+            return new Cartesian2(Math.max(1, Cartesian3.distance(southWest, southEast)), Math.max(1, 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 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 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 = 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.
@@ -44765,7 +45014,33 @@ 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 new 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()
                     }
                 });
             }
@@ -45419,6 +45694,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 +45868,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 +45908,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 +45954,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.
  */
@@ -47532,7 +47834,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.3.6";
+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.