bruce-cesium 5.7.9 → 5.8.0

package/dist/lib/rendering/entity-render-engine-point.js

@@ -0,0 +1,984 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityRenderEnginePoint = void 0;
+const bruce_models_1 = require("bruce-models");
+const cesium_animated_property_1 = require("./cesium-animated-property");
+const Cesium = require("cesium");
+const entity_render_engine_1 = require("./entity-render-engine");
+const entity_utils_1 = require("../utils/entity-utils");
+const js_utils_1 = require("../internal/js-utils");
+const cesium_utils_1 = require("../internal/cesium-utils");
+const limited_log_1 = require("../internal/limited-log");
+const cesium_entity_styler_1 = require("../utils/cesium-entity-styler");
+/**
+ * Handles point rendering.
+ */
+var EntityRenderEnginePoint;
+(function (EntityRenderEnginePoint) {
+    /**
+     * Creates a circle billboard (canvas) for a point.
+     * @param params
+     * @returns
+     */
+    function CreateCircleBillboard(params) {
+        return createCircleBillboard(params.size, params.colorCss);
+    }
+    EntityRenderEnginePoint.CreateCircleBillboard = CreateCircleBillboard;
+    /**
+     * Renders a single point Entity.
+     * This takes an optional prior Cesium Entity to update rather than create from scratch.
+     * @param params
+     * @returns
+     */
+    async function Render(params) {
+        var _a, _b, _c, _d;
+        const entity = params.entity;
+        if (!params.entityHistoric) {
+            params.entityHistoric = [];
+        }
+        const style = params.style;
+        let type = style.Type;
+        if (type == null) {
+            // Very old backward compatibility.
+            if (style.useIcon == true) {
+                type = bruce_models_1.Style.EPointType.Icon;
+            }
+        }
+        let cEntity = null;
+        let siblings = [];
+        let heightRef = null;
+        let animatePosition = null;
+        let shouldShowTrack = false;
+        const prepareExistingGraphic = (cEntity, maxSiblings = 0) => {
+            // Gather entity in case previous version had sibling graphics we no longer need.
+            const parts = entity_utils_1.EntityUtils.GatherEntity({
+                entity: cEntity,
+            });
+            if (parts.length > 1) {
+                // We'll cull all except the allowed number of siblings.
+                cEntity._siblingGraphics = cEntity._siblingGraphics.slice(0, maxSiblings);
+                // We'll remove all that aren't in the allowed (direct) list.
+                for (let i = 0; i < parts.length - 1; i++) {
+                    const part = parts[i];
+                    if (part && part instanceof Cesium.Entity && params.viewer.entities.contains(part) && !cEntity._siblingGraphics.includes(part)) {
+                        params.viewer.entities.remove(part);
+                    }
+                }
+                if (cEntity._parentEntity) {
+                    console.warn("Point.Render: Parent entity was not null. This should not happen.");
+                }
+            }
+            siblings = cEntity._siblingGraphics;
+            cEntity._siblingGraphics = [];
+        };
+        const updateShouldShowTrack = () => {
+            var _a, _b, _c;
+            if (!params.entityHistoricDrawTrack) {
+                return;
+            }
+            if ((_a = params.entityHistoric) === null || _a === void 0 ? void 0 : _a.length) {
+                const lStyle = (_c = (_b = params.fullStyle) === null || _b === void 0 ? void 0 : _b.polylineStyle) !== null && _c !== void 0 ? _c : {};
+                let width = lStyle.width ? (0, js_utils_1.EnsureNumber)(bruce_models_1.Calculator.GetNumber(lStyle.width, entity, params.tags)) : 2;
+                if (width == null) {
+                    width = 2;
+                }
+                width = (0, js_utils_1.EnsureNumber)(width);
+                if (width > 0.01) {
+                    const bColor = lStyle.lineColor ? bruce_models_1.Calculator.GetColor(lStyle.lineColor, entity, params.tags) : null;
+                    const cColor = bColor ? (0, cesium_utils_1.ColorToCColor)(bColor) : Cesium.Color.fromCssColorString("rgba(255, 193, 7, 0.8)");
+                    if (cColor.alpha > 0) {
+                        const seriesTrackPosses = cesium_animated_property_1.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                        seriesTrackPosses.reverse();
+                        let posses = seriesTrackPosses.map(x => x.pos3d);
+                        posses = (0, cesium_utils_1.CullDuplicateCPosses)(posses);
+                        shouldShowTrack = posses.length > 1;
+                    }
+                }
+            }
+            ;
+        };
+        if (type == bruce_models_1.Style.EPointType.Icon) {
+            // Fixing poor data.
+            let iconUrlRows = style.iconUrl == null ? [] : style.iconUrl;
+            iconUrlRows.forEach((row) => {
+                if (row.type == bruce_models_1.Calculator.EValueType.Color) {
+                    row.type = bruce_models_1.Calculator.EValueType.Input;
+                }
+            });
+            const icon = bruce_models_1.Calculator.GetString(iconUrlRows, entity, params.tags);
+            let iconUrl = null;
+            if (typeof icon == "string") {
+                iconUrl = icon;
+                const metadata = extractMetadataFromFileUrl(iconUrl);
+                // If we're able to determine the Nextspace metadata from the url then we can use that to load the file.
+                // Warning, if this is cross-env, eg: UAT -> DEV then it will RIGHTLY fail to load the file.
+                if (metadata) {
+                    const api = params.apiGetter.getApi(metadata.accountId);
+                    await api.Loading;
+                    iconUrl = bruce_models_1.ClientFile.GetUrl({
+                        api: api,
+                        fileId: metadata.fileId,
+                        viaCdn: true
+                    });
+                }
+            }
+            if (!iconUrl && style.iconId) {
+                await params.api.Loading;
+                iconUrl = bruce_models_1.ClientFile.GetUrl({
+                    api: params.api,
+                    fileId: style.iconId,
+                    viaCdn: true
+                });
+            }
+            let image = null;
+            // ND-1640 - Tags not appearing.
+            // Validate file, else user will see nothing.
+            // Pray we aren't loading some giant file.
+            if (iconUrl) {
+                try {
+                    image = await createImageBillboard(iconUrl);
+                }
+                catch (e) {
+                    // Expanding the logging here so we can figure out why this is happening.
+                    // Most of the time the file is missing but we're getting some strange errors so I am including logging on the API settings as well.
+                    (0, limited_log_1.OneTimeError)("ENTITY_RENDER_ENGINE_ICON_URL_ERROR_" + iconUrl, {
+                        error: e,
+                        iconUrl,
+                        apiUrl: (_a = params.api) === null || _a === void 0 ? void 0 : _a.GetBaseUrl(),
+                        apiAccountId: (_b = params.api) === null || _b === void 0 ? void 0 : _b.AccountId
+                    });
+                }
+            }
+            if (image) {
+                let iconScale = (0, js_utils_1.EnsureNumber)(bruce_models_1.Calculator.GetNumber(style.iconScale, entity, params.tags));
+                if (!iconScale && iconScale != 0) {
+                    iconScale = 1;
+                }
+                const disableDepthTest = Boolean(style.renderOnTop);
+                if (iconScale > 0) {
+                    updateShouldShowTrack();
+                    const bColor = style.iconTintColor ? bruce_models_1.Calculator.GetColor(style.iconTintColor, entity, params.tags) : null;
+                    const cColor = bColor ? (0, cesium_utils_1.ColorToCColor)(bColor) : Cesium.Color.WHITE.clone();
+                    heightRef = getHeightRef(style);
+                    if (!params.rendered || !params.rendered.billboard) {
+                        const animateColorIn = new cesium_animated_property_1.CesiumAnimatedProperty.AnimateColor({
+                            durationMs: 200,
+                            targetColor: cColor,
+                            startColor: cColor.withAlpha(0),
+                            viewer: params.viewer
+                        });
+                        let position = null;
+                        // If we have a series of time-based positions then we'll animate as time changes.
+                        const series = cesium_animated_property_1.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                        if (series.length > 1) {
+                            animatePosition = new cesium_animated_property_1.CesiumAnimatedProperty.AnimatePositionSeries({
+                                posses: series,
+                                viewer: params.viewer
+                            });
+                            position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
+                            position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                        }
+                        else {
+                            position = new Cesium.CallbackProperty(() => entity_utils_1.EntityUtils.GetPos({
+                                viewer: params.viewer,
+                                entity,
+                                recordHeightRef: heightRef,
+                                returnHeightRef: heightRef,
+                                allowRendered: false
+                            }), true);
+                        }
+                        cEntity = new Cesium.Entity({
+                            id: bruce_models_1.ObjectUtils.UId(15),
+                            billboard: {
+                                horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
+                                verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
+                                image: image.canvasDataUri,
+                                heightReference: getHeightRef(style),
+                                scale: iconScale,
+                                disableDepthTestDistance: disableDepthTest ? Number.POSITIVE_INFINITY : undefined,
+                                distanceDisplayCondition: entity_render_engine_1.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance),
+                                color: new Cesium.CallbackProperty(() => {
+                                    const color = animateColorIn.GetColor();
+                                    if (animateColorIn.IsDone() && (cEntity === null || cEntity === void 0 ? void 0 : cEntity.billboard)) {
+                                        cEntity.billboard.color = new Cesium.CallbackProperty(() => color, true);
+                                    }
+                                    return color;
+                                }, false),
+                                // Would be great once we have a setting for this.
+                                // translucencyByDistance: getTranslucencyByDistance(params.minDistance, params.maxDistance),
+                            },
+                            position: position,
+                            show: true
+                        });
+                        cesium_entity_styler_1.CesiumEntityStyler.BakeDefaultColor({
+                            entity: cEntity,
+                            colors: {
+                                "billboard": cColor
+                            },
+                            viewer: params.viewer,
+                            refresh: false
+                        });
+                    }
+                    else {
+                        prepareExistingGraphic(params.rendered, shouldShowTrack ? 1 : 0);
+                        cEntity = params.rendered;
+                        const currentImgKey = cEntity.billboard._billboardImgKey;
+                        if (currentImgKey != iconUrl) {
+                            cEntity.billboard.image = new Cesium.ConstantProperty(image.canvasDataUri);
+                        }
+                        cEntity.billboard.scale = new Cesium.ConstantProperty(iconScale);
+                        cEntity.billboard.heightReference = new Cesium.ConstantProperty(getHeightRef(style));
+                        cEntity.billboard.disableDepthTestDistance = new Cesium.ConstantProperty(disableDepthTest ? Number.POSITIVE_INFINITY : undefined);
+                        cEntity.billboard.distanceDisplayCondition = new Cesium.ConstantProperty(entity_render_engine_1.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
+                        // Unset width/height.
+                        cEntity.billboard.width = undefined;
+                        cEntity.billboard.height = undefined;
+                        const prevPos3d = (0, cesium_utils_1.GetCValue)(params.viewer, cEntity.position);
+                        let prevStartTime = null;
+                        if (cEntity.position && cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
+                            prevStartTime = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"].GetAnimateFromDateTime();
+                        }
+                        // If we have a series of time-based positions then we'll animate as time changes.
+                        const series = cesium_animated_property_1.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                        if (series.length > 1) {
+                            animatePosition = new cesium_animated_property_1.CesiumAnimatedProperty.AnimatePositionSeries({
+                                posses: series,
+                                viewer: params.viewer,
+                                animateFromPos3d: prevPos3d,
+                                animateFromPos3dTimeStart: prevStartTime
+                            });
+                            cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
+                            cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                        }
+                        else {
+                            const pos3d = entity_utils_1.EntityUtils.GetPos({
+                                viewer: params.viewer,
+                                entity,
+                                recordHeightRef: heightRef,
+                                returnHeightRef: heightRef,
+                                allowRendered: false
+                            });
+                            if (!prevPos3d || !Cesium.Cartesian3.equals(prevPos3d, pos3d)) {
+                                animatePosition = new cesium_animated_property_1.CesiumAnimatedProperty.AnimatePosition({
+                                    durationMs: 200,
+                                    targetPos3d: pos3d,
+                                    viewer: params.viewer,
+                                    startPos3d: prevPos3d
+                                });
+                                cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
+                            }
+                        }
+                        // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
+                        cesium_entity_styler_1.CesiumEntityStyler.SetDefaultColor({
+                            color: cColor ? cColor : new Cesium.Color(),
+                            entity: cEntity,
+                            viewer: params.viewer,
+                            override: true,
+                            requestRender: false
+                        });
+                        cEntity.show = true;
+                    }
+                    cEntity.billboard._billboardSize = image.height;
+                    cEntity.billboard._billboardImgKey = iconUrl;
+                }
+            }
+        }
+        if (type == bruce_models_1.Style.EPointType.Cylinder) {
+            const radius = (0, js_utils_1.EnsureNumber)(bruce_models_1.Calculator.GetNumber(style.CylinderRadius, entity, params.tags));
+            if (radius <= 0) {
+                return null;
+            }
+            const bFill = style.CylinderFillColor ? bruce_models_1.Calculator.GetColor(style.CylinderFillColor, entity, params.tags) : null;
+            const cFill = bFill ? (0, cesium_utils_1.ColorToCColor)(bFill) : Cesium.Color.RED;
+            const outline = Boolean(style.CylinderBorderEnabled);
+            let cOutline = null;
+            let outlineWidth = 1;
+            if (outline) {
+                const bOutline = style.CylinderBorderColor ? bruce_models_1.Calculator.GetColor(style.CylinderBorderColor, entity, params.tags) : null;
+                cOutline = bOutline ? (0, cesium_utils_1.ColorToCColor)(bOutline) : Cesium.Color.BLACK;
+                outlineWidth = (0, js_utils_1.EnsureNumber)(bruce_models_1.Calculator.GetNumber(style.CylinderBorderWidth, entity, params.tags), 1);
+            }
+            heightRef = getHeightRef(style);
+            let pos3d = entity_utils_1.EntityUtils.GetPos({
+                viewer: params.viewer,
+                entity,
+                recordHeightRef: heightRef,
+                returnHeightRef: heightRef,
+                allowRendered: false
+            });
+            const extrusion = getCylinderExtrusion(entity, params.tags, heightRef, style.CylinderFillExtrusion);
+            const hasOutline = outline && outlineWidth > 0;
+            const outlineExtrusion = hasOutline ? getCylinderExtrusion(entity, params.tags, heightRef, style.CylinderBorderExtrusion) : null;
+            // If this doesn't have its own extrusion, we must make it match the sibling.
+            // This way they render in a uniform way.
+            if (hasOutline) {
+                if (outlineExtrusion.value == undefined && extrusion.value != undefined) {
+                    outlineExtrusion.exHeightRef = extrusion.exHeightRef;
+                    outlineExtrusion.value = 0;
+                }
+                else if (outlineExtrusion.value != undefined && extrusion.value == undefined) {
+                    extrusion.exHeightRef = outlineExtrusion.exHeightRef;
+                    extrusion.value = 0;
+                }
+            }
+            let classification = Cesium.ClassificationType.TERRAIN;
+            if (style["drapeOver"] == "ALL") {
+                classification = Cesium.ClassificationType.BOTH;
+            }
+            // Height being set will kill classification.
+            // So we want to use it only when we have to (when extruded).
+            let height = undefined;
+            if (heightRef != Cesium.HeightReference.CLAMP_TO_GROUND && extrusion.value != undefined) {
+                height = Cesium.Cartographic.fromCartesian(pos3d).height;
+            }
+            if (!params.rendered || !params.rendered.ellipse) {
+                cEntity = new Cesium.Entity({
+                    id: bruce_models_1.ObjectUtils.UId(15),
+                    ellipse: {
+                        semiMajorAxis: radius,
+                        semiMinorAxis: radius,
+                        material: cFill,
+                        outlineWidth: null,
+                        extrudedHeight: extrusion.value,
+                        heightReference: heightRef,
+                        extrudedHeightReference: extrusion.exHeightRef,
+                        height: height,
+                        zIndex: 1,
+                        classificationType: classification,
+                        distanceDisplayCondition: entity_render_engine_1.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance)
+                    },
+                    position: pos3d === null || pos3d === void 0 ? void 0 : pos3d.clone(),
+                    show: true
+                });
+            }
+            else {
+                prepareExistingGraphic(params.rendered, hasOutline ? 1 : 0);
+                cEntity = params.rendered;
+                const curRadius = (0, cesium_utils_1.GetCValue)(params.viewer, cEntity.ellipse.semiMajorAxis);
+                if (curRadius != radius) {
+                    cEntity.ellipse.semiMajorAxis = new Cesium.ConstantProperty(radius);
+                    cEntity.ellipse.semiMinorAxis = new Cesium.ConstantProperty(radius);
+                }
+                cEntity.ellipse.outlineWidth = undefined;
+                {
+                    const curHeightRef = (0, cesium_utils_1.GetCValue)(params.viewer, cEntity.ellipse.heightReference);
+                    if (curHeightRef != heightRef) {
+                        cEntity.ellipse.heightReference = new Cesium.ConstantProperty(heightRef);
+                    }
+                    const curHeight = (0, cesium_utils_1.GetCValue)(params.viewer, cEntity.ellipse.height);
+                    if (curHeight != height) {
+                        cEntity.ellipse.height = new Cesium.ConstantProperty(height);
+                    }
+                }
+                {
+                    const curExtHeightRef = (0, cesium_utils_1.GetCValue)(params.viewer, cEntity.ellipse.extrudedHeightReference);
+                    if (curExtHeightRef != extrusion.exHeightRef) {
+                        cEntity.ellipse.extrudedHeightReference = new Cesium.ConstantProperty(extrusion.exHeightRef);
+                    }
+                    const curExtHeight = (0, cesium_utils_1.GetCValue)(params.viewer, cEntity.ellipse.extrudedHeight);
+                    if (curExtHeight != extrusion.value) {
+                        cEntity.ellipse.extrudedHeight = new Cesium.ConstantProperty(extrusion.value);
+                    }
+                }
+                cEntity.ellipse.zIndex = new Cesium.ConstantProperty(1);
+                cEntity.ellipse.distanceDisplayCondition = new Cesium.ConstantProperty(entity_render_engine_1.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
+                const curClassification = (0, cesium_utils_1.GetCValue)(params.viewer, cEntity.ellipse.classificationType);
+                if (curClassification != classification) {
+                    cEntity.ellipse.classificationType = new Cesium.ConstantProperty(classification);
+                }
+                cEntity.position = new Cesium.ConstantPositionProperty(pos3d === null || pos3d === void 0 ? void 0 : pos3d.clone());
+                // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
+                // WARNING: ellipse does not support animation (yet?).
+                cesium_entity_styler_1.CesiumEntityStyler.SetDefaultColor({
+                    color: cFill,
+                    entity: cEntity,
+                    viewer: params.viewer,
+                    override: true,
+                    requestRender: false
+                });
+                cEntity.show = true;
+            }
+            if (hasOutline) {
+                // Height being set will kill classification.
+                // So we want to use it only when we have to (when extruded).
+                let outlineHeight = undefined;
+                if (outlineExtrusion.exHeightRef != Cesium.HeightReference.CLAMP_TO_GROUND && outlineExtrusion.value != undefined) {
+                    outlineHeight = Cesium.Cartographic.fromCartesian(pos3d).height;
+                }
+                let outlineEntity = siblings === null || siblings === void 0 ? void 0 : siblings[0];
+                if (outlineEntity && outlineEntity.ellipse) {
+                    const curRadius = (0, cesium_utils_1.GetCValue)(params.viewer, outlineEntity.ellipse.semiMajorAxis);
+                    if (curRadius != radius + outlineWidth) {
+                        outlineEntity.ellipse.semiMajorAxis = new Cesium.ConstantProperty(radius + outlineWidth);
+                        outlineEntity.ellipse.semiMinorAxis = new Cesium.ConstantProperty(radius + outlineWidth);
+                    }
+                    {
+                        const curHeightRef = (0, cesium_utils_1.GetCValue)(params.viewer, outlineEntity.ellipse.heightReference);
+                        if (curHeightRef != heightRef) {
+                            outlineEntity.ellipse.heightReference = new Cesium.ConstantProperty(heightRef);
+                        }
+                        const curHeight = (0, cesium_utils_1.GetCValue)(params.viewer, outlineEntity.ellipse.height);
+                        if (curHeight != outlineHeight) {
+                            outlineEntity.ellipse.height = new Cesium.ConstantProperty(outlineHeight);
+                        }
+                    }
+                    {
+                        const curExtHeightRef = (0, cesium_utils_1.GetCValue)(params.viewer, outlineEntity.ellipse.extrudedHeightReference);
+                        if (curExtHeightRef != outlineExtrusion.exHeightRef) {
+                            outlineEntity.ellipse.extrudedHeightReference = new Cesium.ConstantProperty(outlineExtrusion.exHeightRef);
+                        }
+                        const curExtHeight = (0, cesium_utils_1.GetCValue)(params.viewer, outlineEntity.ellipse.extrudedHeight);
+                        if (curExtHeight != outlineExtrusion.value) {
+                            outlineEntity.ellipse.extrudedHeight = new Cesium.ConstantProperty(outlineExtrusion.value);
+                        }
+                    }
+                    outlineEntity.ellipse.zIndex = new Cesium.ConstantProperty(2);
+                    outlineEntity.ellipse.distanceDisplayCondition = new Cesium.ConstantProperty(entity_render_engine_1.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
+                    const curClassification = (0, cesium_utils_1.GetCValue)(params.viewer, outlineEntity.ellipse.classificationType);
+                    if (curClassification != classification) {
+                        outlineEntity.ellipse.classificationType = new Cesium.ConstantProperty(classification);
+                    }
+                    // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
+                    // WARNING: ellipse does not support animation (yet?).
+                    cesium_entity_styler_1.CesiumEntityStyler.SetDefaultColor({
+                        color: cOutline,
+                        entity: outlineEntity,
+                        viewer: params.viewer,
+                        override: true,
+                        requestRender: false
+                    });
+                    outlineEntity.show = true;
+                }
+                else {
+                    outlineEntity = new Cesium.Entity({
+                        id: bruce_models_1.ObjectUtils.UId(15),
+                        ellipse: {
+                            semiMajorAxis: radius + outlineWidth,
+                            semiMinorAxis: radius + outlineWidth,
+                            material: cOutline,
+                            outlineWidth: undefined,
+                            extrudedHeight: outlineExtrusion.value,
+                            heightReference: heightRef,
+                            extrudedHeightReference: outlineExtrusion.exHeightRef,
+                            height: outlineHeight,
+                            zIndex: 2,
+                            classificationType: classification,
+                            distanceDisplayCondition: entity_render_engine_1.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance)
+                        },
+                        position: pos3d === null || pos3d === void 0 ? void 0 : pos3d.clone()
+                    });
+                }
+                siblings.push(outlineEntity);
+            }
+        }
+        if (!cEntity) {
+            const bColor = style.color ? bruce_models_1.Calculator.GetColor(style.color, entity, params.tags) : null;
+            const cColor = bColor ? (0, cesium_utils_1.ColorToCColor)(bColor) : Cesium.Color.fromCssColorString("rgba(33, 150, 243, 0.8)");
+            let size = style.size ? bruce_models_1.Calculator.GetNumber(style.size, entity, params.tags) : null;
+            if (size == null) {
+                size = 20;
+            }
+            size = (0, js_utils_1.EnsureNumber)(size);
+            if (size <= 0) {
+                return null;
+            }
+            heightRef = getHeightRef(style);
+            const circleBillboard = createCircleBillboard(size, cColor.toCssColorString());
+            const disableDepthTest = Boolean(style.renderOnTop);
+            updateShouldShowTrack();
+            if (!params.rendered || !params.rendered.billboard) {
+                const animateColorIn = new cesium_animated_property_1.CesiumAnimatedProperty.AnimateColor({
+                    durationMs: 200,
+                    targetColor: cColor,
+                    startColor: cColor.withAlpha(0),
+                    viewer: params.viewer
+                });
+                let position = null;
+                // If we have a series of time-based positions then we'll animate as time changes.
+                const series = cesium_animated_property_1.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                if (series.length > 1) {
+                    animatePosition = new cesium_animated_property_1.CesiumAnimatedProperty.AnimatePositionSeries({
+                        posses: series,
+                        viewer: params.viewer
+                    });
+                    position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
+                    position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                }
+                else {
+                    position = new Cesium.CallbackProperty(() => entity_utils_1.EntityUtils.GetPos({
+                        viewer: params.viewer,
+                        entity,
+                        recordHeightRef: heightRef,
+                        returnHeightRef: heightRef,
+                        allowRendered: false
+                    }), true);
+                }
+                cEntity = new Cesium.Entity({
+                    id: bruce_models_1.ObjectUtils.UId(15),
+                    // point: {
+                    //     pixelSize: size,
+                    //     color: cColor,
+                    //     heightReference: getHeightRef(style),
+                    //     distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance)
+                    // },
+                    // We are generating a billboard instead of using the point.
+                    // This is because points were behaving strangely where they would appear oblong shapes.
+                    // This occurred consistently when rendering many icons and points at the same time.
+                    billboard: {
+                        height: circleBillboard.height,
+                        width: circleBillboard.width,
+                        image: circleBillboard.canvasDataUri,
+                        color: new Cesium.CallbackProperty(() => {
+                            const color = animateColorIn.GetColor();
+                            if (animateColorIn.IsDone() && (cEntity === null || cEntity === void 0 ? void 0 : cEntity.billboard)) {
+                                cEntity.billboard.color = new Cesium.CallbackProperty(() => color, true);
+                            }
+                            return color;
+                        }, false),
+                        heightReference: heightRef,
+                        distanceDisplayCondition: entity_render_engine_1.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance),
+                        disableDepthTestDistance: disableDepthTest ? Number.POSITIVE_INFINITY : undefined
+                    },
+                    position: position,
+                    show: true
+                });
+                cesium_entity_styler_1.CesiumEntityStyler.BakeDefaultColor({
+                    entity: cEntity,
+                    viewer: params.viewer,
+                    colors: {
+                        "billboard": cColor
+                    },
+                    refresh: false
+                });
+            }
+            else {
+                prepareExistingGraphic(params.rendered, shouldShowTrack ? 1 : 0);
+                cEntity = params.rendered;
+                const imgKey = `${size}-${cColor.toCssColorString()}`;
+                const currentImgKey = cEntity.billboard._billboardImgKey;
+                if (currentImgKey != imgKey) {
+                    cEntity.billboard.image = new Cesium.ConstantProperty(circleBillboard.canvasDataUri);
+                }
+                cEntity.billboard.height = new Cesium.ConstantProperty(circleBillboard.height);
+                cEntity.billboard.width = new Cesium.ConstantProperty(circleBillboard.width);
+                cEntity.billboard.heightReference = new Cesium.ConstantProperty(heightRef);
+                cEntity.billboard.distanceDisplayCondition = new Cesium.ConstantProperty(entity_render_engine_1.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
+                cEntity.billboard.disableDepthTestDistance = new Cesium.ConstantProperty(disableDepthTest ? Number.POSITIVE_INFINITY : undefined);
+                const prevPos3d = (0, cesium_utils_1.GetCValue)(params.viewer, cEntity.position);
+                let prevStartTime = null;
+                if (cEntity.position && cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
+                    prevStartTime = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"].GetAnimateFromDateTime();
+                }
+                // If we have a series of time-based positions then we'll animate as time changes.
+                const series = cesium_animated_property_1.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                if (series.length > 1) {
+                    animatePosition = new cesium_animated_property_1.CesiumAnimatedProperty.AnimatePositionSeries({
+                        posses: series,
+                        viewer: params.viewer,
+                        animateFromPos3d: prevPos3d,
+                        animateFromPos3dTimeStart: prevStartTime
+                    });
+                    cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
+                    cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                }
+                else {
+                    const pos3d = entity_utils_1.EntityUtils.GetPos({
+                        viewer: params.viewer,
+                        entity,
+                        recordHeightRef: heightRef,
+                        returnHeightRef: heightRef,
+                        allowRendered: false
+                    });
+                    if (!prevPos3d || !Cesium.Cartesian3.equals(prevPos3d, pos3d)) {
+                        animatePosition = new cesium_animated_property_1.CesiumAnimatedProperty.AnimatePosition({
+                            durationMs: 200,
+                            targetPos3d: pos3d,
+                            viewer: params.viewer,
+                            startPos3d: prevPos3d
+                        });
+                        cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
+                    }
+                }
+                // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
+                cesium_entity_styler_1.CesiumEntityStyler.SetDefaultColor({
+                    color: cColor,
+                    entity: cEntity,
+                    viewer: params.viewer,
+                    override: true,
+                    requestRender: false
+                });
+                cEntity.show = true;
+                cEntity.billboard._billboardImgKey = imgKey;
+            }
+            cEntity.billboard._billboardSize = Math.ceil(circleBillboard.height / 2);
+        }
+        // Generate a polyline 'track' for the historic data.
+        // We do this for historic data that exists and is moving.
+        if (shouldShowTrack && animatePosition && animatePosition instanceof cesium_animated_property_1.CesiumAnimatedProperty.AnimatePositionSeries && animatePosition.GetSeries) {
+            const lStyle = (_d = (_c = params.fullStyle) === null || _c === void 0 ? void 0 : _c.polylineStyle) !== null && _d !== void 0 ? _d : {};
+            const bColor = lStyle.lineColor ? bruce_models_1.Calculator.GetColor(lStyle.lineColor, entity, params.tags) : null;
+            const cColor = bColor ? (0, cesium_utils_1.ColorToCColor)(bColor) : Cesium.Color.fromCssColorString("rgba(255, 193, 7, 0.8)");
+            let width = lStyle.lineWidth ? (0, js_utils_1.EnsureNumber)(bruce_models_1.Calculator.GetNumber(lStyle.lineWidth, entity, params.tags)) : 2;
+            if (width == null) {
+                width = 2;
+            }
+            width = (0, js_utils_1.EnsureNumber)(width);
+            const lHeightRef = getHeightRef(lStyle, heightRef);
+            let trackEntity = siblings === null || siblings === void 0 ? void 0 : siblings[0];
+            if (!trackEntity || !trackEntity.polyline) {
+                trackEntity = new Cesium.Entity({
+                    id: bruce_models_1.ObjectUtils.UId(15),
+                    polyline: {
+                        positions: [],
+                        width: width,
+                        material: cColor,
+                        clampToGround: lHeightRef == Cesium.HeightReference.CLAMP_TO_GROUND,
+                        zIndex: 0,
+                        classificationType: Cesium.ClassificationType.BOTH,
+                        show: true
+                    },
+                    position: (0, cesium_utils_1.GetCValue)(params.viewer, cEntity.position),
+                });
+                // Visual was updated in a way that needs a full refresh.
+                if (params.rego) {
+                    params.rego.stale = true;
+                }
+            }
+            trackEntity._parentEntity = null;
+            trackEntity._noEdit = true;
+            trackEntity.polyline.positions = new Cesium.CallbackProperty(() => {
+                return animatePosition.GetSeries();
+            }, false);
+            // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
+            // WARNING: polyline does not support animation (yet?).
+            cesium_entity_styler_1.CesiumEntityStyler.SetDefaultColor({
+                color: cColor,
+                entity: trackEntity,
+                viewer: params.viewer,
+                override: true,
+                requestRender: false
+            });
+            siblings.push(trackEntity);
+            trackEntity._parentEntity = cEntity;
+        }
+        cEntity._siblingGraphics = siblings;
+        return cEntity;
+    }
+    EntityRenderEnginePoint.Render = Render;
+    /**
+     * Renders a group of point Entities.
+     * This will take an optional set of prior rendered Cesium Entities to update rather than create from scratch.
+     * @param params
+     * @returns
+     */
+    async function RenderGroup(params) {
+        var _a, _b, _c, _d, _e;
+        const api = params.apiGetter.getApi();
+        const cEntities = new Map();
+        for (let i = 0; i < params.entities.length; i++) {
+            const entity = params.entities[i];
+            const zoomItem = params.zoomItems[entity.Bruce.ID];
+            const style = zoomItem.StyleID != -1 ? (_a = (await getStyle(api, entity, zoomItem.StyleID))) === null || _a === void 0 ? void 0 : _a.Settings : zoomItem.Style;
+            const tagIds = entity.Bruce["Layer.ID"];
+            let tags = [];
+            if (tagIds && tagIds.length > 0) {
+                tags = (await bruce_models_1.EntityTag.GetListByIds({
+                    api,
+                    tagIds
+                })).tags;
+            }
+            const pStyle = (_b = style === null || style === void 0 ? void 0 : style.pointStyle) !== null && _b !== void 0 ? _b : {};
+            let rego = null;
+            // Only used for historic tracks right now.
+            // So won't bother getting it if we don't have historic data.
+            if ((_c = params.entitiesHistoric) === null || _c === void 0 ? void 0 : _c[entity.Bruce.ID]) {
+                rego = params.visualRegister.GetRego({
+                    entityId: entity.Bruce.ID,
+                    menuItemId: params.menuItemId
+                });
+            }
+            const cEntity = await Render({
+                entity: entity,
+                style: pStyle,
+                tags: tags,
+                viewer: params.viewer,
+                api: api,
+                apiGetter: params.apiGetter,
+                maxDistance: zoomItem.MaxZoom,
+                minDistance: zoomItem.MinZoom,
+                rendered: (_d = params.rendered) === null || _d === void 0 ? void 0 : _d.get(entity.Bruce.ID),
+                entityHistoric: (_e = params.entitiesHistoric) === null || _e === void 0 ? void 0 : _e[entity.Bruce.ID],
+                entityHistoricDrawTrack: params.entityHistoricDrawTrack,
+                fullStyle: style,
+                rego: rego
+            });
+            if (cEntity) {
+                const name = await getName(api, entity);
+                cEntity.name = name;
+                cEntity._renderGroup = entity_render_engine_1.EntityRenderEngine.GetRenderGroupId(zoomItem);
+            }
+            cEntities.set(entity.Bruce.ID, cEntity);
+        }
+        return cEntities;
+    }
+    EntityRenderEnginePoint.RenderGroup = RenderGroup;
+})(EntityRenderEnginePoint = exports.EntityRenderEnginePoint || (exports.EntityRenderEnginePoint = {}));
+// Cache of billboards to avoid regenerating them for the same size and color.
+const _billboardCache = new bruce_models_1.LRUCache(150);
+const POINT_BILLBOARD_PADDING = 1;
+const createCircleBillboard = (size, colorCss) => {
+    const key = size + "-" + colorCss;
+    const cacheData = _billboardCache.Get(key);
+    if ((cacheData === null || cacheData === void 0 ? void 0 : cacheData.canvasDataUri) && typeof (cacheData === null || cacheData === void 0 ? void 0 : cacheData.canvasDataUri) == "string") {
+        return cacheData;
+    }
+    // Slight padding to avoid corners clipping.
+    const canvasSize = size + (POINT_BILLBOARD_PADDING * 4);
+    const canvas = document.createElement("canvas");
+    canvas.width = canvasSize;
+    canvas.height = canvasSize;
+    const context = canvas.getContext("2d");
+    context.beginPath();
+    context.arc(canvasSize / 2, canvasSize / 2, size / 2, 0, 2 * Math.PI, false);
+    context.fillStyle = colorCss;
+    context.fill();
+    const data = {
+        canvasDataUri: canvas.toDataURL("image/png"),
+        colorCss,
+        size,
+        height: canvasSize,
+        width: canvasSize
+    };
+    _billboardCache.Set(key, data);
+    return data;
+};
+const createImageBillboard = (url) => {
+    const cacheKey = "image-" + url;
+    const cacheData = _billboardCache.Get(cacheKey);
+    if (cacheData) {
+        return cacheData;
+    }
+    const prom = new Promise(async (res, rej) => {
+        try {
+            const response = await fetch(url);
+            const blob = await response.blob();
+            const canvas = document.createElement("canvas");
+            const image = new Image();
+            image.onload = () => {
+                canvas.width = image.width;
+                canvas.height = image.height;
+                const context = canvas.getContext("2d");
+                context.drawImage(image, 0, 0);
+                const data = {
+                    canvasDataUri: canvas.toDataURL("image/png"),
+                    height: image.height
+                };
+                res(data);
+            };
+            image.onerror = (e) => {
+                rej(e);
+            };
+            image.src = URL.createObjectURL(blob);
+        }
+        catch (e) {
+            rej(e);
+        }
+    });
+    _billboardCache.Set(cacheKey, prom);
+    return prom;
+};
+/**
+ * Turns a hard-coded file url into pieces so we can properly load it using our libraries rather than directly.
+ * @param url eg: https://demoplantprocess.api.nextspace-uat.net/file/4c29bdf8-1f0b-4739-b0ee-421ea07ba4e5.png
+ */
+function extractMetadataFromFileUrl(url) {
+    var _a;
+    url = url.toLowerCase();
+    // Bzzt, invalid url format for our purposes.
+    if (!url.includes(".api.") || !url.includes("/file/")) {
+        return null;
+    }
+    url = url.replace("https://", "").replace("http://", "");
+    let envId = bruce_models_1.Api.EEnv.PROD;
+    if (url.includes("-dev.net")) {
+        envId = bruce_models_1.Api.EEnv.DEV;
+    }
+    else if (url.includes("-stg.net")) {
+        envId = bruce_models_1.Api.EEnv.STG;
+    }
+    else if (url.includes("-uat.net")) {
+        envId = bruce_models_1.Api.EEnv.UAT;
+    }
+    const parts = url.split("/");
+    const host = parts[0];
+    const hostParts = host.split(".");
+    const accountId = hostParts[0];
+    let fileId = (_a = parts[2]) !== null && _a !== void 0 ? _a : "";
+    if (fileId.includes("?")) {
+        fileId = fileId.split("?")[0];
+    }
+    if (fileId.includes(".")) {
+        fileId = fileId.split(".")[0];
+    }
+    if (!fileId || !accountId) {
+        return null;
+    }
+    return {
+        accountId,
+        fileId: fileId,
+        envId: envId
+    };
+}
+function getHeightRef(style, defaultStyle) {
+    var _a;
+    let heightRef = defaultStyle == null ? Cesium.HeightReference.CLAMP_TO_GROUND : defaultStyle;
+    const altOptionId = (_a = style === null || style === void 0 ? void 0 : style.altitudeOption) === null || _a === void 0 ? void 0 : _a.id;
+    if (altOptionId == 0) {
+        heightRef = Cesium.HeightReference.CLAMP_TO_GROUND;
+    }
+    else if (altOptionId == 1) {
+        heightRef = Cesium.HeightReference.NONE;
+    }
+    else if (altOptionId == 2) {
+        heightRef = Cesium.HeightReference.RELATIVE_TO_GROUND;
+    }
+    return heightRef;
+}
+function getCylinderStyleExtrusion(style, entity, tags, heightRef) {
+    if (!style) {
+        return null;
+    }
+    try {
+        const extrusion = +bruce_models_1.Calculator.GetNumber(style, entity, tags);
+        if (!extrusion && extrusion != 0) {
+            return null;
+        }
+        /*
+            Cesium extrudes in strange way.
+            If you want something that is 50 meters above sea, and 5 meters tall,
+            You need to extrude by 55 meters, if you extrude by 5 it will extrude from sea and look flat.
+        */
+        const height = (0, js_utils_1.EnsureNumber)(bruce_models_1.Entity.GetValue({
+            entity: entity,
+            path: ["Bruce", "Location", "altitude"]
+        }), 0);
+        return heightRef != Cesium.HeightReference.CLAMP_TO_GROUND ? extrusion + height : extrusion;
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return 0;
+}
+function getCylinderExtrusion(entity, tags, heightRef, style) {
+    const data = {
+        value: undefined,
+        exHeightRef: heightRef == Cesium.HeightReference.CLAMP_TO_GROUND ? Cesium.HeightReference.RELATIVE_TO_GROUND : heightRef
+    };
+    const extrusion = getCylinderStyleExtrusion(style, entity, tags, heightRef);
+    if (extrusion) {
+        data.value = extrusion;
+    }
+    if (data.value != undefined) {
+        data.value = (0, js_utils_1.EnsureNumber)(data.value);
+    }
+    return data;
+}
+async function getName(api, entity) {
+    try {
+        const typeId = entity.Bruce["EntityType.ID"];
+        let type = null;
+        if (typeId) {
+            type = (await bruce_models_1.EntityType.Get({
+                api,
+                entityTypeId: typeId
+            })).entityType;
+        }
+        if (type) {
+            const name = bruce_models_1.Entity.CalculateName({
+                entity,
+                type,
+                defaultToId: false
+            });
+            return name ? name : "Unnamed Entity";
+        }
+    }
+    catch (e) {
+        let hideError = false;
+        // TODO: we need a util for extracting code + message rather than writing all this every time.
+        if (e && typeof e == "object" && e.ERROR) {
+            const error = e.ERROR;
+            const code = error && typeof error == "object" ? error.Code : "";
+            // Avoiding logging a common error.
+            // This happens when rendering entities that don't have records.
+            hideError = String(code).toLowerCase() == "notfound";
+        }
+        if (!hideError) {
+            console.error(e);
+        }
+    }
+    return "Unknown entity";
+}
+async function getStyle(api, entity, styleId) {
+    let style = null;
+    if (styleId && styleId != -1) {
+        try {
+            style = (await bruce_models_1.Style.Get({
+                api,
+                styleId
+            })).style;
+        }
+        // Probably deleted.
+        catch (e) {
+            console.error(e);
+        }
+    }
+    if (!style) {
+        const typeId = entity.Bruce["EntityType.ID"];
+        if (typeId) {
+            try {
+                const { entityType: type } = await bruce_models_1.EntityType.Get({
+                    api,
+                    entityTypeId: typeId
+                });
+                if (type["DisplaySetting.ID"]) {
+                    try {
+                        style = (await bruce_models_1.Style.Get({
+                            api,
+                            styleId: type["DisplaySetting.ID"]
+                        })).style;
+                    }
+                    catch (e) {
+                        let hideError = false;
+                        // TODO: we need a util for extracting code + message rather than writing all this every time.
+                        if (e && typeof e == "object" && e.ERROR) {
+                            const error = e.ERROR;
+                            const code = error && typeof error == "object" ? error.Code : "";
+                            // Avoiding logging a common error.
+                            // This happens when rendering entities that don't have records.
+                            hideError = String(code).toLowerCase() == "notfound";
+                        }
+                        if (!hideError) {
+                            console.error(e);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                let hideError = false;
+                // TODO: we need a util for extracting code + message rather than writing all this every time.
+                if (e && typeof e == "object" && e.ERROR) {
+                    const error = e.ERROR;
+                    const code = error && typeof error == "object" ? error.Code : "";
+                    // Avoiding logging a common error.
+                    // This happens when rendering entities that don't have records.
+                    hideError = String(code).toLowerCase() == "notfound";
+                }
+                if (!hideError) {
+                    console.error(e);
+                }
+            }
+        }
+    }
+    return style;
+}
+//# sourceMappingURL=entity-render-engine-point.js.map