bruce-cesium 7.3.7 → 7.3.8

package/dist/bruce-cesium.umd.js

@@ -9493,6 +9493,14 @@
                     }
                 };
             }
+            /**
+             * 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.
@@ -12659,6 +12667,11 @@
                     optimizeTolerance: this.item.optimizeTolerance,
                 });
                 if (this.disposed) {
+                    exports.EntityRenderEngine.RemoveAll({
+                        viewer: this.viewer,
+                        entities: cEntities,
+                        register: this.visualsManager
+                    });
                     this.doDispose();
                     return;
                 }
@@ -13660,6 +13673,11 @@
                     force
                 });
                 if (this.disposed) {
+                    exports.EntityRenderEngine.RemoveAll({
+                        viewer: this.viewer,
+                        entities: cEntities,
+                        register: this.visualsManager
+                    });
                     this.visualsManager.RemoveRegos({
                         menuItemId: this.item.id
                     });
@@ -14099,10 +14117,15 @@
                     zoomControl: this.item.CameraZoomSettings,
                     force: force || changed
                 });
+                if (this.disposed) {
+                    exports.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);
@@ -19471,6 +19494,11 @@
                         force
                     });
                     if (this.disposed) {
+                        exports.EntityRenderEngine.RemoveAll({
+                            viewer: this.viewer,
+                            entities: cEntities,
+                            register: this.visualsManager
+                        });
                         return;
                     }
                     for (let i = 0; i < entities.length; i++) {
@@ -43545,17 +43573,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.
@@ -43675,6 +43707,7 @@ void main() {
     // 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));
@@ -43682,16 +43715,9 @@ void main() {
     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.
-     */
+    // 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;
 }
@@ -43705,7 +43731,7 @@ uniform float u_valuePacked;
 uniform float u_valueRange;
 uniform float u_exaggeration;
 uniform float u_metresPerTexel;
-uniform float u_waterOn;
+//#water
 uniform float u_waterWavelength;
 uniform float u_waterAmplitude;
 uniform float u_waterReflectivity;
@@ -43717,15 +43743,18 @@ 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
@@ -43737,6 +43766,7 @@ 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.
  */
@@ -43812,6 +43842,7 @@ vec4 water(vec3 relief, vec4 color) {
     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) {
@@ -43834,10 +43865,10 @@ void main() {
     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;
-    }
+//#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;
@@ -43845,6 +43876,15 @@ void main() {
     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.
          */
@@ -44173,6 +44213,7 @@ void main() {
                 this.texture = null;
                 this.textureDirty = true;
                 this.shaderProgram = null;
+                this.shaderProgramWater = false;
                 this.renderState = null;
                 this.destroyed = false;
                 this.lastEyePosition = null;
@@ -44192,6 +44233,10 @@ void main() {
                 this.water = null;
                 this.waterStartMs = now();
                 this.waveOrigin = new Cesium.Cartesian2(0, 0);
+                this.extentMetresCache = null;
+                // Written in place each frame rather than reallocated, since they are read per tile.
+                this.wavePhaseScratch = [new Cesium.Cartesian4(), new Cesium.Cartesian4()];
+                this.waterSkyScratch = new Cesium.Cartesian3();
                 this.followGround = Boolean(options.followGround);
                 this.terrainProvider = options.terrainProvider || null;
                 this.extent = options.extent;
@@ -44616,32 +44661,45 @@ void main() {
              * 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 = 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)));
+                this.extentMetresCache = new Cesium.Cartesian2(Math.max(1, Cesium.Cartesian3.distance(southWest, southEast)), Math.max(1, Cesium.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 new Cesium.Cartesian4(0, 0, 0, 0);
+                    return Cesium.Cartesian4.clone(Cesium.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 phases = WATER_WAVES.slice(from, from + 4).map((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);
-                    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);
+                    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;
@@ -44828,14 +44886,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 = Cesium.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 = Cesium.RenderState.fromCache({
                         depthTest: { enabled: true },
                         // Translucent ramp: blend, and leave the depth buffer to the opaque world.
@@ -44911,7 +44977,7 @@ void main() {
                             },
                             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);
+                                return Cesium.Cartesian3.fromElements(sky.red / 255, sky.green / 255, sky.blue / 255, self.waterSkyScratch);
                             },
                             u_wavePhase: () => self.wavePhase(0),
                             u_wavePhaseB: () => self.wavePhase(4),
@@ -44922,6 +44988,7 @@ void main() {
                     });
                 }
                 // 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;
@@ -46870,6 +46937,28 @@ void main() {
             };
         }
         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;
@@ -47695,7 +47784,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.3.7";
+    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.