bruce-cesium 7.7.2 → 7.7.4

package/dist/bruce-cesium.umd.js

@@ -28173,14 +28173,12 @@
                 var _a, _b;
                 // Array index is the LOD level, ie: index 0 = LOD 0.
                 const lods = obj.getLodInfos();
-                //console.log("xgrids-getLodInfos()", lods);
-                const HARD_MIN = 1000000;
-                const HARD_MAX = 20000000;
-                const maxSplats = Math.max(lods ? lods[0] || 0 : 0, HARD_MIN);
-                obj.setMaxSplats(Math.min(HARD_MAX, maxSplats));
-                if (maxSplats >= HARD_MAX) {
-                    console.warn("Reduced splat quality due to the number of splats being too large. Was: \"" + maxSplats + "\", now is: \"" + HARD_MAX + "\".");
-                }
+                const maxSplats = 6000000;
+                // LCC 0.5.4 fixes the LOD when the budget exceeds LOD 1, leaving distant splats sparse.
+                const lodBudget = (lods === null || lods === void 0 ? void 0 : lods[0]) > maxSplats && (lods === null || lods === void 0 ? void 0 : lods[1]) > 0
+                    ? Math.min(maxSplats, lods[1])
+                    : maxSplats;
+                obj.setMaxSplats(lodBudget);
                 // Auto fly to.
                 if (params.flyTo) {
                     const pos3d = (_b = (_a = obj === null || obj === void 0 ? void 0 : obj.getBounds) === null || _a === void 0 ? void 0 : _a.call(obj)) === null || _b === void 0 ? void 0 : _b.origin;
@@ -28201,6 +28199,15 @@
                     }
                 }
             });
+            if (typeof (obj === null || obj === void 0 ? void 0 : obj.setRenderState) === "function") {
+                // Splats must respect nearer meshes already drawn in the same Cesium pass.
+                obj.setRenderState({
+                    depthTest: {
+                        enabled: true,
+                        func: Cesium.WebGLConstants.LEQUAL
+                    }
+                });
+            }
             if (typeof (obj === null || obj === void 0 ? void 0 : obj.setVisible) === "function") {
                 obj.setVisible(true);
             }
@@ -45481,6 +45488,45 @@
         const hpr = Cesium.HeadingPitchRoll.fromDegrees(EnsureNumber(transform.heading), EnsureNumber(transform.pitch), EnsureNumber(transform.roll));
         return Cesium.Matrix4.multiply(frame, Cesium.Matrix4.fromRotation(Cesium.Matrix3.fromHeadingPitchRoll(hpr)), frame);
     }
+    // Assembly parts are always drawn at the heights their records hold.
+    const ASSEMBLY_HEIGHT_REFS = {
+        point: Cesium.HeightReference.NONE,
+        polyline: Cesium.HeightReference.NONE,
+        polygon: Cesium.HeightReference.NONE
+    };
+    /*
+     * Reads how an Entity Type's default Style draws its records, or null when the type cannot be read.
+     */
+    async function getStyledHeightRefs(api, entityTypeId) {
+        var _a, _b;
+        let styleId;
+        try {
+            const { entityType } = await BModels.EntityType.Get({ api, entityTypeId });
+            if (!entityType) {
+                return null;
+            }
+            styleId = entityType["DisplaySetting.ID"];
+        }
+        catch (e) {
+            console.error(e);
+            return null;
+        }
+        let settings = {};
+        if (styleId && styleId > 0) {
+            try {
+                settings = ((_b = (_a = (await BModels.Style.Get({ api, styleId })).style) === null || _a === void 0 ? void 0 : _a.Settings) !== null && _b !== void 0 ? _b : {});
+            }
+            catch (e) {
+                // A deleted Style leaves the records drawn with the defaults, as the render engines do.
+                console.error(e);
+            }
+        }
+        return {
+            point: exports.EntityRenderEngine.GetHeightRef(settings.pointStyle),
+            polyline: exports.EntityRenderEngine.GetHeightRefPolyline(exports.EntityRenderEngine.GetHeightRef(settings.polylineStyle)),
+            polygon: exports.EntityRenderEngine.GetHeightRef(settings.polygonStyle)
+        };
+    }
     // Records created within about this long ago are the ones the oversized GeometryRadius bug could have written.
     const GEOMETRY_RADIUS_SUSPECT_AGE_MS = 1000 * 60 * 60 * 24 * 183;
     // Above this a recent record's radius is treated as that bug rather than a real size.
