bruce-cesium 6.9.2 → 6.9.4

package/dist/bruce-cesium.umd.js

@@ -36557,7 +36557,7 @@
     }
 
     (function (EntityRenderEnginePolygon) {
-        function Render(params) {
+        async function Render(params) {
             var _a, _b;
             const entity = params.entity;
             const pRings = BModels.Entity.GetValue({
@@ -36568,9 +36568,26 @@
                 return null;
             }
             const style = params.style;
+            const fillType = style.fillType || BModels.Style.EPolygonFillType.Color;
             const fillColorTrace = style.fillColor ? BModels.Calculator.TraceGetColor(style.fillColor, entity, params.tags) : { value: null, effective: null };
             const bFillColor = fillColorTrace.value;
             const cFillColor = bFillColor ? ColorToCColor(bFillColor) : Cesium.Color.fromCssColorString("rgba(139, 195, 74, 0.8)");
+            let textureDataUri = null;
+            let textureTraceEffective = null;
+            if (fillType === BModels.Style.EPolygonFillType.Texture) {
+                const resolved = await resolveTexturedFill({
+                    api: params.api,
+                    style,
+                    entity,
+                    tags: params.tags
+                });
+                textureDataUri = resolved.dataUri;
+                textureTraceEffective = resolved.effective;
+            }
+            const hasFill = fillType === BModels.Style.EPolygonFillType.Texture ? Boolean(textureDataUri) : cFillColor.alpha > 0;
+            const fillMaterial = textureDataUri
+                ? new Cesium.ImageMaterialProperty({ image: textureDataUri, transparent: true })
+                : cFillColor;
             const lineColorTrace = style.lineColor ? BModels.Calculator.TraceGetColor(style.lineColor, entity, params.tags) : { value: null, effective: null };
             const bLineColor = lineColorTrace.value;
             const cLineColor = bLineColor ? ColorToCColor(bLineColor) : Cesium.Color.fromCssColorString("rgba(80, 80, 80, 0.8)");
@@ -36589,7 +36606,7 @@
             }
             // If both outline and fill is not available then don't render anything.
             if ((width <= 0 || cLineColor.alpha <= 0) &&
-                cFillColor.alpha <= 0) {
+                !hasFill) {
                 return null;
             }
             let heightRef = getHeightRef$3(style);
@@ -36644,7 +36661,7 @@
                     id: BModels.ObjectUtils.UId(15),
                     polygon: {
                         hierarchy: new Cesium.PolygonHierarchy(posses, holePosses.map(x => new Cesium.PolygonHierarchy(x))),
-                        material: cFillColor,
+                        material: fillMaterial,
                         extrudedHeight: extrusion.value,
                         extrudedHeightReference: extrusion.exHeightRef,
                         shadows: Cesium.ShadowMode.ENABLED,
@@ -36709,15 +36726,21 @@
                 cEntity.polygon.distanceDisplayCondition = new Cesium.ConstantProperty(exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width <= 0 || !cLineColor || units == "m" ? size : null, true));
                 cEntity.polygon.shadows = new Cesium.ConstantProperty(Cesium.ShadowMode.ENABLED);
                 cEntity.polygon.classificationType = new Cesium.ConstantProperty(classification);
-                // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
-                // WARNING: polygon does not support animation (yet?).
-                exports.CesiumEntityStyler.SetDefaultColor({
-                    color: cFillColor,
-                    entity: cEntity,
-                    viewer: params.viewer,
-                    override: true,
-                    requestRender: false
-                });
+                // TODO: animate the texture!
+                if (textureDataUri) {
+                    cEntity.polygon.material = fillMaterial;
+                }
+                else {
+                    // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
+                    // WARNING: polygon does not support animation (yet?).
+                    exports.CesiumEntityStyler.SetDefaultColor({
+                        color: cFillColor,
+                        entity: cEntity,
+                        viewer: params.viewer,
+                        override: true,
+                        requestRender: false
+                    });
+                }
                 cEntity.show = true;
             }
             if (hasOutline) {
@@ -36865,6 +36888,7 @@
             }
             cEntity.styleEffective = exports.StyleEffective.Combine([
                 { key: "color", effective: fillColorTrace.effective },
+                { key: "texture", effective: textureTraceEffective },
                 { key: "lineColor", effective: lineColorTrace.effective },
                 { key: "lineWidth", effective: lineWidthTrace.effective }
             ]);
@@ -36916,11 +36940,12 @@
                     }
                 }
                 const pStyle = (_b = style === null || style === void 0 ? void 0 : style.polygonStyle) !== null && _b !== void 0 ? _b : {};
-                const cEntity = Render({
+                const cEntity = await Render({
                     entity: entity,
                     style: pStyle,
                     tags: tags,
                     viewer: params.viewer,
+                    api,
                     maxDistance: zoomItem.MaxZoom,
                     minDistance: zoomItem.MinZoom,
                     // Temporarily disabling re-using graphics for polygons as they have some bugs, and
@@ -37038,6 +37063,101 @@
         }
         return style;
     }
+    // Cache of tinted texture data URIs, keyed by resolved url + color mask, so repeated renders of the
+    // same polygon (or multiple polygons sharing a texture) don't refetch/reprocess the same image.
+    const _textureCache = new BModels.LRUCache(50);
+    /**
+     * Returns if a resolved texture value looks like a URL rather than a client file ID.
+     * @param value
+     */
+    function looksLikeTextureUrl(value) {
+        return /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value) || value.startsWith("//") || value.startsWith("data:");
+    }
+    /**
+     * Resolves a polygon style's texture field and if a color ask is needed it tints the resulting image.
+     * @param params
+     */
+    async function resolveTexturedFill(params) {
+        const { api, style, entity, tags } = params;
+        let textureRows = style.texture == null ? [] : style.texture;
+        textureRows.forEach((row) => {
+            if (row.type == BModels.Calculator.EValueType.Color) {
+                row.type = BModels.Calculator.EValueType.Input;
+            }
+        });
+        const textureTrace = textureRows.length ? BModels.Calculator.TraceGetString(textureRows, entity, tags) : { value: null, effective: null };
+        const raw = textureTrace.value;
+        if (!raw || typeof raw != "string" || !api) {
+            return { dataUri: null, effective: textureTrace.effective };
+        }
+        let url = raw;
+        if (!looksLikeTextureUrl(raw)) {
+            await api.Loading;
+            url = BModels.ClientFile.GetUrl({
+                api,
+                fileId: raw,
+                viaCdn: true
+            });
+        }
+        const mask = style.textureColorMask;
+        const cacheKey = "texture-" + url + "-" + (mask ? mask.type + "-" + mask.minColor + "-" + mask.maxColor : "none");
+        let prom = _textureCache.Get(cacheKey);
+        if (!prom) {
+            prom = buildTintedTextureDataUri(url, mask).catch(() => null);
+            _textureCache.Set(cacheKey, prom);
+        }
+        return { dataUri: await prom, effective: textureTrace.effective };
+    }
+    /**
+     * Fetches an image and, if a color mask is provided, remaps its (assumed grayscale) pixel values
+     * into a gradient between the mask's minColor/maxColor, preserving source alpha.
+     * @param url
+     * @param mask
+     */
+    async function buildTintedTextureDataUri(url, mask) {
+        const response = await fetch(url);
+        const blob = await response.blob();
+        const objectUrl = URL.createObjectURL(blob);
+        let image;
+        try {
+            image = await loadImage(objectUrl);
+        }
+        finally {
+            URL.revokeObjectURL(objectUrl);
+        }
+        const canvas = document.createElement("canvas");
+        canvas.width = image.width;
+        canvas.height = image.height;
+        const context = canvas.getContext("2d");
+        context.drawImage(image, 0, 0);
+        if (mask && mask.type === BModels.Style.ETextureColorMaskType.BlackWhite) {
+            const minColor = BModels.Color.ColorFromStr(mask.minColor) || { red: 0, green: 0, blue: 0, alpha: 1 };
+            const maxColor = BModels.Color.ColorFromStr(mask.maxColor) || { red: 255, green: 255, blue: 255, alpha: 1 };
+            const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
+            const data = imageData.data;
+            for (let i = 0; i < data.length; i += 4) {
+                // The texture is rendered black-to-white server-side, so any channel carries the value.
+                const t = data[i] / 255;
+                data[i] = Math.round(minColor.red + (maxColor.red - minColor.red) * t);
+                data[i + 1] = Math.round(minColor.green + (maxColor.green - minColor.green) * t);
+                data[i + 2] = Math.round(minColor.blue + (maxColor.blue - minColor.blue) * t);
+                // Preserve source transparency (eg unrasterized pixels) blended with the mask's own alpha.
+                const srcAlpha = data[i + 3] / 255;
+                const maskAlpha = minColor.alpha + (maxColor.alpha - minColor.alpha) * t;
+                data[i + 3] = Math.round(srcAlpha * maskAlpha * 255);
+            }
+            context.putImageData(imageData, 0, 0);
+        }
+        return canvas.toDataURL("image/png");
+    }
+    function loadImage(src) {
+        return new Promise((res, rej) => {
+            const image = new Image();
+            image.onload = () => res(image);
+            image.onerror = (e) => rej(e);
+            image.src = src;
+        });
+    }
     /**
      * Compares two color materials.
      * Returns if they are equal.
@@ -38323,7 +38443,7 @@
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "6.9.2";
+    const VERSION = "6.9.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.