bruce-cesium 7.3.6 → 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;
@@ -43466,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 };
@@ -43501,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.
@@ -43623,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;
 }
 `;
@@ -43635,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
@@ -43650,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;
@@ -43670,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;
 
@@ -44020,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;
@@ -44035,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;
@@ -44205,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;
@@ -44416,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.
@@ -44642,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()
                         }
                     });
                 }
@@ -45295,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).
          */
@@ -45452,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);
@@ -45491,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
@@ -45536,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.
      */
@@ -47393,7 +47695,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.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.