@@ -45916,6 +45962,44 @@
                 }
                 return [];
             };
+            // Entity Type ID -> how its default Style draws each kind of geometry, read once per call.
+            const styledRefs = new Map();
+            /*
+             * How the scene would draw an undrawn record's geometry, or null to fall back to the sample's heightRef.
+             */
+            const getStyledRefs = (entity) => {
+                var _a, _b, _c;
+                // Assembly parts are drawn at absolute heights whatever their type's Style says, read with a root or not.
+                if (((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.AssemblyPosition) || ((_b = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _b === void 0 ? void 0 : _b.AssemblyRootLocation)) {
+                    return Promise.resolve(ASSEMBLY_HEIGHT_REFS);
+                }
+                const typeId = (_c = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _c === void 0 ? void 0 : _c["EntityType.ID"];
+                if (!api || !typeId) {
+                    return Promise.resolve(null);
+                }
+                if (!styledRefs.has(typeId)) {
+                    styledRefs.set(typeId, getStyledHeightRefs(api, typeId));
+                }
+                return styledRefs.get(typeId);
+            };
+            /*
+             * Makes a record's positions absolute as a Style draws them, sampling terrain as none may be loaded there.
+             */
+            const placeStyled = async (posses, heightRef, sample) => {
+                if (heightRef != Cesium.HeightReference.NONE) {
+                    for (let i = 0; i < posses.length; i++) {
+                        const carto = Cesium.Cartographic.fromCartesian(posses[i]);
+                        if (!carto) {
+                            continue;
+                        }
+                        const { height: terrainHeight } = await exports.DrawingUtils.GetTerrainHeight({ pos3d: posses[i], viewer });
+                        const ground = EnsureNumber(terrainHeight, 0);
+                        carto.height = heightRef == Cesium.HeightReference.CLAMP_TO_GROUND ? ground : carto.height + ground;
+                        posses[i] = Cesium.Cartographic.toCartesian(carto);
+                    }
+                }
+                await ensureHeightRefs(posses, { ...sample, heightRef: Cesium.HeightReference.NONE });
+            };
             /**
              * Returns an array of positions for a given sampled entity.
              * This will include the location, and geometry positions.
@@ -45930,6 +46014,9 @@
                  */
                 const evaluateRecord = async () => {
                     let posses = [];
+                    const refs = await getStyledRefs(entity);
+                    // The record's own point, kept apart so a Style can say what its altitude means.
+                    const pointPosses = [];
                     const location = BModels.Entity.GetValue({
                         entity: entity,
                         path: ["Bruce", "Location"]
@@ -45940,7 +46027,7 @@
                         // Disallowing 0.
                         if (latitude && longitude) {
                             const pos3d = Cesium.Cartesian3.fromDegrees(longitude, latitude, EnsureNumber(location.altitude));
-                            posses.push(pos3d);
+                            pointPosses.push(pos3d);
                         }
                     }
                     const geometry = BModels.Entity.GetValue({
@@ -45956,7 +46043,7 @@
                             const point = points.length > 0 ? points[0] : null;
                             if (point && BModels.Carto.ValidateCarto(point)) {
                                 const pos3d = Cesium.Cartesian3.fromDegrees(EnsureNumber(point.longitude), EnsureNumber(point.latitude), EnsureNumber(point.altitude));
-                                posses.push(pos3d);
+                                pointPosses.push(pos3d);
                             }
                         }
                         const lineStr = geometry.LineString;
@@ -45964,7 +46051,12 @@
                             const points = BModels.Geometry.ParsePoints(lineStr);
                             if (points.length > 0) {
                                 const pPosses = points.map(x => Cesium.Cartesian3.fromDegrees(EnsureNumber(x.longitude), EnsureNumber(x.latitude), EnsureNumber(x.altitude)));
-                                await ensureHeightRefs(pPosses, sample);
+                                if (refs) {
+                                    await placeStyled(pPosses, refs.polyline, sample);
+                                }
+                                else {
+                                    await ensureHeightRefs(pPosses, sample);
+                                }
                                 posses = posses.concat(pPosses);
                             }
                         }
@@ -45974,7 +46066,12 @@
                             if (boundary === null || boundary === void 0 ? void 0 : boundary.LinearRing) {
                                 const points = BModels.Geometry.ParsePoints(boundary.LinearRing);
                                 const pPosses = points.map(x => Cesium.Cartesian3.fromDegrees(EnsureNumber(x.longitude), EnsureNumber(x.latitude), EnsureNumber(x.altitude)));
-                                await ensureHeightRefs(pPosses, sample);
+                                if (refs) {
+                                    await placeStyled(pPosses, refs.polygon, sample);
+                                }
+                                else {
+                                    await ensureHeightRefs(pPosses, sample);
+                                }
                                 posses = posses.concat(pPosses);
                             }
                         }
@@ -45995,11 +46092,22 @@
                                 Cesium.Cartesian3.fromDegrees(EnsureNumber(boundaries.minLongitude), EnsureNumber(boundaries.minLatitude), EnsureNumber(boundaries.minAltitude)),
                                 Cesium.Cartesian3.fromDegrees(EnsureNumber(boundaries.maxLongitude), EnsureNumber(boundaries.maxLatitude), EnsureNumber(boundaries.maxAltitude))
                             ];
-                            await ensureHeightRefs(bPosses, sample);
+                            if (refs) {
+                                // The bounds span the record's main geometry, so they are drawn the way it is.
+                                const boundsRef = (geometry === null || geometry === void 0 ? void 0 : geometry.Polygon) ? refs.polygon : (geometry === null || geometry === void 0 ? void 0 : geometry.LineString) ? refs.polyline : refs.point;
+                                await placeStyled(bPosses, boundsRef, sample);
+                            }
+                            else {
+                                await ensureHeightRefs(bPosses, sample);
+                            }
                             posses = posses.concat(bPosses);
                         }
                     }
-                    return posses;
+                    if (refs) {
+                        await placeStyled(pointPosses, refs.point, sample);
+                    }
+                    // Points first, since a lone record is placed by its first position.
+                    return pointPosses.concat(posses);
                 };
                 if (isAssemblyEntity) {
                     // See if we have tileset coords to use.
@@ -46158,6 +46266,8 @@
                     sample.entity = (_e = simulation === null || simulation === void 0 ? void 0 : simulation.GetEntity(sample.entityId)) !== null && _e !== void 0 ? _e : sample.entity;
                 }
             }
+            // Read here at the scene's time with their location; records a caller supplied may be of another time.
+            const readHere = new Set();
             // Bulk requesting Entity records.
             try {
                 const toSearchIds = recordSamples.filter(x => !x.entity && x.entityId).map(x => x.entityId);
@@ -46179,6 +46289,9 @@
                         const sample = recordSamples[i];
                         if (!sample.entity && sample.entityId) {
                             const read = entitiesMap.get(sample.entityId);
+                            if (read) {
+                                readHere.add(sample.entityId);
+                            }
                             sample.entity = read && simulation ? simulation.Overlay(read) : read;
                         }
                     }
@@ -46189,10 +46302,10 @@
             catch (e) {
                 console.error(e);
             }
-            // Some records may still not be expanded.
-            // We have to detect whatever is an Assembly Entity and expand it.
+            // Assembly parts not read above with a location expand still need one, and the ones off the scene are dropped
+            // when others are in it, since category nodes without geometry would otherwise pull the result elsewhere.
             try {
-                const needsExpansion = recordSamples.filter(x => {
+                const assemblySamples = recordSamples.filter(x => {
                     var _a;
                     // Expanding reads the API's record, which would replace the stand-in or undo the patch.
                     if (simulation === null || simulation === void 0 ? void 0 : simulation.HasBlob((_a = x.entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID)) {
@@ -46202,36 +46315,30 @@
                         entity: x.entity,
                         path: ["Bruce", "AssemblyPosition"]
                     });
-                    if (!assemblyPos) {
-                        return false;
-                    }
-                    const rootPos = BModels.Entity.GetValue({
-                        entity: x.entity,
-                        path: ["Bruce", "AssemblyRootPosition"]
-                    });
-                    return !rootPos;
+                    return !!assemblyPos;
                 });
+                const isInScene = (sample) => {
+                    var _a;
+                    return !!(visualRegister && visualRegister.GetRego({
+                        entityId: (_a = sample.entityId) !== null && _a !== void 0 ? _a : sample.entity.Bruce.ID,
+                        menuItemId: sample.menuItemId
+                    }));
+                };
+                const sceneSamples = assemblySamples.filter(isInScene);
+                const offSceneSamples = sceneSamples.length ? assemblySamples.filter(x => !isInScene(x)) : [];
+                if (offSceneSamples.length) {
+                    const offSceneIds = new Set(offSceneSamples.map(x => x.entity.Bruce.ID));
+                    recordSamples = recordSamples.filter(x => !offSceneIds.has(x.entity.Bruce.ID));
+                }
+                const keptSamples = sceneSamples.length ? sceneSamples : assemblySamples;
+                const needsExpansion = keptSamples.filter(x => !readHere.has(x.entity.Bruce.ID) || !BModels.Entity.GetValue({
+                    entity: x.entity,
+                    path: ["Bruce", "AssemblyRootLocation"]
+                }));
                 if (needsExpansion.length) {
                     const EXPAND_BATCH_SIZE = 30;
                     const EXPAND_MAX_IDS = 200;
-                    // Figure out if any are in the scene.
-                    // Helps us sort leaf-nodes away from category nodes thta don't have geometry.
-                    const isInScene = (sample) => {
-                        var _a;
-                        return !!(visualRegister && visualRegister.GetRego({
-                            entityId: (_a = sample.entityId) !== null && _a !== void 0 ? _a : sample.entity.Bruce.ID,
-                            menuItemId: sample.menuItemId
-                        }));
-                    };
-                    // Trim to max 200 with a preference to those in the scene.
-                    const sceneSamples = needsExpansion.filter(isInScene);
-                    const offSceneSamples = sceneSamples.length ? needsExpansion.filter(x => !isInScene(x)) : [];
-                    if (offSceneSamples.length) {
-                        const offSceneIds = new Set(offSceneSamples.map(x => x.entity.Bruce.ID));
-                        recordSamples = recordSamples.filter(x => !offSceneIds.has(x.entity.Bruce.ID));
-                    }
-                    const effectiveSamples = sceneSamples.length ? sceneSamples : needsExpansion;
-                    const uniqueIds = Array.from(new Set(effectiveSamples.map(x => x.entity.Bruce.ID)));
+                    const uniqueIds = Array.from(new Set(needsExpansion.map(x => x.entity.Bruce.ID)));
                     const expandIds = uniqueIds.slice(0, EXPAND_MAX_IDS);
                     // Anything we didn't expand will taint the overall result so we have to filter them out.
                     const droppedIds = new Set(uniqueIds.slice(EXPAND_MAX_IDS));
@@ -46260,8 +46367,8 @@
                             expandedMap.set(entities[i].Bruce.ID, entities[i]);
                         }
                     }
-                    for (let i = 0; i < effectiveSamples.length; i++) {
-                        const sample = effectiveSamples[i];
+                    for (let i = 0; i < needsExpansion.length; i++) {
+                        const sample = needsExpansion[i];
                         const expanded = expandedMap.get(sample.entity.Bruce.ID);
                         if (expanded) {
                             sample.entity = expanded;
@@ -57015,7 +57122,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.7.2";
+    const VERSION = "7.7.4";
     /**
      * 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.