@ztgkzhaohao/geo-effect-kit 0.1.0

package/dist/index.js

@@ -0,0 +1,4089 @@
+import { BoundingSphere, BillboardGraphics, CallbackPositionProperty, CallbackProperty, Cartesian2, Cartesian3, Cartesian4, CircleGeometry, Color, ColorMaterialProperty, ConstantPositionProperty, ConstantProperty, CustomDataSource, EllipsoidSurfaceAppearance, Event, GeometryInstance, GroundPrimitive, HeadingPitchRoll, HeadingPitchRange, HeightReference, HorizontalOrigin, Material, Math as CesiumMath, PointGraphics, PolylineGlowMaterialProperty, PolygonGeometry, PolygonHierarchy, PostProcessStage, Primitive, Rectangle, Transforms, VerticalOrigin, } from 'cesium';
+import { decompressFrames, parseGIF } from 'gifuct-js';
+export const GEO_RADAR_SCAN_MATERIAL_TYPE = 'GeoRadarScanMaterial';
+export const GEO_RIPPLE_SPREAD_MATERIAL_TYPE = 'GeoRippleSpreadMaterial';
+export const GEO_LIGHT_WALL_MATERIAL_TYPE = 'GeoLightWallMaterial';
+export const GEO_SCAN_CONE_MATERIAL_TYPE = 'GeoScanConeMaterial';
+export const GEO_SHIELD_DOME_MATERIAL_TYPE = 'GeoShieldDomeMaterial';
+export const GEO_TEMPERATURE_FIELD_MATERIAL_TYPE = 'GeoTemperatureFieldMaterial';
+export const GEO_WATER_SURFACE_MATERIAL_TYPE = 'GeoWaterSurfaceMaterial';
+export const RADAR_SCAN_TYPE_VALUES = ['classic', 'sector', 'pulse', 'grid'];
+export const RIPPLE_SPREAD_TYPE_VALUES = ['water', 'energy', 'soft'];
+export const SCENE_WEATHER_TYPE_VALUES = ['rain', 'snow', 'fog', 'lightning'];
+export const POST_PROCESS_TYPE_VALUES = ['bloom', 'night-vision', 'black-white', 'brightness', 'mosaic', 'depth-of-field'];
+export const POLYLINE_FLOW_TYPE_VALUES = ['dispatch', 'migration', 'attack', 'comet', 'electric'];
+export const FLY_LINE_MODE_VALUES = ['single-arc', 'hub-spoke', 'bidirectional'];
+export const LIGHT_WALL_TYPE_VALUES = ['security', 'warning', 'data', 'fence', 'pulse'];
+export const SCAN_CONE_TYPE_VALUES = ['searchlight', 'radar', 'camera', 'drone', 'alarm'];
+export const SHIELD_DOME_TYPE_VALUES = ['hex', 'plasma', 'matrix', 'aegis', 'storm'];
+export const WATER_SURFACE_TYPE_VALUES = ['river', 'lake', 'flood'];
+export function createRadarScanEffect(viewer, options) {
+    return new RadarScanEffect(viewer, options);
+}
+export function createRippleSpreadEffect(viewer, options) {
+    return new RippleSpreadEffect(viewer, options);
+}
+export function createSceneWeatherEffect(viewer, options = {}) {
+    return new SceneWeatherEffect(viewer, options);
+}
+export function createPostProcessEffect(viewer, options = {}) {
+    return new PostProcessEffect(viewer, options);
+}
+export function createPolylineFlowEffect(viewer, options) {
+    return new PolylineFlowEffect(viewer, options);
+}
+export function createFlyLineEffect(viewer, options) {
+    return new FlyLineEffect(viewer, options);
+}
+export function createPipeFlowEffect(viewer, options) {
+    return new PipeFlowEffect(viewer, options);
+}
+export function createLightWallEffect(viewer, options) {
+    return new LightWallEffect(viewer, options);
+}
+export function createScanConeEffect(viewer, options) {
+    return new ScanConeEffect(viewer, options);
+}
+export function createShieldDomeEffect(viewer, options) {
+    return new ShieldDomeEffect(viewer, options);
+}
+export function createTemperatureFieldEffect(viewer, options) {
+    return new TemperatureFieldEffect(viewer, options);
+}
+export function createFireBillboardEffect(viewer, options) {
+    return new FireBillboardEffect(viewer, options);
+}
+export function createWaterSurfaceEffect(viewer, options) {
+    return new WaterSurfaceEffect(viewer, options);
+}
+export function normalizeRadarScanOptions(options) {
+    return {
+        center: {
+            longitude: finiteOr(options.center.longitude, 0),
+            latitude: finiteOr(options.center.latitude, 0),
+        },
+        radiusMeters: Math.max(1, finiteOr(options.radiusMeters, 1)),
+        type: normalizeRadarScanType(options.type),
+        color: options.color ?? '#36d6ff',
+        scanDurationMs: Math.max(1, finiteOr(options.scanDurationMs ?? 3600, 3600)),
+        opacity: clamp01(finiteOr(options.opacity ?? 0.85, 0.85)),
+        rings: options.rings ?? true,
+        showCenter: options.showCenter ?? false,
+        visible: options.visible ?? true,
+    };
+}
+export function normalizeRippleSpreadOptions(options) {
+    return {
+        center: {
+            longitude: finiteOr(options.center.longitude, 0),
+            latitude: finiteOr(options.center.latitude, 0),
+        },
+        radiusMeters: Math.max(1, finiteOr(options.radiusMeters, 1)),
+        type: normalizeRippleSpreadType(options.type),
+        color: options.color ?? '#62e8ff',
+        ringCount: clampInteger(finiteOr(options.ringCount ?? 4, 4), 1, 12),
+        durationMs: Math.max(1, finiteOr(options.durationMs ?? 3200, 3200)),
+        opacity: clamp01(finiteOr(options.opacity ?? 0.82, 0.82)),
+        showCenter: options.showCenter ?? false,
+        visible: options.visible ?? true,
+    };
+}
+export function normalizeSceneWeatherOptions(options = {}) {
+    const color = options.color && options.color.trim().length > 0 ? options.color : '#d8f3ff';
+    return {
+        type: normalizeSceneWeatherType(options.type),
+        intensity: clamp01(finiteOr(options.intensity ?? 0.55, 0.55)),
+        speed: clamp(finiteOr(options.speed ?? 1, 1), 0.05, 8),
+        windDirection: finiteOr(options.windDirection ?? 115, 115),
+        color,
+        visible: options.visible ?? true,
+    };
+}
+export function normalizePostProcessOptions(options = {}) {
+    return {
+        type: normalizePostProcessType(options.type),
+        strength: clamp01(finiteOr(options.strength ?? 0.65, 0.65)),
+        brightness: clamp(finiteOr(options.brightness ?? 1, 1), 0, 3),
+        contrast: clamp(finiteOr(options.contrast ?? 1, 1), 0, 3),
+        saturation: clamp(finiteOr(options.saturation ?? 1, 1), 0, 3),
+        visible: options.visible ?? true,
+    };
+}
+export function normalizePolylineFlowOptions(options) {
+    return {
+        positions: normalizePositions(options.positions, false),
+        type: normalizePolylineFlowType(options.type),
+        color: options.color ?? '#33f7ff',
+        speed: clamp(finiteOr(options.speed ?? 1, 1), 0.05, 8),
+        width: Math.max(1, finiteOr(options.width ?? 6, 6)),
+        trailLength: clamp(finiteOr(options.trailLength ?? 0.32, 0.32), 0.02, 0.95),
+        pulseCount: clampInteger(finiteOr(options.pulseCount ?? 3, 3), 1, 12),
+        cornerRadius: clamp(finiteOr(options.cornerRadius ?? 0, 0), 0, 0.45),
+        glowPower: clamp(finiteOr(options.glowPower ?? 0.22, 0.22), 0, 1),
+        taperPower: clamp(finiteOr(options.taperPower ?? 0.72, 0.72), 0, 1),
+        clampToGround: options.clampToGround ?? true,
+        visible: options.visible ?? true,
+    };
+}
+export function normalizeFlyLineOptions(options) {
+    return {
+        lines: normalizeFlyLineRoutes(options.lines),
+        mode: normalizeFlyLineMode(options.mode),
+        color: options.color ?? '#5ee8ff',
+        speed: clamp(finiteOr(options.speed ?? 1, 1), 0.05, 8),
+        width: Math.max(1, finiteOr(options.width ?? 4, 4)),
+        arcHeight: Math.max(0, finiteOr(options.arcHeight ?? 38000, 38000)),
+        trailLength: clamp(finiteOr(options.trailLength ?? 0.28, 0.28), 0.02, 0.95),
+        pulseCount: clampInteger(finiteOr(options.pulseCount ?? 3, 3), 1, 12),
+        glowPower: clamp(finiteOr(options.glowPower ?? 0.26, 0.26), 0, 1),
+        taperPower: clamp(finiteOr(options.taperPower ?? 0.62, 0.62), 0, 1),
+        showEndpoints: options.showEndpoints ?? true,
+        visible: options.visible ?? true,
+    };
+}
+export function normalizePipeFlowOptions(options) {
+    return {
+        positions: normalizePositions(options.positions, false),
+        color: options.color ?? '#45dfff',
+        speed: clamp(finiteOr(options.speed ?? 1, 1), 0.05, 8),
+        width: Math.max(1, finiteOr(options.width ?? 12, 12)),
+        pipeOpacity: clamp01(finiteOr(options.pipeOpacity ?? 0.32, 0.32)),
+        waterOpacity: clamp01(finiteOr(options.waterOpacity ?? 0.86, 0.86)),
+        cornerRadius: clamp(finiteOr(options.cornerRadius ?? 0.18, 0.18), 0, 0.45),
+        bubbleDensity: clampInteger(finiteOr(options.bubbleDensity ?? 6, 6), 0, 16),
+        clampToGround: options.clampToGround ?? true,
+        visible: options.visible ?? true,
+    };
+}
+export function normalizeLightWallOptions(options) {
+    return {
+        positions: normalizePositions(options.positions, true),
+        type: normalizeLightWallType(options.type),
+        color: options.color ?? '#27f5ff',
+        height: Math.max(1, finiteOr(options.height ?? 3200, 3200)),
+        speed: clamp(finiteOr(options.speed ?? 1, 1), 0.05, 8),
+        opacity: clamp01(finiteOr(options.opacity ?? 0.72, 0.72)),
+        scanLineCount: clampInteger(finiteOr(options.scanLineCount ?? 4, 4), 1, 16),
+        breathing: options.breathing ?? true,
+        outline: options.outline ?? true,
+        visible: options.visible ?? true,
+    };
+}
+export function normalizeScanConeOptions(options) {
+    return {
+        center: normalizePosition(options.center),
+        type: normalizeScanConeType(options.type),
+        color: options.color ?? '#7cf7ff',
+        radiusMeters: Math.max(1, finiteOr(options.radiusMeters ?? 1800, 1800)),
+        lengthMeters: Math.max(1, finiteOr(options.lengthMeters ?? 4800, 4800)),
+        speed: clamp(finiteOr(options.speed ?? 1, 1), 0.05, 8),
+        opacity: clamp01(finiteOr(options.opacity ?? 0.62, 0.62)),
+        aperture: clamp(finiteOr(options.aperture ?? 34, 34), 8, 120),
+        heading: finiteOr(options.heading ?? 0, 0),
+        pitch: finiteOr(options.pitch ?? 0, 0),
+        showOrigin: options.showOrigin ?? true,
+        visible: options.visible ?? true,
+    };
+}
+export function normalizeShieldDomeOptions(options) {
+    return {
+        center: normalizePosition(options.center),
+        radiusMeters: Math.max(1, finiteOr(options.radiusMeters, 1)),
+        type: normalizeShieldDomeType(options.type),
+        color: options.color ?? '#57f7ff',
+        speed: clamp(finiteOr(options.speed ?? 1, 1), 0.05, 8),
+        opacity: clamp01(finiteOr(options.opacity ?? 0.56, 0.56)),
+        gridDensity: clampInteger(finiteOr(options.gridDensity ?? 14, 14), 2, 40),
+        pulseStrength: clamp01(finiteOr(options.pulseStrength ?? 0.72, 0.72)),
+        ring: options.ring ?? true,
+        visible: options.visible ?? true,
+    };
+}
+export function normalizeTemperatureFieldOptions(options) {
+    const polygons = normalizeTemperatureFieldPolygons(options.polygons);
+    const bounds = normalizeTemperatureFieldBounds(options.bounds) ?? getTemperatureFieldBounds(polygons);
+    return {
+        polygons,
+        stops: normalizeTemperatureFieldStops(options.stops),
+        samples: normalizeTemperatureFieldSamples(options.samples),
+        seed: normalizeSeed(options.seed),
+        opacity: clamp01(finiteOr(options.opacity ?? 0.76, 0.76)),
+        bounds,
+        noiseStrength: clamp01(finiteOr(options.noiseStrength ?? 0.42, 0.42)),
+        contourLines: options.contourLines ?? true,
+        contourStrength: clamp01(finiteOr(options.contourStrength ?? 0.18, 0.18)),
+        outline: options.outline ?? true,
+        outlineColor: options.outlineColor ?? '#dff8ff',
+        outlineWidth: Math.max(1, finiteOr(options.outlineWidth ?? 5, 5)),
+        visible: options.visible ?? true,
+    };
+}
+export function normalizeFireBillboardOptions(options) {
+    return {
+        points: normalizeFireBillboardPoints(options.points),
+        scale: clamp(finiteOr(options.scale ?? 1, 1), 0.1, 8),
+        frameIntervalMs: clamp(finiteOr(options.frameIntervalMs ?? 80, 80), 16, 2000),
+        clampToGround: options.clampToGround ?? true,
+        disableDepthTestDistance: Math.max(0, finiteOr(options.disableDepthTestDistance ?? Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY)),
+        visible: options.visible ?? true,
+    };
+}
+export function normalizeWaterSurfaceOptions(options) {
+    const color = options.color && options.color.trim().length > 0 ? options.color : '#3de7ff';
+    return {
+        polygon: normalizePositions(options.polygon, true),
+        type: normalizeWaterSurfaceType(options.type),
+        color,
+        height: Math.max(0, finiteOr(options.height ?? 0, 0)),
+        speed: clamp(finiteOr(options.speed ?? 1, 1), 0.05, 8),
+        opacity: clamp01(finiteOr(options.opacity ?? 0.72, 0.72)),
+        waveStrength: clamp01(finiteOr(options.waveStrength ?? 0.48, 0.48)),
+        reflectionStrength: clamp01(finiteOr(options.reflectionStrength ?? 0.36, 0.36)),
+        distortionScale: clamp(finiteOr(options.distortionScale ?? 18, 18), 0, 64),
+        reflectivity: clamp01(finiteOr(options.reflectivity ?? 0.58, 0.58)),
+        refractionStrength: clamp01(finiteOr(options.refractionStrength ?? 0.42, 0.42)),
+        fresnelPower: clamp(finiteOr(options.fresnelPower ?? 4, 4), 1, 12),
+        flowDirection: finiteOr(options.flowDirection ?? 90, 90),
+        outline: options.outline ?? true,
+        visible: options.visible ?? true,
+    };
+}
+export function shouldRebuildRadarScan(previous, next) {
+    return (previous.radiusMeters !== next.radiusMeters ||
+        previous.center.longitude !== next.center.longitude ||
+        previous.center.latitude !== next.center.latitude);
+}
+export function shouldRebuildRippleSpread(previous, next) {
+    return (previous.radiusMeters !== next.radiusMeters ||
+        previous.center.longitude !== next.center.longitude ||
+        previous.center.latitude !== next.center.latitude);
+}
+export function shouldRebuildPolylineFlow(previous, next) {
+    return (previous.clampToGround !== next.clampToGround ||
+        previous.cornerRadius !== next.cornerRadius ||
+        previous.positions.length !== next.positions.length ||
+        !positionsEqual(previous.positions, next.positions));
+}
+export function shouldRebuildFlyLine(previous, next) {
+    return (previous.mode !== next.mode ||
+        previous.arcHeight !== next.arcHeight ||
+        previous.lines.length !== next.lines.length ||
+        !flyLineRoutesEqual(previous.lines, next.lines));
+}
+export function shouldRebuildPipeFlow(previous, next) {
+    return (previous.clampToGround !== next.clampToGround ||
+        previous.cornerRadius !== next.cornerRadius ||
+        previous.bubbleDensity !== next.bubbleDensity ||
+        previous.positions.length !== next.positions.length ||
+        !positionsEqual(previous.positions, next.positions));
+}
+export function shouldRebuildLightWall(previous, next) {
+    return (previous.height !== next.height ||
+        previous.positions.length !== next.positions.length ||
+        !positionsEqual(previous.positions, next.positions));
+}
+export function shouldRebuildScanCone(previous, next) {
+    return (previous.radiusMeters !== next.radiusMeters ||
+        previous.lengthMeters !== next.lengthMeters ||
+        previous.aperture !== next.aperture ||
+        !positionsEqual([previous.center], [next.center]));
+}
+export function shouldRebuildShieldDome(previous, next) {
+    return previous.radiusMeters !== next.radiusMeters || !positionsEqual([previous.center], [next.center]);
+}
+export function shouldRebuildTemperatureField(previous, next) {
+    return !temperatureFieldPolygonsEqual(previous.polygons, next.polygons);
+}
+export function shouldRebuildFireBillboard(previous, next) {
+    return (previous.clampToGround !== next.clampToGround ||
+        previous.points.length !== next.points.length ||
+        !fireBillboardPointsEqual(previous.points, next.points));
+}
+export function shouldRebuildWaterSurface(previous, next) {
+    return (previous.height !== next.height ||
+        previous.outline !== next.outline ||
+        previous.polygon.length !== next.polygon.length ||
+        !positionsEqual(previous.polygon, next.polygon));
+}
+export function buildPolylineFlowSegmentWeights(segmentCount, type = 'dispatch', progress = 0) {
+    const count = clampInteger(finiteOr(segmentCount, 0), 0, 128);
+    if (count <= 0)
+        return [];
+    const normalizedType = normalizePolylineFlowType(type);
+    const head = fract(finiteOr(progress, 0)) * Math.max(1, count - 1);
+    const profile = getPolylineFlowProfile(normalizedType);
+    return Array.from({ length: count }, (_, index) => {
+        const distance = Math.abs(index - head);
+        const wrappedDistance = Math.min(distance, count - distance);
+        const weight = 1 - wrappedDistance / Math.max(1, profile.tail);
+        return roundWeight(clamp01(weight) ** profile.power);
+    });
+}
+export function buildRadarScanMaterialSource(_options) {
+    return `
+    // ${GEO_RADAR_SCAN_MATERIAL_TYPE}
+    czm_material czm_getMaterial(czm_materialInput materialInput)
+    {
+      czm_material material = czm_getDefaultMaterial(materialInput);
+      vec2 st = materialInput.st;
+      vec2 radarCenter = vec2(0.5);
+      vec2 vectorToPixel = st - radarCenter;
+      float d = distance(st, radarCenter);
+      float inside = smoothstep(0.5, 0.495, d);
+      float outerRing = ringsEnabled * smoothstep(0.018, 0.0, abs(d - 0.49));
+      float middleRing = ringsEnabled * smoothstep(0.008, 0.0, abs(d - 0.33)) * 0.16;
+      float innerRing = ringsEnabled * smoothstep(0.008, 0.0, abs(d - 0.18)) * 0.18;
+      float scanAngle = fract((czm_frameNumber * 16.6667) / scanDurationMs) * 6.28318530718;
+      vec2 scanDirection = vec2(cos(scanAngle), sin(scanAngle));
+      vec2 pixelDirection = normalize(vectorToPixel + vec2(0.00001));
+      float directionMatch = dot(pixelDirection, scanDirection);
+      float radialFade = smoothstep(0.06, 0.18, d) * (1.0 - smoothstep(0.35, 0.5, d));
+      float classicEnabled = 1.0 - step(1.5, radarType);
+      float sectorEnabled = step(1.5, radarType) * (1.0 - step(2.5, radarType));
+      float pulseEnabled = step(2.5, radarType) * (1.0 - step(3.5, radarType));
+      float gridEnabled = step(3.5, radarType);
+      float classicScan = smoothstep(0.36, 0.98, directionMatch) * radialFade * inside;
+      float classicLine = smoothstep(0.955, 1.0, directionMatch) * radialFade * inside;
+      float sectorScan = smoothstep(0.06, 0.92, directionMatch) * radialFade * inside;
+      float sectorEdge = (smoothstep(0.84, 1.0, directionMatch) + smoothstep(0.08, 0.0, abs(directionMatch - 0.12))) * radialFade * inside;
+      float pulseScan = pow(max(directionMatch, 0.0), 16.0) * radialFade * inside;
+      float pulseHead = smoothstep(0.975, 1.0, directionMatch) * radialFade * inside;
+      float pulseWake = smoothstep(0.28, 0.95, directionMatch) * radialFade * inside * (1.0 - smoothstep(0.42, 0.5, d));
+      float gridLineX = smoothstep(0.0035, 0.0, abs(fract(st.x * 12.0) - 0.5));
+      float gridLineY = smoothstep(0.0035, 0.0, abs(fract(st.y * 12.0) - 0.5));
+      float gridMask = (gridLineX + gridLineY) * radialFade * inside * smoothstep(0.28, 0.98, directionMatch);
+      float gridScan = max(gridMask * 0.42, classicLine * 0.85);
+      float scanTail = classicScan * classicEnabled + sectorScan * sectorEnabled + pulseWake * pulseEnabled + gridScan * gridEnabled;
+      float sweepLine = classicLine * classicEnabled + sectorEdge * sectorEnabled + pulseHead * pulseEnabled + classicLine * gridEnabled;
+      float centerGlow = smoothstep(0.065, 0.0, d) * (1.0 + pulseEnabled * 0.45 + gridEnabled * 0.18);
+      float crossLine = (smoothstep(0.003, 0.0, abs(st.x - 0.5)) + smoothstep(0.003, 0.0, abs(st.y - 0.5))) * (0.1 + gridEnabled * 0.2);
+      vec3 sectorTint = mix(color.rgb, vec3(0.7, 1.0, 0.32), 0.26);
+      vec3 pulseTint = mix(color.rgb, vec3(1.0, 0.26, 0.88), 0.36);
+      vec3 gridTint = mix(color.rgb, vec3(0.42, 0.72, 1.0), 0.28);
+      vec3 styleColor = color.rgb * classicEnabled + sectorTint * sectorEnabled + pulseTint * pulseEnabled + gridTint * gridEnabled;
+      float bodyGlow = sectorEnabled * sectorScan * 0.1 + pulseEnabled * pulseScan * 0.18 + gridEnabled * gridMask * 0.08;
+      material.diffuse = styleColor * (0.34 + scanTail * 0.42 + outerRing * 0.32 + bodyGlow);
+      material.emission = styleColor * (scanTail * 0.55 + sweepLine * (0.72 + pulseEnabled * 0.45) + outerRing * 0.8 + centerGlow * 0.45 + bodyGlow * 1.6);
+      material.alpha = opacity * (inside * 0.08 + scanTail * 0.28 + sweepLine * (0.18 + sectorEnabled * 0.14 + pulseEnabled * 0.2) + outerRing * 0.56 + middleRing + innerRing + centerGlow * 0.18 + crossLine + bodyGlow);
+      return material;
+    }
+  `;
+}
+export function buildRippleSpreadMaterialSource() {
+    return `
+    // ${GEO_RIPPLE_SPREAD_MATERIAL_TYPE}
+    czm_material czm_getMaterial(czm_materialInput materialInput)
+    {
+      czm_material material = czm_getDefaultMaterial(materialInput);
+      vec2 st = materialInput.st;
+      vec2 center = vec2(0.5);
+      float d = distance(st, center);
+      float inside = smoothstep(0.5, 0.495, d);
+      float time = fract((czm_frameNumber * 16.6667) / durationMs);
+      float safeRingCount = max(ringCount, 1.0);
+      float waterRipple = 0.0;
+      float energyRipple = 0.0;
+      float softRipple = 0.0;
+
+      for (int i = 0; i < 12; i++) {
+        float index = float(i);
+        float enabled = step(index + 0.5, safeRingCount);
+        float progress = fract(time - index / safeRingCount + 1.0);
+        float rippleRadius = progress * 0.49;
+        float edgeFade = smoothstep(0.025, 0.13, rippleRadius) * (1.0 - smoothstep(0.39, 0.5, rippleRadius));
+        float waterLine = smoothstep(0.026, 0.0, abs(d - rippleRadius)) * edgeFade;
+        float energyLine = smoothstep(0.011, 0.0, abs(d - rippleRadius)) * edgeFade;
+        float softLine = smoothstep(0.045, 0.0, abs(d - rippleRadius)) * edgeFade;
+        waterRipple += enabled * waterLine * (1.0 - progress * 0.34);
+        energyRipple += enabled * energyLine * (1.24 - progress * 0.18);
+        softRipple += enabled * softLine * (0.78 - progress * 0.22);
+      }
+
+      float energyEnabled = step(1.5, rippleType) * (1.0 - step(2.5, rippleType));
+      float softEnabled = step(2.5, rippleType);
+      float waterEnabled = 1.0 - energyEnabled - softEnabled;
+      float rippleStrength = waterRipple * waterEnabled + energyRipple * energyEnabled + softRipple * softEnabled;
+      float centerGlow = smoothstep(0.07, 0.0, d) * (0.42 + energyEnabled * 0.58);
+      float outerGlow = smoothstep(0.5, 0.26, d) * inside * (0.04 + softEnabled * 0.05);
+      float shimmer = sin((d * 82.0) - (time * 6.28318530718)) * 0.018 * waterEnabled * inside;
+      vec3 energyTint = mix(color.rgb, vec3(1.0, 0.24, 0.86), 0.42);
+      vec3 softTint = mix(color.rgb, vec3(0.72, 0.94, 1.0), 0.28);
+      vec3 styleColor = color.rgb * waterEnabled + energyTint * energyEnabled + softTint * softEnabled;
+      material.diffuse = styleColor * (0.24 + rippleStrength * 0.3 + outerGlow);
+      material.emission = styleColor * (rippleStrength * (0.56 + energyEnabled * 0.42) + centerGlow * 0.48);
+      material.alpha = opacity * (inside * (0.035 + softEnabled * 0.04) + shimmer + rippleStrength * (0.35 + energyEnabled * 0.24) + centerGlow * 0.18 + outerGlow);
+      return material;
+    }
+  `;
+}
+export function buildSceneWeatherPostProcessSource() {
+    return `
+    uniform sampler2D colorTexture;
+    uniform float weatherType;
+    uniform float intensity;
+    uniform float speed;
+    uniform float windDirection;
+    uniform vec4 color;
+    in vec2 v_textureCoordinates;
+
+    float geoWeatherHash(vec2 p)
+    {
+      return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+    }
+
+    float geoWeatherNoise(vec2 p)
+    {
+      vec2 i = floor(p);
+      vec2 f = fract(p);
+      float a = geoWeatherHash(i);
+      float b = geoWeatherHash(i + vec2(1.0, 0.0));
+      float c = geoWeatherHash(i + vec2(0.0, 1.0));
+      float d = geoWeatherHash(i + vec2(1.0, 1.0));
+      vec2 u = f * f * (3.0 - 2.0 * f);
+      return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
+    }
+
+    void main()
+    {
+      vec4 sceneColor = texture(colorTexture, v_textureCoordinates);
+      vec2 st = v_textureCoordinates;
+      float time = czm_frameNumber * 0.016667 * speed;
+      float angle = radians(windDirection);
+      vec2 wind = vec2(cos(angle), sin(angle));
+      float rainEnabled = 1.0 - step(1.5, weatherType);
+      float snowEnabled = step(1.5, weatherType) * (1.0 - step(2.5, weatherType));
+      float fogEnabled = step(2.5, weatherType) * (1.0 - step(3.5, weatherType));
+      float lightningEnabled = step(3.5, weatherType);
+
+      vec2 rainUv = st * vec2(36.0, 1.8) + wind * time * 1.65;
+      float rainLine = smoothstep(0.965, 1.0, fract(rainUv.x + rainUv.y * 0.24));
+      rainLine *= smoothstep(0.14, 1.0, geoWeatherHash(vec2(floor(rainUv.x), floor(rainUv.y * 8.0))));
+
+      vec2 snowUv = st * 18.0 + vec2(wind.x * 0.28, -1.0) * time * 0.32;
+      float snowCell = geoWeatherNoise(snowUv);
+      float snowFlake = smoothstep(0.82, 1.0, snowCell) * (0.55 + 0.45 * geoWeatherNoise(snowUv * 0.47));
+
+      float fogNoise = geoWeatherNoise(st * 4.0 + vec2(time * 0.04, time * 0.02));
+      float fogGradient = smoothstep(0.02, 0.98, st.y);
+      float fog = (0.45 + fogNoise * 0.55) * fogGradient;
+
+      float flash = pow(max(sin(time * 2.7), 0.0), 18.0) * geoWeatherNoise(vec2(floor(time * 0.7), 7.3));
+      float bolt = smoothstep(0.018, 0.0, abs(st.x - (0.28 + geoWeatherNoise(vec2(floor(time), 2.0)) * 0.46 + sin(st.y * 34.0) * 0.025)));
+      bolt *= smoothstep(0.95, 0.35, st.y) * flash;
+
+      vec3 weatherColor = color.rgb;
+      vec3 rainColor = mix(sceneColor.rgb, weatherColor, rainLine * intensity * 0.48);
+      vec3 snowColor = mix(sceneColor.rgb, weatherColor, snowFlake * intensity * 0.58);
+      vec3 fogColor = mix(sceneColor.rgb, weatherColor, fog * intensity * 0.72);
+      vec3 lightningColor = sceneColor.rgb + weatherColor * (bolt * 1.8 + flash * 0.18) * intensity;
+      vec3 mixed = sceneColor.rgb;
+      mixed = mix(mixed, rainColor, rainEnabled);
+      mixed = mix(mixed, snowColor, snowEnabled);
+      mixed = mix(mixed, fogColor, fogEnabled);
+      mixed = mix(mixed, lightningColor, lightningEnabled);
+      out_FragColor = vec4(mixed, sceneColor.a);
+    }
+  `;
+}
+export function buildPostProcessSource() {
+    return `
+    uniform sampler2D colorTexture;
+    uniform float effectType;
+    uniform float strength;
+    uniform float brightness;
+    uniform float contrast;
+    uniform float saturation;
+    in vec2 v_textureCoordinates;
+
+    void main()
+    {
+      vec4 sceneColor = texture(colorTexture, v_textureCoordinates);
+      vec2 st = v_textureCoordinates;
+      vec3 colorValue = sceneColor.rgb;
+      float bloomEnabled = 1.0 - step(1.5, effectType);
+      float nightEnabled = step(1.5, effectType) * (1.0 - step(2.5, effectType));
+      float blackWhiteEnabled = step(2.5, effectType) * (1.0 - step(3.5, effectType));
+      float brightnessEnabled = step(3.5, effectType) * (1.0 - step(4.5, effectType));
+      float mosaicEnabled = step(4.5, effectType) * (1.0 - step(5.5, effectType));
+      float depthEnabled = step(5.5, effectType);
+
+      float luminance = dot(colorValue, vec3(0.299, 0.587, 0.114));
+      vec3 bloomColor = colorValue + max(colorValue - vec3(0.62), vec3(0.0)) * strength * 1.35;
+      vec3 nightColor = vec3(luminance * 0.18, luminance * 1.22, luminance * 0.34) * (0.72 + strength);
+      vec3 grayColor = vec3(luminance);
+      vec3 brightColor = (colorValue - 0.5) * contrast + 0.5;
+      brightColor = mix(vec3(dot(brightColor, vec3(0.299, 0.587, 0.114))), brightColor, saturation) * brightness;
+
+      vec2 mosaicUv = (floor(st * mix(96.0, 24.0, strength)) + 0.5) / mix(96.0, 24.0, strength);
+      vec3 mosaicColor = texture(colorTexture, mosaicUv).rgb;
+      float distanceFromFocus = distance(st, vec2(0.5));
+      vec3 depthColor = mix(colorValue, texture(colorTexture, mix(st, vec2(0.5), 0.018 + strength * 0.04)).rgb, smoothstep(0.2, 0.72, distanceFromFocus));
+
+      vec3 result = colorValue;
+      result = mix(result, bloomColor, bloomEnabled);
+      result = mix(result, nightColor, nightEnabled);
+      result = mix(result, grayColor, blackWhiteEnabled * strength);
+      result = mix(result, brightColor, brightnessEnabled);
+      result = mix(result, mosaicColor, mosaicEnabled);
+      result = mix(result, depthColor, depthEnabled);
+      out_FragColor = vec4(result, sceneColor.a);
+    }
+  `;
+}
+export function buildTemperatureFieldMaterialSource() {
+    return `
+    // ${GEO_TEMPERATURE_FIELD_MATERIAL_TYPE}
+    float temperatureHash(vec2 p)
+    {
+      p = fract(p * vec2(123.34, 456.21));
+      p += dot(p, p + 45.32);
+      return fract(p.x * p.y);
+    }
+
+    float temperatureNoise(vec2 p)
+    {
+      vec2 i = floor(p);
+      vec2 f = fract(p);
+      float a = temperatureHash(i);
+      float b = temperatureHash(i + vec2(1.0, 0.0));
+      float c = temperatureHash(i + vec2(0.0, 1.0));
+      float d = temperatureHash(i + vec2(1.0, 1.0));
+      vec2 u = f * f * (3.0 - 2.0 * f);
+      return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
+    }
+
+    vec3 temperatureRamp(float value)
+    {
+      vec3 c0 = lowColor.rgb;
+      vec3 c1 = lowerColor.rgb;
+      vec3 c2 = mediumColor.rgb;
+      vec3 c3 = higherColor.rgb;
+      vec3 c4 = highColor.rgb;
+      vec3 first = mix(c0, c1, smoothstep(0.0, 0.25, value));
+      vec3 second = mix(c1, c2, smoothstep(0.18, 0.5, value));
+      vec3 third = mix(c2, c3, smoothstep(0.42, 0.72, value));
+      vec3 fourth = mix(c3, c4, smoothstep(0.64, 1.0, value));
+      return mix(mix(first, second, smoothstep(0.18, 0.38, value)), mix(third, fourth, smoothstep(0.58, 0.82, value)), smoothstep(0.42, 0.64, value));
+    }
+
+    float randomBlob(vec2 st, vec2 center, float radius)
+    {
+      vec2 offset = st - center;
+      float distanceSquared = dot(offset, offset);
+      return exp(-distanceSquared / max(0.0001, radius));
+    }
+
+    float randomField(vec2 st)
+    {
+      vec2 randomCenter0 = vec2(0.18 + temperatureHash(seedVector.xy + vec2(0.11, 0.31)) * 0.64, 0.14 + temperatureHash(seedVector.zw + vec2(0.29, 0.07)) * 0.7);
+      vec2 randomCenter1 = vec2(0.18 + temperatureHash(seedVector.yz + vec2(0.43, 0.17)) * 0.64, 0.14 + temperatureHash(seedVector.wx + vec2(0.19, 0.53)) * 0.7);
+      vec2 randomCenter2 = vec2(0.18 + temperatureHash(seedVector.zx + vec2(0.73, 0.23)) * 0.64, 0.14 + temperatureHash(seedVector.yw + vec2(0.61, 0.37)) * 0.7);
+      vec2 randomCenter3 = vec2(0.18 + temperatureHash(seedVector.xw + vec2(0.13, 0.79)) * 0.64, 0.14 + temperatureHash(seedVector.zy + vec2(0.47, 0.41)) * 0.7);
+      vec2 randomCenter4 = vec2(0.18 + temperatureHash(seedVector.yy + vec2(0.89, 0.67)) * 0.64, 0.14 + temperatureHash(seedVector.xx + vec2(0.31, 0.83)) * 0.7);
+      vec2 randomCenter5 = vec2(0.18 + temperatureHash(seedVector.ww + vec2(0.57, 0.97)) * 0.64, 0.14 + temperatureHash(seedVector.zz + vec2(0.71, 0.59)) * 0.7);
+      float value = 0.0;
+      value += randomBlob(st, randomCenter0, 0.11 + temperatureHash(randomCenter0) * 0.1) * (0.55 + temperatureHash(randomCenter0.yx) * 0.45);
+      value += randomBlob(st, randomCenter1, 0.08 + temperatureHash(randomCenter1) * 0.09) * (0.42 + temperatureHash(randomCenter1.yx) * 0.45);
+      value += randomBlob(st, randomCenter2, 0.1 + temperatureHash(randomCenter2) * 0.08) * (0.38 + temperatureHash(randomCenter2.yx) * 0.4);
+      value -= randomBlob(st, randomCenter3, 0.12 + temperatureHash(randomCenter3) * 0.08) * (0.22 + temperatureHash(randomCenter3.yx) * 0.28);
+      value -= randomBlob(st, randomCenter4, 0.08 + temperatureHash(randomCenter4) * 0.08) * (0.18 + temperatureHash(randomCenter4.yx) * 0.2);
+      value += randomBlob(st, randomCenter5, 0.07 + temperatureHash(randomCenter5) * 0.06) * (0.18 + temperatureHash(randomCenter5.yx) * 0.22);
+      return value;
+    }
+
+    float sampleInfluence(vec2 st, vec4 samplePoint)
+    {
+      vec2 offset = st - samplePoint.xy;
+      float distanceSquared = dot(offset, offset);
+      float radius = 0.006 + samplePoint.w * 0.038;
+      return exp(-distanceSquared / radius);
+    }
+
+    float sampleContribution(vec2 st, vec4 samplePoint, float index, inout float weight)
+    {
+      float enabled = step(index + 0.5, sampleCount);
+      float influence = sampleInfluence(st, samplePoint) * enabled;
+      weight += influence;
+      return samplePoint.z * influence;
+    }
+
+    float sampleField(vec2 st)
+    {
+      float weight = 0.0;
+      float value = 0.0;
+      value += sampleContribution(st, sample0, 0.0, weight);
+      value += sampleContribution(st, sample1, 1.0, weight);
+      value += sampleContribution(st, sample2, 2.0, weight);
+      value += sampleContribution(st, sample3, 3.0, weight);
+      value += sampleContribution(st, sample4, 4.0, weight);
+      value += sampleContribution(st, sample5, 5.0, weight);
+      value += sampleContribution(st, sample6, 6.0, weight);
+      value += sampleContribution(st, sample7, 7.0, weight);
+      value += sampleContribution(st, sample8, 8.0, weight);
+      value += sampleContribution(st, sample9, 9.0, weight);
+      value += sampleContribution(st, sample10, 10.0, weight);
+      value += sampleContribution(st, sample11, 11.0, weight);
+      value += sampleContribution(st, sample12, 12.0, weight);
+      value += sampleContribution(st, sample13, 13.0, weight);
+      value += sampleContribution(st, sample14, 14.0, weight);
+      value += sampleContribution(st, sample15, 15.0, weight);
+      float base = 0.26 + randomField(st) * 0.12;
+      return mix(base, value / max(weight, 0.0001), smoothstep(0.01, 0.22, weight));
+    }
+
+    float riskField(vec2 st)
+    {
+      float broadNoise = temperatureNoise(st * 3.0 + seedVector.zw * 5.0);
+      float detailNoise = temperatureNoise(st * 9.0 + seedVector.wx * 7.0);
+      float hotSpot0 = exp(-dot(st - hotSpot0Center, st - hotSpot0Center) / max(0.0001, hotSpot0Radius));
+      float hotSpot1 = exp(-dot(st - hotSpot1Center, st - hotSpot1Center) / max(0.0001, hotSpot1Radius));
+      float coldSpot0 = exp(-dot(st - coldSpot0Center, st - coldSpot0Center) / max(0.0001, coldSpot0Radius));
+      float randomTemperature = 0.28 + randomField(st) * 0.56 + (broadNoise - 0.5) * 0.34 * noiseStrength + (detailNoise - 0.5) * 0.14 * noiseStrength;
+      randomTemperature += hotSpot0 * hotSpot0Strength + hotSpot1 * hotSpot1Strength;
+      randomTemperature -= coldSpot0 * coldSpot0Strength;
+      float sampleTexture = (broadNoise - 0.5) * 0.08 * noiseStrength + (detailNoise - 0.5) * 0.04 * noiseStrength;
+      float sampleTemperature = sampleField(st) + sampleTexture;
+      float hasSamples = step(0.5, sampleCount);
+      float value = mix(randomTemperature, sampleTemperature, hasSamples);
+      return clamp(value, 0.0, 1.0);
+    }
+
+    czm_material czm_getMaterial(czm_materialInput materialInput)
+    {
+      czm_material material = czm_getDefaultMaterial(materialInput);
+      vec2 st = materialInput.st;
+      float value = riskField(st);
+      vec3 ramp = temperatureRamp(value);
+      float contour = smoothstep(0.03, 0.0, abs(fract(value * 8.0) - 0.5)) * contourStrength * contourLines;
+      float edgeFade = smoothstep(0.0, 0.035, st.x) * smoothstep(0.0, 0.035, st.y) * smoothstep(0.0, 0.035, 1.0 - st.x) * smoothstep(0.0, 0.035, 1.0 - st.y);
+      vec3 veil = mix(ramp, vec3(1.0, 0.96, 0.72), 0.08);
+      material.diffuse = veil * (0.82 + contour * 0.18);
+      material.emission = ramp * (0.12 + value * 0.16) + vec3(1.0, 0.88, 0.45) * contour * 0.12;
+      material.alpha = opacity * edgeFade * (0.52 + value * 0.24 + contour * 0.14);
+      return material;
+    }
+  `;
+}
+export function buildWaterSurfaceMaterialSource() {
+    return `
+    // ${GEO_WATER_SURFACE_MATERIAL_TYPE}
+    float waterHash(vec2 p)
+    {
+      return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+    }
+
+    float waterNoise(vec2 p)
+    {
+      vec2 i = floor(p);
+      vec2 f = fract(p);
+      vec2 u = f * f * (3.0 - 2.0 * f);
+      float a = waterHash(i);
+      float b = waterHash(i + vec2(1.0, 0.0));
+      float c = waterHash(i + vec2(0.0, 1.0));
+      float d = waterHash(i + vec2(1.0, 1.0));
+      return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+    }
+
+    float waterHeight(vec2 uv, vec2 flow, float time)
+    {
+      vec2 crossFlow = vec2(-flow.y, flow.x);
+      float layerA = sin(dot(uv + flow * time * 0.055, flow) * 62.0 + time * 1.7);
+      float layerB = sin(dot(uv - crossFlow * time * 0.04, crossFlow) * 84.0 - time * 1.15);
+      float layerC = waterNoise(uv * 18.0 + flow * time * 1.4) * 2.0 - 1.0;
+      return layerA * 0.42 + layerB * 0.34 + layerC * 0.24;
+    }
+
+    vec3 getProceduralWaterNormal(vec2 uv, vec2 flow, float time, float strength)
+    {
+      float sampleStep = 0.006;
+      float center = waterHeight(uv, flow, time);
+      float dx = waterHeight(uv + vec2(sampleStep, 0.0), flow, time) - center;
+      float dy = waterHeight(uv + vec2(0.0, sampleStep), flow, time) - center;
+      return normalize(vec3(-dx * strength, -dy * strength, 1.0));
+    }
+
+    czm_material czm_getMaterial(czm_materialInput materialInput)
+    {
+      czm_material material = czm_getDefaultMaterial(materialInput);
+      vec2 st = materialInput.st;
+      float time = czm_frameNumber * 0.016667 * speed;
+      float direction = radians(flowDirection);
+      vec2 flow = vec2(cos(direction), sin(direction));
+      vec2 crossFlow = vec2(-flow.y, flow.x);
+      vec2 distortion = (flow * sin(dot(st, crossFlow) * 18.0 + time * 0.8) + crossFlow * sin(dot(st, flow) * 22.0 - time * 0.65)) * distortionScale * 0.00085;
+      vec2 moving = st + flow * time * 0.06 + distortion;
+      vec3 surfaceNormal = getProceduralWaterNormal(moving * (1.0 + waveStrength * 1.8), flow, time, mix(8.0, 28.0, waveStrength));
+      float waveA = waterHeight(moving * 1.8, flow, time) * 0.5 + 0.5;
+      float waveB = waterHeight(moving.yx * 2.2 + vec2(0.17, 0.31), crossFlow, time * 0.82) * 0.5 + 0.5;
+      float smallWave = clamp(dot(surfaceNormal.xy, vec2(0.72, -0.48)) * 0.5 + 0.5, 0.0, 1.0);
+      float riverEnabled = 1.0 - step(1.5, waterType);
+      float lakeEnabled = step(1.5, waterType) * (1.0 - step(2.5, waterType));
+      float floodEnabled = step(2.5, waterType);
+      float riverFlow = smoothstep(0.38, 1.0, waterNoise(moving * 9.0 + flow * time * 0.55)) * waveA;
+      float lakeShimmer = pow(waveA * waveB, 2.0);
+      float floodPulse = smoothstep(0.08, 0.0, abs(fract(distance(st, vec2(0.5)) * 4.0 - time * 0.45) - 0.5));
+      float riverWave = mix(waveA, max(riverFlow, waveB * 0.72), 0.45);
+      float wave = mix(waveA, max(riverWave, lakeShimmer), waveStrength);
+      wave = max(wave, floodPulse * floodEnabled);
+      vec3 viewDirection = normalize(materialInput.positionToEyeEC);
+      float viewFacing = clamp(1.0 - abs(dot(normalize(materialInput.normalEC), -viewDirection)), 0.0, 1.0);
+      float fresnel = pow(viewFacing, fresnelPower) * reflectivity;
+      float reflection = (0.18 + smallWave * 0.82) * reflectionStrength;
+      vec3 riverTint = mix(color.rgb, vec3(0.18, 0.72, 1.0), 0.24);
+      vec3 lakeTint = mix(color.rgb, vec3(0.36, 0.92, 0.86), 0.22);
+      vec3 floodTint = mix(color.rgb, vec3(0.42, 0.68, 1.0), 0.36);
+      vec3 waterColor = riverTint * riverEnabled + lakeTint * lakeEnabled + floodTint * floodEnabled;
+      vec3 deepColor = mix(waterColor, vec3(0.015, 0.11, 0.18), 0.46);
+      vec3 refractionColor = mix(deepColor, waterColor, 0.42 + wave * 0.34);
+      refractionColor += vec3(0.02, 0.12, 0.16) * refractionStrength * (0.5 + waveB * 0.5);
+      vec3 skyReflection = mix(vec3(0.58, 0.86, 1.0), vec3(1.0), pow(smallWave, 5.0));
+      vec3 reflectionColor = skyReflection * (0.32 + reflection * 0.78);
+      vec3 finalColor = mix(refractionColor, reflectionColor, clamp(fresnel + reflection * 0.24, 0.0, 1.0));
+      float foam = smoothstep(0.68, 1.0, wave) * smoothstep(0.38, 1.0, waveStrength);
+      finalColor = mix(finalColor, vec3(0.82, 0.98, 1.0), foam * 0.18);
+      material.normal = surfaceNormal;
+      material.diffuse = finalColor * (0.56 + wave * 0.18);
+      material.emission = reflectionColor * (0.14 + fresnel * 0.42) + waterColor * ((riverFlow * 0.08 + waveB * 0.06) * riverEnabled + floodPulse * floodEnabled * 0.22);
+      material.alpha = opacity * (0.62 + wave * 0.12 + fresnel * 0.2 + refractionStrength * 0.06);
+      return material;
+    }
+  `;
+}
+export function buildLightWallMaterialSource() {
+    return `
+    // ${GEO_LIGHT_WALL_MATERIAL_TYPE}
+    czm_material czm_getMaterial(czm_materialInput materialInput)
+    {
+      czm_material material = czm_getDefaultMaterial(materialInput);
+      vec2 st = materialInput.st;
+      float time = fract((czm_frameNumber * 0.016667 * speed));
+      float verticalFade = smoothstep(0.0, 0.12, st.t) * (1.0 - smoothstep(0.88, 1.0, st.t));
+      float flowLine = smoothstep(0.035, 0.0, abs(fract(st.t * 3.0 - time) - 0.5));
+      float scanLine = smoothstep(0.018, 0.0, abs(fract(st.t * scanLineCount - time * 1.8) - 0.5));
+      float breath = mix(1.0, 0.58 + 0.42 * sin(time * 6.28318530718), breathing);
+      float verticalStripe = smoothstep(0.012, 0.0, abs(fract(st.s * 18.0 + time * 0.6) - 0.5));
+      float spark = smoothstep(0.02, 0.0, abs(fract((st.s + st.t) * 12.0 - time * 2.2) - 0.5));
+      float securityEnabled = 1.0 - step(1.5, wallType);
+      float warningEnabled = step(1.5, wallType) * (1.0 - step(2.5, wallType));
+      float dataEnabled = step(2.5, wallType) * (1.0 - step(3.5, wallType));
+      float fenceEnabled = step(3.5, wallType) * (1.0 - step(4.5, wallType));
+      float pulseEnabled = step(4.5, wallType);
+      float securityWall = flowLine * 0.72 + scanLine * 0.42;
+      float warningWall = max(scanLine * 0.95, step(0.5, fract(st.s * 10.0 + st.t * 4.0 - time)) * 0.12);
+      float dataWall = verticalStripe * 0.55 + spark * 0.75 + scanLine * 0.24;
+      float fenceWall = max(verticalStripe, smoothstep(0.01, 0.0, abs(fract(st.t * 8.0) - 0.5))) * 0.54;
+      float pulseWall = flowLine * 1.05 + smoothstep(0.2, 0.0, abs(st.t - time)) * 0.82;
+      float style = securityWall * securityEnabled + warningWall * warningEnabled + dataWall * dataEnabled + fenceWall * fenceEnabled + pulseWall * pulseEnabled;
+      vec3 warningTint = mix(color.rgb, vec3(1.0, 0.48, 0.1), 0.44);
+      vec3 dataTint = mix(color.rgb, vec3(0.36, 0.74, 1.0), 0.38);
+      vec3 fenceTint = mix(color.rgb, vec3(0.74, 1.0, 0.42), 0.3);
+      vec3 pulseTint = mix(color.rgb, vec3(1.0, 0.18, 0.72), 0.42);
+      vec3 styleColor = color.rgb * securityEnabled + warningTint * warningEnabled + dataTint * dataEnabled + fenceTint * fenceEnabled + pulseTint * pulseEnabled;
+      float rim = smoothstep(0.025, 0.0, min(st.t, 1.0 - st.t));
+      material.diffuse = styleColor * (0.16 + verticalFade * 0.18 + style * 0.24);
+      material.emission = styleColor * (style * (0.9 + pulseEnabled * 0.45) + rim * 0.48) * breath;
+      material.alpha = opacity * (0.12 * verticalFade + style * 0.62 + rim * 0.42) * breath;
+      return material;
+    }
+  `;
+}
+export function buildScanConeMaterialSource() {
+    return `
+    // ${GEO_SCAN_CONE_MATERIAL_TYPE}
+    czm_material czm_getMaterial(czm_materialInput materialInput)
+    {
+      czm_material material = czm_getDefaultMaterial(materialInput);
+      vec2 st = materialInput.st;
+      vec2 centered = st - vec2(0.5);
+      float radius = length(centered) * 2.0;
+      float angle = atan(centered.y, centered.x) / 6.28318530718 + 0.5;
+      float time = fract((czm_frameNumber * 0.016667 * speed));
+      float verticalFade = smoothstep(0.0, 0.12, st.t) * (1.0 - smoothstep(0.92, 1.0, st.t));
+      float sweepBand = smoothstep(0.08, 0.0, abs(fract(angle - time) - 0.5));
+      float radialGrid = smoothstep(0.012, 0.0, abs(fract(radius * 7.0 - time * 2.0) - 0.5));
+      float verticalGrid = smoothstep(0.01, 0.0, abs(fract(st.t * 9.0 + time) - 0.5));
+      float searchlightEnabled = 1.0 - step(1.5, coneType);
+      float radarEnabled = step(1.5, coneType) * (1.0 - step(2.5, coneType));
+      float cameraEnabled = step(2.5, coneType) * (1.0 - step(3.5, coneType));
+      float droneEnabled = step(3.5, coneType) * (1.0 - step(4.5, coneType));
+      float alarmEnabled = step(4.5, coneType);
+      float searchlightCone = smoothstep(0.82, 0.0, radius) * (0.32 + sweepBand * 0.8);
+      float radarCone = radialGrid * 0.55 + sweepBand * 0.82 + verticalGrid * 0.2;
+      float cameraCone = smoothstep(0.025, 0.0, abs(centered.x)) * 0.42 + sweepBand * 0.62;
+      float droneCone = (radialGrid + verticalGrid) * 0.35 + smoothstep(0.05, 0.0, abs(radius - 0.72)) * 0.7;
+      float alarmCone = max(sweepBand, smoothstep(0.018, 0.0, abs(fract(angle * 12.0 + time * 4.0) - 0.5))) * 0.95;
+      float style = searchlightCone * searchlightEnabled + radarCone * radarEnabled + cameraCone * cameraEnabled + droneCone * droneEnabled + alarmCone * alarmEnabled;
+      vec3 radarTint = mix(color.rgb, vec3(0.35, 1.0, 0.46), 0.32);
+      vec3 cameraTint = mix(color.rgb, vec3(0.42, 0.68, 1.0), 0.3);
+      vec3 droneTint = mix(color.rgb, vec3(0.8, 0.55, 1.0), 0.36);
+      vec3 alarmTint = mix(color.rgb, vec3(1.0, 0.12, 0.26), 0.46);
+      vec3 styleColor = color.rgb * searchlightEnabled + radarTint * radarEnabled + cameraTint * cameraEnabled + droneTint * droneEnabled + alarmTint * alarmEnabled;
+      float edge = smoothstep(0.05, 0.0, abs(radius - 1.0));
+      material.diffuse = styleColor * (0.12 + style * 0.2);
+      material.emission = styleColor * (style * 1.15 + edge * 0.54) * verticalFade;
+      material.alpha = opacity * verticalFade * (0.08 + style * 0.62 + edge * 0.36);
+      return material;
+    }
+  `;
+}
+export function buildShieldDomeMaterialSource() {
+    return `
+    // ${GEO_SHIELD_DOME_MATERIAL_TYPE}
+    czm_material czm_getMaterial(czm_materialInput materialInput)
+    {
+      czm_material material = czm_getDefaultMaterial(materialInput);
+      vec2 st = materialInput.st;
+      float time = fract((czm_frameNumber * 0.016667 * speed));
+      float lat = st.t;
+      float lon = st.s;
+      float domeFade = smoothstep(0.02, 0.16, lat) * (1.0 - smoothstep(0.92, 1.0, lat));
+      float gridLine = max(
+        smoothstep(0.012, 0.0, abs(fract(lon * gridDensity + lat * 0.5) - 0.5)),
+        smoothstep(0.012, 0.0, abs(fract(lat * gridDensity * 0.55) - 0.5))
+      );
+      float scanLine = smoothstep(0.035, 0.0, abs(fract(lat * 1.2 - time) - 0.5));
+      float energyPulse = smoothstep(0.08, 0.0, abs(fract(distance(st, vec2(0.5, 0.0)) * 2.0 - time * 1.6) - 0.5)) * pulseStrength;
+      float hexEnabled = 1.0 - step(1.5, domeType);
+      float plasmaEnabled = step(1.5, domeType) * (1.0 - step(2.5, domeType));
+      float matrixEnabled = step(2.5, domeType) * (1.0 - step(3.5, domeType));
+      float aegisEnabled = step(3.5, domeType) * (1.0 - step(4.5, domeType));
+      float stormEnabled = step(4.5, domeType);
+      float hexDome = gridLine * 0.7 + scanLine * 0.48;
+      float plasmaDome = energyPulse * 1.05 + sin((lon * 36.0 + lat * 18.0 + time * 8.0)) * 0.08;
+      float matrixDome = gridLine * 0.42 + smoothstep(0.018, 0.0, abs(fract(lon * 28.0 - time * 3.0) - 0.5)) * 0.78;
+      float aegisDome = max(gridLine * 0.52, scanLine * 0.72) + smoothstep(0.03, 0.0, abs(lat - 0.08)) * 0.54;
+      float stormDome = energyPulse * 0.82 + smoothstep(0.02, 0.0, abs(fract((lon + lat) * 18.0 + time * 5.0) - 0.5)) * 0.82;
+      float style = hexDome * hexEnabled + plasmaDome * plasmaEnabled + matrixDome * matrixEnabled + aegisDome * aegisEnabled + stormDome * stormEnabled;
+      vec3 plasmaTint = mix(color.rgb, vec3(1.0, 0.28, 0.86), 0.4);
+      vec3 matrixTint = mix(color.rgb, vec3(0.62, 1.0, 0.24), 0.42);
+      vec3 aegisTint = mix(color.rgb, vec3(0.46, 0.78, 1.0), 0.28);
+      vec3 stormTint = mix(color.rgb, vec3(0.82, 0.55, 1.0), 0.38);
+      vec3 styleColor = color.rgb * hexEnabled + plasmaTint * plasmaEnabled + matrixTint * matrixEnabled + aegisTint * aegisEnabled + stormTint * stormEnabled;
+      float rim = smoothstep(0.06, 0.0, lat) + smoothstep(0.035, 0.0, abs(lat - 0.96));
+      material.diffuse = styleColor * (0.14 + style * 0.18);
+      material.emission = styleColor * (style * 1.05 + rim * 0.62 + energyPulse * 0.48) * domeFade;
+      material.alpha = opacity * domeFade * (0.09 + style * 0.55 + rim * 0.36 + energyPulse * 0.22);
+      return material;
+    }
+  `;
+}
+export class RadarScanEffect {
+    viewer;
+    dataSource;
+    options;
+    primitive = null;
+    centerEntity = null;
+    renderFrame = 0;
+    destroyed = false;
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = normalizeRadarScanOptions(options);
+        this.dataSource = new CustomDataSource('geo-effect-kit-radar-scan');
+        this.viewer.dataSources.add(this.dataSource);
+        this.renderPrimitive();
+        this.syncCenterEntity();
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    update(options) {
+        if (this.destroyed)
+            return;
+        const next = normalizeRadarScanOptions({
+            ...this.options,
+            ...options,
+            center: options.center ?? this.options.center,
+            radiusMeters: options.radiusMeters ?? this.options.radiusMeters,
+        });
+        const rebuildPrimitive = shouldRebuildRadarScan(this.options, next);
+        this.options = next;
+        if (rebuildPrimitive) {
+            this.renderPrimitive();
+        }
+        else {
+            this.applyPrimitiveOptions();
+        }
+        this.syncCenterEntity();
+        if (this.options.visible)
+            this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    show() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: true };
+        this.applyPrimitiveOptions();
+        if (this.centerEntity)
+            this.centerEntity.show = this.options.showCenter;
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    hide() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: false };
+        this.applyPrimitiveOptions();
+        if (this.centerEntity)
+            this.centerEntity.show = false;
+        this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    flyTo(options = {}) {
+        if (this.destroyed)
+            return;
+        const center = this.getCenterCartesian();
+        const sphere = new BoundingSphere(center, this.options.radiusMeters);
+        this.viewer.camera.flyToBoundingSphere(sphere, {
+            duration: options.duration ?? 1,
+            offset: new HeadingPitchRange(0, options.pitch ?? -0.72, this.options.radiusMeters * (options.rangeMultiplier ?? 2.25)),
+        });
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.stopRenderLoop();
+        this.removePrimitive();
+        if (this.centerEntity) {
+            this.dataSource.entities.remove(this.centerEntity);
+            this.centerEntity = null;
+        }
+        this.dataSource.entities.removeAll();
+        this.viewer.dataSources.remove(this.dataSource, true);
+        this.viewer.scene.requestRender();
+    }
+    isVisible() {
+        return this.options.visible;
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    getOptions() {
+        return {
+            ...this.options,
+            center: { ...this.options.center },
+        };
+    }
+    renderPrimitive() {
+        this.removePrimitive();
+        registerRadarScanMaterial(this.options);
+        const instance = new GeometryInstance({
+            geometry: new CircleGeometry({
+                center: this.getCenterCartesian(),
+                radius: this.options.radiusMeters,
+                vertexFormat: EllipsoidSurfaceAppearance.VERTEX_FORMAT,
+            }),
+        });
+        this.primitive = this.viewer.scene.primitives.add(new GroundPrimitive({
+            geometryInstances: instance,
+            appearance: new EllipsoidSurfaceAppearance({
+                material: createRadarScanMaterial(this.options),
+            }),
+            show: this.options.visible,
+        }));
+    }
+    removePrimitive() {
+        if (!this.primitive)
+            return;
+        this.viewer.scene.primitives.remove(this.primitive);
+        this.primitive = null;
+    }
+    applyPrimitiveOptions() {
+        if (this.primitive) {
+            this.primitive.show = this.options.visible;
+            this.applyMaterialOptions();
+        }
+    }
+    applyMaterialOptions() {
+        const material = this.primitive?.appearance?.material;
+        if (!material)
+            return;
+        material.uniforms.color = Color.fromCssColorString(this.options.color).withAlpha(1);
+        material.uniforms.opacity = this.options.opacity;
+        material.uniforms.ringsEnabled = this.options.rings ? 1 : 0;
+        material.uniforms.radarType = getRadarScanTypeUniform(this.options.type);
+        material.uniforms.scanDurationMs = this.options.scanDurationMs;
+    }
+    syncCenterEntity() {
+        if (!this.options.showCenter) {
+            if (this.centerEntity) {
+                this.dataSource.entities.remove(this.centerEntity);
+                this.centerEntity = null;
+            }
+            return;
+        }
+        const position = this.getCenterCartesian();
+        const color = Color.fromCssColorString(this.options.color);
+        if (!this.centerEntity) {
+            this.centerEntity = this.dataSource.entities.add({
+                id: 'geo-effect-kit-radar-scan-center',
+                position,
+                show: this.options.visible,
+                point: new PointGraphics({
+                    pixelSize: 12,
+                    color: new ConstantProperty(color),
+                    outlineColor: new ConstantProperty(Color.WHITE.withAlpha(0.72)),
+                    outlineWidth: 2,
+                    heightReference: HeightReference.CLAMP_TO_GROUND,
+                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
+                }),
+            });
+            return;
+        }
+        this.centerEntity.position = new ConstantPositionProperty(position);
+        this.centerEntity.show = this.options.visible;
+        if (this.centerEntity.point) {
+            this.centerEntity.point.color = new ConstantProperty(color);
+        }
+    }
+    startRenderLoop() {
+        if (this.renderFrame || !this.options.visible || typeof window === 'undefined')
+            return;
+        const tick = () => {
+            if (this.destroyed || !this.primitive || !this.options.visible) {
+                this.renderFrame = 0;
+                return;
+            }
+            this.viewer.scene.requestRender();
+            this.renderFrame = window.requestAnimationFrame(tick);
+        };
+        this.renderFrame = window.requestAnimationFrame(tick);
+    }
+    stopRenderLoop() {
+        if (!this.renderFrame || typeof window === 'undefined') {
+            this.renderFrame = 0;
+            return;
+        }
+        window.cancelAnimationFrame(this.renderFrame);
+        this.renderFrame = 0;
+    }
+    getCenterCartesian() {
+        return Cartesian3.fromDegrees(this.options.center.longitude, this.options.center.latitude);
+    }
+}
+export class RippleSpreadEffect {
+    viewer;
+    dataSource;
+    options;
+    primitive = null;
+    centerEntity = null;
+    renderFrame = 0;
+    destroyed = false;
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = normalizeRippleSpreadOptions(options);
+        this.dataSource = new CustomDataSource('geo-effect-kit-ripple-spread');
+        this.viewer.dataSources.add(this.dataSource);
+        this.renderPrimitive();
+        this.syncCenterEntity();
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    update(options) {
+        if (this.destroyed)
+            return;
+        const next = normalizeRippleSpreadOptions({
+            ...this.options,
+            ...options,
+            center: options.center ?? this.options.center,
+            radiusMeters: options.radiusMeters ?? this.options.radiusMeters,
+        });
+        const rebuildPrimitive = shouldRebuildRippleSpread(this.options, next);
+        this.options = next;
+        if (rebuildPrimitive) {
+            this.renderPrimitive();
+        }
+        else {
+            this.applyPrimitiveOptions();
+        }
+        this.syncCenterEntity();
+        if (this.options.visible)
+            this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    show() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: true };
+        this.applyPrimitiveOptions();
+        if (this.centerEntity)
+            this.centerEntity.show = this.options.showCenter;
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    hide() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: false };
+        this.applyPrimitiveOptions();
+        if (this.centerEntity)
+            this.centerEntity.show = false;
+        this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    flyTo(options = {}) {
+        if (this.destroyed)
+            return;
+        const center = this.getCenterCartesian();
+        const sphere = new BoundingSphere(center, this.options.radiusMeters);
+        this.viewer.camera.flyToBoundingSphere(sphere, {
+            duration: options.duration ?? 1,
+            offset: new HeadingPitchRange(0, options.pitch ?? -0.72, this.options.radiusMeters * (options.rangeMultiplier ?? 2.25)),
+        });
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.stopRenderLoop();
+        this.removePrimitive();
+        if (this.centerEntity) {
+            this.dataSource.entities.remove(this.centerEntity);
+            this.centerEntity = null;
+        }
+        this.dataSource.entities.removeAll();
+        this.viewer.dataSources.remove(this.dataSource, true);
+        this.viewer.scene.requestRender();
+    }
+    isVisible() {
+        return this.options.visible;
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    getOptions() {
+        return {
+            ...this.options,
+            center: { ...this.options.center },
+        };
+    }
+    renderPrimitive() {
+        this.removePrimitive();
+        registerRippleSpreadMaterial(this.options);
+        const instance = new GeometryInstance({
+            geometry: new CircleGeometry({
+                center: this.getCenterCartesian(),
+                radius: this.options.radiusMeters,
+                vertexFormat: EllipsoidSurfaceAppearance.VERTEX_FORMAT,
+            }),
+        });
+        this.primitive = this.viewer.scene.primitives.add(new GroundPrimitive({
+            geometryInstances: instance,
+            appearance: new EllipsoidSurfaceAppearance({
+                material: createRippleSpreadMaterial(this.options),
+            }),
+            show: this.options.visible,
+        }));
+    }
+    removePrimitive() {
+        if (!this.primitive)
+            return;
+        this.viewer.scene.primitives.remove(this.primitive);
+        this.primitive = null;
+    }
+    applyPrimitiveOptions() {
+        if (this.primitive) {
+            this.primitive.show = this.options.visible;
+            this.applyMaterialOptions();
+        }
+    }
+    applyMaterialOptions() {
+        const material = this.primitive?.appearance?.material;
+        if (!material)
+            return;
+        material.uniforms.color = Color.fromCssColorString(this.options.color).withAlpha(1);
+        material.uniforms.opacity = this.options.opacity;
+        material.uniforms.rippleType = getRippleSpreadTypeUniform(this.options.type);
+        material.uniforms.ringCount = this.options.ringCount;
+        material.uniforms.durationMs = this.options.durationMs;
+    }
+    syncCenterEntity() {
+        if (!this.options.showCenter) {
+            if (this.centerEntity) {
+                this.dataSource.entities.remove(this.centerEntity);
+                this.centerEntity = null;
+            }
+            return;
+        }
+        const position = this.getCenterCartesian();
+        const color = Color.fromCssColorString(this.options.color);
+        if (!this.centerEntity) {
+            this.centerEntity = this.dataSource.entities.add({
+                id: 'geo-effect-kit-ripple-spread-center',
+                position,
+                show: this.options.visible,
+                point: new PointGraphics({
+                    pixelSize: 12,
+                    color: new ConstantProperty(color),
+                    outlineColor: new ConstantProperty(Color.WHITE.withAlpha(0.72)),
+                    outlineWidth: 2,
+                    heightReference: HeightReference.CLAMP_TO_GROUND,
+                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
+                }),
+            });
+            return;
+        }
+        this.centerEntity.position = new ConstantPositionProperty(position);
+        this.centerEntity.show = this.options.visible;
+        if (this.centerEntity.point) {
+            this.centerEntity.point.color = new ConstantProperty(color);
+        }
+    }
+    startRenderLoop() {
+        if (this.renderFrame || !this.options.visible || typeof window === 'undefined')
+            return;
+        const tick = () => {
+            if (this.destroyed || !this.primitive || !this.options.visible) {
+                this.renderFrame = 0;
+                return;
+            }
+            this.viewer.scene.requestRender();
+            this.renderFrame = window.requestAnimationFrame(tick);
+        };
+        this.renderFrame = window.requestAnimationFrame(tick);
+    }
+    stopRenderLoop() {
+        if (!this.renderFrame || typeof window === 'undefined') {
+            this.renderFrame = 0;
+            return;
+        }
+        window.cancelAnimationFrame(this.renderFrame);
+        this.renderFrame = 0;
+    }
+    getCenterCartesian() {
+        return Cartesian3.fromDegrees(this.options.center.longitude, this.options.center.latitude);
+    }
+}
+export class SceneWeatherEffect {
+    viewer;
+    options;
+    stage = null;
+    renderFrame = 0;
+    destroyed = false;
+    constructor(viewer, options = {}) {
+        this.viewer = viewer;
+        this.options = normalizeSceneWeatherOptions(options);
+        this.renderStage();
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    update(options) {
+        if (this.destroyed)
+            return;
+        this.options = normalizeSceneWeatherOptions({
+            ...this.options,
+            ...options,
+            visible: options.visible ?? this.options.visible,
+        });
+        this.applyStageOptions();
+        if (this.options.visible)
+            this.startRenderLoop();
+        else
+            this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    show() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: true };
+        this.applyStageOptions();
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    hide() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: false };
+        this.applyStageOptions();
+        this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    flyTo() {
+        if (this.destroyed)
+            return;
+        this.viewer.scene.requestRender();
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.stopRenderLoop();
+        if (this.stage) {
+            this.viewer.scene.postProcessStages.remove(this.stage);
+            this.stage = null;
+        }
+        this.viewer.scene.requestRender();
+    }
+    isVisible() {
+        return this.options.visible;
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    getOptions() {
+        return { ...this.options };
+    }
+    renderStage() {
+        this.stage = this.viewer.scene.postProcessStages.add(new PostProcessStage({
+            name: 'geo-effect-kit-scene-weather',
+            fragmentShader: buildSceneWeatherPostProcessSource(),
+            uniforms: createSceneWeatherUniforms(this.options),
+        }));
+        this.applyStageOptions();
+    }
+    applyStageOptions() {
+        if (!this.stage)
+            return;
+        this.stage.enabled = this.options.visible;
+        Object.assign(this.stage.uniforms, createSceneWeatherUniforms(this.options));
+    }
+    startRenderLoop() {
+        if (this.renderFrame || !this.options.visible || typeof window === 'undefined')
+            return;
+        const tick = () => {
+            if (this.destroyed || !this.options.visible) {
+                this.renderFrame = 0;
+                return;
+            }
+            this.viewer.scene.requestRender();
+            this.renderFrame = window.requestAnimationFrame(tick);
+        };
+        this.renderFrame = window.requestAnimationFrame(tick);
+    }
+    stopRenderLoop() {
+        if (!this.renderFrame || typeof window === 'undefined') {
+            this.renderFrame = 0;
+            return;
+        }
+        window.cancelAnimationFrame(this.renderFrame);
+        this.renderFrame = 0;
+    }
+}
+export class PostProcessEffect {
+    viewer;
+    options;
+    stage = null;
+    destroyed = false;
+    constructor(viewer, options = {}) {
+        this.viewer = viewer;
+        this.options = normalizePostProcessOptions(options);
+        this.renderStage();
+        this.viewer.scene.requestRender();
+    }
+    update(options) {
+        if (this.destroyed)
+            return;
+        this.options = normalizePostProcessOptions({
+            ...this.options,
+            ...options,
+            visible: options.visible ?? this.options.visible,
+        });
+        this.applyStageOptions();
+        this.viewer.scene.requestRender();
+    }
+    show() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: true };
+        this.applyStageOptions();
+        this.viewer.scene.requestRender();
+    }
+    hide() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: false };
+        this.applyStageOptions();
+        this.viewer.scene.requestRender();
+    }
+    flyTo() {
+        if (this.destroyed)
+            return;
+        this.viewer.scene.requestRender();
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        if (this.stage) {
+            this.viewer.scene.postProcessStages.remove(this.stage);
+            this.stage = null;
+        }
+        this.viewer.scene.requestRender();
+    }
+    isVisible() {
+        return this.options.visible;
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    getOptions() {
+        return { ...this.options };
+    }
+    renderStage() {
+        this.stage = this.viewer.scene.postProcessStages.add(new PostProcessStage({
+            name: 'geo-effect-kit-post-process',
+            fragmentShader: buildPostProcessSource(),
+            uniforms: createPostProcessUniforms(this.options),
+        }));
+        this.applyStageOptions();
+    }
+    applyStageOptions() {
+        if (!this.stage)
+            return;
+        this.stage.enabled = this.options.visible;
+        Object.assign(this.stage.uniforms, createPostProcessUniforms(this.options));
+    }
+}
+export class TemperatureFieldEffect {
+    viewer;
+    dataSource;
+    options;
+    primitive = null;
+    destroyed = false;
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = normalizeTemperatureFieldOptions(options);
+        this.dataSource = new CustomDataSource('geo-effect-kit-temperature-field');
+        this.viewer.dataSources.add(this.dataSource);
+        this.renderPrimitive();
+        this.syncOutlines();
+        this.viewer.scene.requestRender();
+    }
+    update(options) {
+        if (this.destroyed)
+            return;
+        const nextOptions = {
+            polygons: options.polygons ?? this.options.polygons,
+            stops: options.stops ?? this.options.stops,
+            samples: options.samples ?? this.options.samples,
+            seed: options.seed ?? this.options.seed,
+            opacity: options.opacity ?? this.options.opacity,
+            noiseStrength: options.noiseStrength ?? this.options.noiseStrength,
+            contourLines: options.contourLines ?? this.options.contourLines,
+            contourStrength: options.contourStrength ?? this.options.contourStrength,
+            outline: options.outline ?? this.options.outline,
+            outlineColor: options.outlineColor ?? this.options.outlineColor,
+            outlineWidth: options.outlineWidth ?? this.options.outlineWidth,
+            visible: options.visible ?? this.options.visible,
+        };
+        const nextBounds = options.bounds ?? this.options.bounds;
+        if (nextBounds)
+            nextOptions.bounds = nextBounds;
+        const next = normalizeTemperatureFieldOptions(nextOptions);
+        const rebuildPrimitive = shouldRebuildTemperatureField(this.options, next);
+        this.options = next;
+        if (rebuildPrimitive) {
+            this.renderPrimitive();
+            this.syncOutlines();
+        }
+        else {
+            this.applyPrimitiveOptions();
+            this.syncOutlineVisibility();
+        }
+        this.viewer.scene.requestRender();
+    }
+    show() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: true };
+        this.applyPrimitiveOptions();
+        this.syncOutlineVisibility();
+        this.viewer.scene.requestRender();
+    }
+    hide() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: false };
+        this.applyPrimitiveOptions();
+        this.syncOutlineVisibility();
+        this.viewer.scene.requestRender();
+    }
+    flyTo(options = {}) {
+        if (this.destroyed || !this.options.bounds)
+            return;
+        this.viewer.camera.flyTo({
+            destination: Rectangle.fromDegrees(this.options.bounds.west, this.options.bounds.south, this.options.bounds.east, this.options.bounds.north),
+            duration: options.duration ?? 1,
+        });
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.removePrimitive();
+        this.dataSource.entities.removeAll();
+        this.viewer.dataSources.remove(this.dataSource, true);
+        this.viewer.scene.requestRender();
+    }
+    isVisible() {
+        return this.options.visible;
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    getOptions() {
+        return cloneTemperatureFieldOptions(this.options);
+    }
+    renderPrimitive() {
+        this.removePrimitive();
+        registerTemperatureFieldMaterial(this.options);
+        if (this.options.polygons.length === 0)
+            return;
+        const instances = this.options.polygons.map((polygon, index) => {
+            const outerPositions = polygon.outer.map(([longitude, latitude]) => Cartesian3.fromDegrees(longitude, latitude));
+            const holes = polygon.holes.map((hole) => new PolygonHierarchy(hole.map(([longitude, latitude]) => Cartesian3.fromDegrees(longitude, latitude))));
+            return new GeometryInstance({
+                id: `geo-temperature-field-${index}`,
+                geometry: new PolygonGeometry({
+                    polygonHierarchy: new PolygonHierarchy(outerPositions, holes),
+                    vertexFormat: EllipsoidSurfaceAppearance.VERTEX_FORMAT,
+                }),
+            });
+        });
+        this.primitive = this.viewer.scene.primitives.add(new GroundPrimitive({
+            geometryInstances: instances,
+            appearance: new EllipsoidSurfaceAppearance({
+                material: createTemperatureFieldMaterial(this.options),
+            }),
+            show: this.options.visible,
+        }));
+    }
+    removePrimitive() {
+        if (!this.primitive)
+            return;
+        this.viewer.scene.primitives.remove(this.primitive);
+        this.primitive = null;
+    }
+    applyPrimitiveOptions() {
+        if (!this.primitive)
+            return;
+        this.primitive.show = this.options.visible;
+        this.applyMaterialOptions();
+    }
+    applyMaterialOptions() {
+        const material = this.primitive?.appearance?.material;
+        if (!material)
+            return;
+        Object.assign(material.uniforms, createTemperatureFieldUniforms(this.options));
+    }
+    syncOutlines() {
+        clearEntities(this.dataSource);
+        if (!this.options.outline)
+            return;
+        this.options.polygons.forEach((polygon, index) => {
+            this.addOutline(`${index}-outer`, polygon.outer);
+            polygon.holes.forEach((hole, holeIndex) => {
+                this.addOutline(`${index}-hole-${holeIndex}`, hole);
+            });
+        });
+    }
+    addOutline(id, ring) {
+        if (ring.length < 2)
+            return;
+        const closedRing = isTemperatureRingClosed(ring) ? ring : [...ring, ring[0]];
+        this.dataSource.entities.add({
+            id: `geo-temperature-field-outline-${id}`,
+            show: this.options.visible && this.options.outline,
+            polyline: {
+                positions: closedRing.map(([longitude, latitude]) => Cartesian3.fromDegrees(longitude, latitude)),
+                clampToGround: true,
+                width: this.options.outlineWidth,
+                material: new PolylineGlowMaterialProperty({
+                    glowPower: 0.18,
+                    color: Color.fromCssColorString(this.options.outlineColor).withAlpha(0.76),
+                }),
+            },
+        });
+    }
+    syncOutlineVisibility() {
+        this.dataSource.entities.values.forEach((entity) => {
+            entity.show = this.options.visible && this.options.outline;
+        });
+    }
+}
+export class FireBillboardEffect {
+    viewer;
+    dataSource;
+    options;
+    entities = [];
+    frameSets = [];
+    frameTimer = null;
+    frameIndex = 0;
+    loadToken = 0;
+    destroyed = false;
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = normalizeFireBillboardOptions(options);
+        this.dataSource = new CustomDataSource('geo-effect-kit-fire-billboard');
+        this.dataSource.show = this.options.visible;
+        this.viewer.dataSources.add(this.dataSource);
+        this.renderEntities();
+        this.loadFrames();
+        this.viewer.scene.requestRender();
+    }
+    update(options) {
+        if (this.destroyed)
+            return;
+        const next = normalizeFireBillboardOptions({
+            ...this.options,
+            ...options,
+            points: options.points ?? this.options.points,
+            clampToGround: options.clampToGround ?? this.options.clampToGround,
+            visible: options.visible ?? this.options.visible,
+        });
+        const rebuildEntities = shouldRebuildFireBillboard(this.options, next);
+        const intervalChanged = this.options.frameIntervalMs !== next.frameIntervalMs;
+        this.options = next;
+        if (rebuildEntities) {
+            this.stopFrameTimer();
+            this.renderEntities();
+            this.loadFrames();
+        }
+        else {
+            this.applyBillboardOptions();
+            if (intervalChanged)
+                this.restartFrameTimer();
+        }
+        this.dataSource.show = this.options.visible;
+        if (!this.options.visible)
+            this.stopFrameTimer();
+        this.viewer.scene.requestRender();
+    }
+    show() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: true };
+        this.dataSource.show = true;
+        this.loadFrames();
+        this.viewer.scene.requestRender();
+    }
+    hide() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: false };
+        this.dataSource.show = false;
+        this.stopFrameTimer();
+        this.viewer.scene.requestRender();
+    }
+    flyTo(options = {}) {
+        if (this.destroyed || this.options.points.length === 0)
+            return;
+        const { center, radius } = getPositionBounds(this.options.points, Math.max(1200, this.options.scale * 2400));
+        this.viewer.camera.flyToBoundingSphere(new BoundingSphere(center, radius), {
+            duration: options.duration ?? 1,
+            offset: new HeadingPitchRange(0, options.pitch ?? -0.62, radius * (options.rangeMultiplier ?? 2.4)),
+        });
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.loadToken += 1;
+        this.stopFrameTimer();
+        this.dataSource.entities.removeAll();
+        this.entities = [];
+        this.viewer.dataSources.remove(this.dataSource, true);
+        this.viewer.scene.requestRender();
+    }
+    isVisible() {
+        return this.options.visible;
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    getOptions() {
+        return {
+            ...this.options,
+            points: cloneFireBillboardPoints(this.options.points),
+        };
+    }
+    renderEntities() {
+        clearEntities(this.dataSource);
+        this.frameSets = this.options.points.map((point) => [point.gif]);
+        this.entities = this.options.points.map((point, index) => {
+            const billboard = new BillboardGraphics({
+                image: new ConstantProperty(point.gif),
+                scale: new ConstantProperty(this.options.scale),
+                horizontalOrigin: HorizontalOrigin.CENTER,
+                verticalOrigin: VerticalOrigin.BOTTOM,
+                heightReference: this.options.clampToGround ? HeightReference.CLAMP_TO_GROUND : HeightReference.NONE,
+                disableDepthTestDistance: this.options.disableDepthTestDistance,
+            });
+            const entityOptions = {
+                id: point.id ?? `geo-effect-kit-fire-billboard-${index}`,
+                position: Cartesian3.fromDegrees(point.longitude, point.latitude, point.height ?? 0),
+                billboard,
+            };
+            if (point.label) {
+                Object.assign(entityOptions, {
+                    label: {
+                        text: point.label,
+                        font: '12px sans-serif',
+                        fillColor: Color.WHITE,
+                        outlineColor: Color.BLACK,
+                        outlineWidth: 3,
+                        pixelOffset: new Cartesian2(0, -Math.max(24, 48 * this.options.scale)),
+                        showBackground: false,
+                        disableDepthTestDistance: this.options.disableDepthTestDistance,
+                    },
+                });
+            }
+            return this.dataSource.entities.add(entityOptions);
+        });
+    }
+    applyBillboardOptions() {
+        this.entities.forEach((entity, index) => {
+            const point = this.options.points[index];
+            if (!point || !entity.billboard)
+                return;
+            entity.position = new ConstantPositionProperty(Cartesian3.fromDegrees(point.longitude, point.latitude, point.height ?? 0));
+            entity.billboard.scale = new ConstantProperty(this.options.scale);
+            entity.billboard.heightReference = new ConstantProperty(this.options.clampToGround ? HeightReference.CLAMP_TO_GROUND : HeightReference.NONE);
+            entity.billboard.disableDepthTestDistance = new ConstantProperty(this.options.disableDepthTestDistance);
+            if (entity.label) {
+                entity.label.text = new ConstantProperty(point.label ?? '');
+                entity.label.pixelOffset = new ConstantProperty(new Cartesian2(0, -Math.max(24, 48 * this.options.scale)));
+                entity.label.disableDepthTestDistance = new ConstantProperty(this.options.disableDepthTestDistance);
+            }
+        });
+    }
+    loadFrames() {
+        if (!this.options.visible || this.options.points.length === 0)
+            return;
+        const token = ++this.loadToken;
+        this.options.points.forEach((point, index) => {
+            loadGifFrameImages(point.gif).then((frames) => {
+                if (this.destroyed || token !== this.loadToken)
+                    return;
+                const currentPoint = this.options.points[index];
+                if (!currentPoint || currentPoint.gif !== point.gif)
+                    return;
+                this.applyFrameSet(index, frames);
+            }).catch(() => {
+                if (this.destroyed || token !== this.loadToken)
+                    return;
+                const currentPoint = this.options.points[index];
+                if (!currentPoint || currentPoint.gif !== point.gif)
+                    return;
+                this.applyFrameSet(index, [point.gif]);
+            });
+        });
+    }
+    applyFrameSet(index, frames) {
+        const entity = this.entities[index];
+        const point = this.options.points[index];
+        if (!entity?.billboard || !point)
+            return;
+        this.frameSets[index] = frames.length > 0 ? frames : [point.gif];
+        entity.billboard.image = new ConstantProperty(this.frameSets[index][0] ?? point.gif);
+        this.restartFrameTimer();
+        this.viewer.scene.requestRender();
+    }
+    restartFrameTimer(frameSets) {
+        this.stopFrameTimer();
+        if (!this.options.visible)
+            return;
+        const sets = frameSets ?? this.frameSets;
+        if (!sets.some((frames) => frames.length > 1))
+            return;
+        this.frameTimer = setInterval(() => {
+            if (this.destroyed || !this.options.visible) {
+                this.stopFrameTimer();
+                return;
+            }
+            this.frameIndex += 1;
+            this.entities.forEach((entity, index) => {
+                const frames = sets[index];
+                if (!entity.billboard || !frames || frames.length === 0)
+                    return;
+                entity.billboard.image = new ConstantProperty(frames[this.frameIndex % frames.length] ?? frames[0]);
+            });
+            this.viewer.scene.requestRender();
+        }, this.options.frameIntervalMs);
+    }
+    stopFrameTimer() {
+        if (!this.frameTimer)
+            return;
+        clearInterval(this.frameTimer);
+        this.frameTimer = null;
+    }
+}
+export class WaterSurfaceEffect {
+    viewer;
+    dataSource;
+    options;
+    waterEntity = null;
+    outlineEntity = null;
+    material = null;
+    renderFrame = 0;
+    destroyed = false;
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = normalizeWaterSurfaceOptions(options);
+        this.dataSource = new CustomDataSource('geo-effect-kit-water-surface');
+        this.dataSource.show = this.options.visible;
+        this.viewer.dataSources.add(this.dataSource);
+        this.renderEntities();
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    update(options) {
+        if (this.destroyed)
+            return;
+        const next = normalizeWaterSurfaceOptions({
+            ...this.options,
+            ...options,
+            polygon: options.polygon ?? this.options.polygon,
+            visible: options.visible ?? this.options.visible,
+        });
+        const rebuildEntities = shouldRebuildWaterSurface(this.options, next);
+        this.options = next;
+        if (rebuildEntities) {
+            this.renderEntities();
+        }
+        else {
+            this.applyMaterialOptions();
+        }
+        this.dataSource.show = this.options.visible;
+        if (this.options.visible)
+            this.startRenderLoop();
+        else
+            this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    show() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: true };
+        this.dataSource.show = true;
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    hide() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: false };
+        this.dataSource.show = false;
+        this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    flyTo(options = {}) {
+        if (this.destroyed)
+            return;
+        const bounds = getPositionBounds(this.options.polygon, 1200);
+        this.viewer.camera.flyToBoundingSphere(new BoundingSphere(bounds.center, bounds.radius), {
+            duration: options.duration ?? 1,
+            offset: new HeadingPitchRange(0, options.pitch ?? -0.72, bounds.radius * (options.rangeMultiplier ?? 2.8)),
+        });
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.stopRenderLoop();
+        this.dataSource.entities.removeAll();
+        this.waterEntity = null;
+        this.outlineEntity = null;
+        this.material = null;
+        this.viewer.dataSources.remove(this.dataSource, true);
+        this.viewer.scene.requestRender();
+    }
+    isVisible() {
+        return this.options.visible;
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    getOptions() {
+        return {
+            ...this.options,
+            polygon: clonePositions(this.options.polygon),
+        };
+    }
+    renderEntities() {
+        clearEntities(this.dataSource);
+        this.material = createWaterSurfaceMaterialProperty(this.options);
+        this.waterEntity = this.dataSource.entities.add({
+            id: 'geo-effect-kit-water-surface-polygon',
+            polygon: {
+                hierarchy: new PolygonHierarchy(positionsToCartesiansAtHeight(this.options.polygon, this.options.height)),
+                material: this.material,
+                perPositionHeight: this.options.height > 0,
+                outline: false,
+            },
+        });
+        this.syncOutlineEntity();
+    }
+    applyMaterialOptions() {
+        if (!this.material)
+            return;
+        Object.assign(this.material.uniforms, createWaterSurfaceUniforms(this.options));
+    }
+    syncOutlineEntity() {
+        if (!this.options.outline)
+            return;
+        this.outlineEntity = this.dataSource.entities.add({
+            id: 'geo-effect-kit-water-surface-outline',
+            polyline: {
+                positions: positionsToCartesiansAtHeight(this.options.polygon, this.options.height + 1),
+                clampToGround: this.options.height <= 0,
+                width: 3,
+                material: new PolylineGlowMaterialProperty({
+                    glowPower: 0.2,
+                    color: Color.fromCssColorString(this.options.color).withAlpha(0.72),
+                }),
+            },
+        });
+    }
+    startRenderLoop() {
+        if (this.renderFrame || !this.options.visible || typeof window === 'undefined')
+            return;
+        const tick = () => {
+            if (this.destroyed || !this.options.visible) {
+                this.renderFrame = 0;
+                return;
+            }
+            this.viewer.scene.requestRender();
+            this.renderFrame = window.requestAnimationFrame(tick);
+        };
+        this.renderFrame = window.requestAnimationFrame(tick);
+    }
+    stopRenderLoop() {
+        if (!this.renderFrame || typeof window === 'undefined') {
+            this.renderFrame = 0;
+            return;
+        }
+        window.cancelAnimationFrame(this.renderFrame);
+        this.renderFrame = 0;
+    }
+}
+export class PolylineFlowEffect {
+    viewer;
+    dataSource;
+    options;
+    routeEntity = null;
+    trailEntities = [];
+    renderFrame = 0;
+    destroyed = false;
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = normalizePolylineFlowOptions(options);
+        this.dataSource = new CustomDataSource('geo-effect-kit-polyline-flow');
+        this.dataSource.show = this.options.visible;
+        this.viewer.dataSources.add(this.dataSource);
+        this.renderEntities();
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    update(options) {
+        if (this.destroyed)
+            return;
+        const next = normalizePolylineFlowOptions({
+            ...this.options,
+            ...options,
+            positions: options.positions ?? this.options.positions,
+            clampToGround: options.clampToGround ?? this.options.clampToGround,
+            visible: options.visible ?? this.options.visible,
+        });
+        const rebuildEntities = shouldRebuildPolylineFlow(this.options, next);
+        const pulseCountChanged = this.options.pulseCount !== next.pulseCount;
+        this.options = next;
+        if (rebuildEntities) {
+            this.renderEntities();
+        }
+        else {
+            this.applyRouteOptions();
+            if (pulseCountChanged)
+                this.syncTrailEntities();
+            else
+                this.applyTrailOptions();
+        }
+        this.dataSource.show = this.options.visible;
+        if (this.options.visible)
+            this.startRenderLoop();
+        else
+            this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    show() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: true };
+        this.dataSource.show = true;
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    hide() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: false };
+        this.dataSource.show = false;
+        this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    flyTo(options = {}) {
+        if (this.destroyed)
+            return;
+        const { center, radius } = getPositionBounds(this.getRenderPositions(), Math.max(2000, this.options.width * 1000));
+        this.viewer.camera.flyToBoundingSphere(new BoundingSphere(center, radius), {
+            duration: options.duration ?? 1,
+            offset: new HeadingPitchRange(0, options.pitch ?? -0.62, radius * (options.rangeMultiplier ?? 2.4)),
+        });
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.stopRenderLoop();
+        this.dataSource.entities.removeAll();
+        this.routeEntity = null;
+        this.trailEntities = [];
+        this.viewer.dataSources.remove(this.dataSource, true);
+        this.viewer.scene.requestRender();
+    }
+    isVisible() {
+        return this.options.visible;
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    getOptions() {
+        return {
+            ...this.options,
+            positions: clonePositions(this.options.positions),
+        };
+    }
+    renderEntities() {
+        clearEntities(this.dataSource);
+        this.trailEntities = [];
+        this.routeEntity = this.dataSource.entities.add({
+            id: 'geo-effect-kit-polyline-flow-route',
+            polyline: {
+                positions: positionsToCartesians(this.getRenderPositions()),
+                width: this.options.width,
+                clampToGround: this.options.clampToGround,
+                material: this.createBaseMaterial(),
+            },
+        });
+        this.syncTrailEntities();
+    }
+    syncTrailEntities() {
+        this.trailEntities.forEach((entity) => this.dataSource.entities.remove(entity));
+        this.trailEntities = [];
+        for (let index = 0; index < this.options.pulseCount; index += 1) {
+            const trailIndex = index;
+            const entity = this.dataSource.entities.add({
+                id: `geo-effect-kit-polyline-flow-trail-${index}`,
+                polyline: {
+                    positions: new CallbackProperty(() => this.getTrailCartesians(trailIndex), false),
+                    width: Math.max(1, this.options.width * (1.24 - index * 0.035)),
+                    clampToGround: this.options.clampToGround,
+                    material: this.createTrailMaterial(index),
+                },
+            });
+            this.trailEntities.push(entity);
+        }
+    }
+    applyRouteOptions() {
+        if (!this.routeEntity?.polyline)
+            return;
+        this.routeEntity.polyline.width = new ConstantProperty(this.options.width);
+        this.routeEntity.polyline.material = this.createBaseMaterial();
+    }
+    applyTrailOptions() {
+        this.trailEntities.forEach((entity, index) => {
+            if (!entity.polyline)
+                return;
+            entity.polyline.width = new ConstantProperty(Math.max(1, this.options.width * (1.24 - index * 0.035)));
+            entity.polyline.material = this.createTrailMaterial(index);
+        });
+    }
+    createBaseMaterial() {
+        return new PolylineGlowMaterialProperty({
+            color: Color.fromCssColorString(this.options.color).withAlpha(0.58),
+            glowPower: this.options.glowPower,
+            taperPower: this.options.taperPower,
+        });
+    }
+    createTrailMaterial(index) {
+        const alpha = clamp(0.92 - index * 0.045, 0.35, 0.94);
+        return new PolylineGlowMaterialProperty({
+            color: getPolylineFlowColor(this.options.type, this.options.color).withAlpha(alpha),
+            glowPower: clamp(this.options.glowPower + 0.18, 0, 1),
+            taperPower: clamp(this.options.taperPower - 0.18, 0, 1),
+        });
+    }
+    getTrailCartesians(index) {
+        const phase = fract(getAnimationSeconds() * this.options.speed * 0.22 + index / Math.max(1, this.options.pulseCount));
+        const trail = samplePolylineTrail(this.getRenderPositions(), phase, this.options.trailLength, getTrailSampleCount(this.options.type));
+        return positionsToCartesians(trail);
+    }
+    getRenderPositions() {
+        return roundPolylineCorners(this.options.positions, this.options.cornerRadius);
+    }
+    startRenderLoop() {
+        if (this.renderFrame || !this.options.visible || typeof window === 'undefined')
+            return;
+        const tick = () => {
+            if (this.destroyed || !this.options.visible) {
+                this.renderFrame = 0;
+                return;
+            }
+            this.viewer.scene.requestRender();
+            this.renderFrame = window.requestAnimationFrame(tick);
+        };
+        this.renderFrame = window.requestAnimationFrame(tick);
+    }
+    stopRenderLoop() {
+        if (!this.renderFrame || typeof window === 'undefined') {
+            this.renderFrame = 0;
+            return;
+        }
+        window.cancelAnimationFrame(this.renderFrame);
+        this.renderFrame = 0;
+    }
+}
+export class FlyLineEffect {
+    viewer;
+    dataSource;
+    options;
+    baseEntities = [];
+    trailEntities = [];
+    endpointEntities = [];
+    renderFrame = 0;
+    destroyed = false;
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = normalizeFlyLineOptions(options);
+        this.dataSource = new CustomDataSource('geo-effect-kit-fly-line');
+        this.dataSource.show = this.options.visible;
+        this.viewer.dataSources.add(this.dataSource);
+        this.renderEntities();
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    update(options) {
+        if (this.destroyed)
+            return;
+        const next = normalizeFlyLineOptions({
+            ...this.options,
+            ...options,
+            lines: options.lines ?? this.options.lines,
+            showEndpoints: options.showEndpoints ?? this.options.showEndpoints,
+            visible: options.visible ?? this.options.visible,
+        });
+        const rebuildEntities = shouldRebuildFlyLine(this.options, next);
+        const pulseCountChanged = this.options.pulseCount !== next.pulseCount;
+        this.options = next;
+        if (rebuildEntities) {
+            this.renderEntities();
+        }
+        else {
+            this.applyBaseOptions();
+            if (pulseCountChanged)
+                this.syncTrailEntities();
+            else
+                this.applyTrailOptions();
+            this.syncEndpointEntities();
+        }
+        this.dataSource.show = this.options.visible;
+        if (this.options.visible)
+            this.startRenderLoop();
+        else
+            this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    show() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: true };
+        this.dataSource.show = true;
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    hide() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: false };
+        this.dataSource.show = false;
+        this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    flyTo(options = {}) {
+        if (this.destroyed)
+            return;
+        const positions = expandFlyLineRoutes(this.options.lines, this.options.mode).flatMap((line) => sampleFlyLineArc(line, this.options.arcHeight, 12));
+        const { center, radius } = getPositionBounds(positions, Math.max(5000, this.options.arcHeight));
+        this.viewer.camera.flyToBoundingSphere(new BoundingSphere(center, radius), {
+            duration: options.duration ?? 1,
+            offset: new HeadingPitchRange(0, options.pitch ?? -0.64, radius * (options.rangeMultiplier ?? 2.45)),
+        });
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.stopRenderLoop();
+        this.dataSource.entities.removeAll();
+        this.baseEntities = [];
+        this.trailEntities = [];
+        this.endpointEntities = [];
+        this.viewer.dataSources.remove(this.dataSource, true);
+        this.viewer.scene.requestRender();
+    }
+    isVisible() {
+        return this.options.visible;
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    getOptions() {
+        return {
+            ...this.options,
+            lines: cloneFlyLineRoutes(this.options.lines),
+        };
+    }
+    renderEntities() {
+        clearEntities(this.dataSource);
+        this.baseEntities = [];
+        this.trailEntities = [];
+        this.endpointEntities = [];
+        const routes = expandFlyLineRoutes(this.options.lines, this.options.mode);
+        routes.forEach((line, index) => {
+            const routeIndex = index;
+            const entity = this.dataSource.entities.add({
+                id: `geo-effect-kit-fly-line-base-${index}`,
+                polyline: {
+                    positions: positionsToCartesians(sampleFlyLineArc(line, this.options.arcHeight, getFlyLineBaseSampleCount(this.options.mode))),
+                    width: this.options.width,
+                    material: this.createBaseMaterial(),
+                },
+            });
+            this.baseEntities.push(entity);
+            for (let pulseIndex = 0; pulseIndex < this.options.pulseCount; pulseIndex += 1) {
+                this.addTrailEntity(routeIndex, pulseIndex);
+            }
+        });
+        this.syncEndpointEntities();
+    }
+    syncTrailEntities() {
+        this.trailEntities.forEach((entity) => this.dataSource.entities.remove(entity));
+        this.trailEntities = [];
+        expandFlyLineRoutes(this.options.lines, this.options.mode).forEach((_line, routeIndex) => {
+            for (let pulseIndex = 0; pulseIndex < this.options.pulseCount; pulseIndex += 1) {
+                this.addTrailEntity(routeIndex, pulseIndex);
+            }
+        });
+    }
+    addTrailEntity(routeIndex, pulseIndex) {
+        const entity = this.dataSource.entities.add({
+            id: `geo-effect-kit-fly-line-trail-${routeIndex}-${pulseIndex}`,
+            polyline: {
+                positions: new CallbackProperty(() => this.getTrailCartesians(routeIndex, pulseIndex), false),
+                width: Math.max(1, this.options.width * (1.32 - pulseIndex * 0.04)),
+                material: this.createTrailMaterial(pulseIndex),
+            },
+        });
+        this.trailEntities.push(entity);
+    }
+    syncEndpointEntities() {
+        this.endpointEntities.forEach((entity) => this.dataSource.entities.remove(entity));
+        this.endpointEntities = [];
+        if (!this.options.showEndpoints)
+            return;
+        const endpoints = uniqueFlyLineEndpoints(this.options.lines);
+        endpoints.forEach((position, index) => {
+            const entity = this.dataSource.entities.add({
+                id: `geo-effect-kit-fly-line-endpoint-${index}`,
+                position: Cartesian3.fromDegrees(position.longitude, position.latitude, position.height ?? 0),
+                point: new PointGraphics({
+                    pixelSize: 9,
+                    color: new ConstantProperty(Color.fromCssColorString(this.options.color).withAlpha(0.92)),
+                    outlineColor: new ConstantProperty(Color.WHITE.withAlpha(0.68)),
+                    outlineWidth: 2,
+                    heightReference: HeightReference.NONE,
+                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
+                }),
+            });
+            this.endpointEntities.push(entity);
+        });
+    }
+    applyBaseOptions() {
+        this.baseEntities.forEach((entity) => {
+            if (!entity.polyline)
+                return;
+            entity.polyline.width = new ConstantProperty(this.options.width);
+            entity.polyline.material = this.createBaseMaterial();
+        });
+    }
+    applyTrailOptions() {
+        this.trailEntities.forEach((entity, index) => {
+            if (!entity.polyline)
+                return;
+            const pulseIndex = index % Math.max(1, this.options.pulseCount);
+            entity.polyline.width = new ConstantProperty(Math.max(1, this.options.width * (1.32 - pulseIndex * 0.04)));
+            entity.polyline.material = this.createTrailMaterial(pulseIndex);
+        });
+    }
+    createBaseMaterial() {
+        return new PolylineGlowMaterialProperty({
+            color: getFlyLineBaseColor(this.options.mode, this.options.color).withAlpha(0.4),
+            glowPower: this.options.glowPower,
+            taperPower: this.options.taperPower,
+        });
+    }
+    createTrailMaterial(pulseIndex) {
+        return new PolylineGlowMaterialProperty({
+            color: getFlyLineTrailColor(this.options.mode, this.options.color).withAlpha(clamp(0.94 - pulseIndex * 0.04, 0.42, 0.94)),
+            glowPower: clamp(this.options.glowPower + 0.2, 0, 1),
+            taperPower: clamp(this.options.taperPower - 0.22, 0, 1),
+        });
+    }
+    getTrailCartesians(routeIndex, pulseIndex) {
+        const routes = expandFlyLineRoutes(this.options.lines, this.options.mode);
+        const route = routes[routeIndex] ?? routes[0];
+        if (!route)
+            return [];
+        const phase = fract(getAnimationSeconds() * this.options.speed * getFlyLineSpeedScale(this.options.mode) +
+            pulseIndex / Math.max(1, this.options.pulseCount));
+        const trail = sampleFlyLineTrail(route, this.options.arcHeight, phase, this.options.trailLength, getFlyLineTrailSampleCount(this.options.mode));
+        return positionsToCartesians(trail);
+    }
+    startRenderLoop() {
+        if (this.renderFrame || !this.options.visible || typeof window === 'undefined')
+            return;
+        const tick = () => {
+            if (this.destroyed || !this.options.visible) {
+                this.renderFrame = 0;
+                return;
+            }
+            this.viewer.scene.requestRender();
+            this.renderFrame = window.requestAnimationFrame(tick);
+        };
+        this.renderFrame = window.requestAnimationFrame(tick);
+    }
+    stopRenderLoop() {
+        if (!this.renderFrame || typeof window === 'undefined') {
+            this.renderFrame = 0;
+            return;
+        }
+        window.cancelAnimationFrame(this.renderFrame);
+        this.renderFrame = 0;
+    }
+}
+export class PipeFlowEffect {
+    viewer;
+    dataSource;
+    options;
+    pipeShellEntity = null;
+    pipeHighlightEntity = null;
+    waterCoreEntity = null;
+    waveEntities = [];
+    bubbleEntities = [];
+    renderFrame = 0;
+    destroyed = false;
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = normalizePipeFlowOptions(options);
+        this.dataSource = new CustomDataSource('geo-effect-kit-pipe-flow');
+        this.dataSource.show = this.options.visible;
+        this.viewer.dataSources.add(this.dataSource);
+        this.renderEntities();
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    update(options) {
+        if (this.destroyed)
+            return;
+        const next = normalizePipeFlowOptions({
+            ...this.options,
+            ...options,
+            positions: options.positions ?? this.options.positions,
+            clampToGround: options.clampToGround ?? this.options.clampToGround,
+            visible: options.visible ?? this.options.visible,
+        });
+        const rebuildEntities = shouldRebuildPipeFlow(this.options, next);
+        this.options = next;
+        if (rebuildEntities)
+            this.renderEntities();
+        else
+            this.applyOptions();
+        this.dataSource.show = this.options.visible;
+        if (this.options.visible)
+            this.startRenderLoop();
+        else
+            this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    show() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: true };
+        this.dataSource.show = true;
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    hide() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: false };
+        this.dataSource.show = false;
+        this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    flyTo(options = {}) {
+        if (this.destroyed)
+            return;
+        const { center, radius } = getPositionBounds(this.getRenderPositions(), Math.max(2400, this.options.width * 1000));
+        this.viewer.camera.flyToBoundingSphere(new BoundingSphere(center, radius), {
+            duration: options.duration ?? 1,
+            offset: new HeadingPitchRange(0, options.pitch ?? -0.62, radius * (options.rangeMultiplier ?? 2.35)),
+        });
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.stopRenderLoop();
+        this.dataSource.entities.removeAll();
+        this.pipeShellEntity = null;
+        this.pipeHighlightEntity = null;
+        this.waterCoreEntity = null;
+        this.waveEntities = [];
+        this.bubbleEntities = [];
+        this.viewer.dataSources.remove(this.dataSource, true);
+        this.viewer.scene.requestRender();
+    }
+    isVisible() {
+        return this.options.visible;
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    getOptions() {
+        return {
+            ...this.options,
+            positions: clonePositions(this.options.positions),
+        };
+    }
+    renderEntities() {
+        clearEntities(this.dataSource);
+        this.waveEntities = [];
+        this.bubbleEntities = [];
+        const positions = this.getRenderCartesians();
+        this.pipeShellEntity = this.dataSource.entities.add({
+            id: 'geo-effect-kit-pipe-flow-shell',
+            polyline: {
+                positions,
+                width: getPipeLayerWidth(this.options.width, 2),
+                clampToGround: this.options.clampToGround,
+                material: this.createPipeShellMaterial(),
+            },
+        });
+        this.pipeHighlightEntity = this.dataSource.entities.add({
+            id: 'geo-effect-kit-pipe-flow-highlight',
+            polyline: {
+                positions,
+                width: getPipeLayerWidth(this.options.width, 1.2),
+                clampToGround: this.options.clampToGround,
+                material: this.createPipeHighlightMaterial(),
+            },
+        });
+        this.waterCoreEntity = this.dataSource.entities.add({
+            id: 'geo-effect-kit-pipe-flow-water-core',
+            polyline: {
+                positions,
+                width: getPipeLayerWidth(this.options.width, 0.8),
+                clampToGround: this.options.clampToGround,
+                material: this.createWaterCoreMaterial(),
+            },
+        });
+        for (let index = 0; index < 2; index += 1) {
+            const waveIndex = index;
+            const entity = this.dataSource.entities.add({
+                id: `geo-effect-kit-pipe-flow-pressure-wave-${index}`,
+                polyline: {
+                    positions: new CallbackProperty(() => this.getMovingSegmentCartesians(waveIndex, 0.18), false),
+                    width: getPipeLayerWidth(this.options.width, 0.92 - index * 0.12),
+                    clampToGround: this.options.clampToGround,
+                    material: this.createPressureWaveMaterial(index),
+                },
+            });
+            this.waveEntities.push(entity);
+        }
+        for (let index = 0; index < this.options.bubbleDensity; index += 1) {
+            const bubbleIndex = index;
+            const entity = this.dataSource.entities.add({
+                id: `geo-effect-kit-pipe-flow-bubble-${index}`,
+                polyline: {
+                    positions: new CallbackProperty(() => this.getMovingSegmentCartesians(bubbleIndex, 0.055), false),
+                    width: getPipeLayerWidth(this.options.width, 0.24),
+                    clampToGround: this.options.clampToGround,
+                    material: this.createBubbleMaterial(index),
+                },
+            });
+            this.bubbleEntities.push(entity);
+        }
+    }
+    applyOptions() {
+        if (this.pipeShellEntity?.polyline) {
+            this.pipeShellEntity.polyline.width = new ConstantProperty(getPipeLayerWidth(this.options.width, 2));
+            this.pipeShellEntity.polyline.material = this.createPipeShellMaterial();
+        }
+        if (this.pipeHighlightEntity?.polyline) {
+            this.pipeHighlightEntity.polyline.width = new ConstantProperty(getPipeLayerWidth(this.options.width, 1.2));
+            this.pipeHighlightEntity.polyline.material = this.createPipeHighlightMaterial();
+        }
+        if (this.waterCoreEntity?.polyline) {
+            this.waterCoreEntity.polyline.width = new ConstantProperty(getPipeLayerWidth(this.options.width, 0.8));
+            this.waterCoreEntity.polyline.material = this.createWaterCoreMaterial();
+        }
+        this.waveEntities.forEach((entity, index) => {
+            if (!entity.polyline)
+                return;
+            entity.polyline.width = new ConstantProperty(getPipeLayerWidth(this.options.width, 0.92 - index * 0.12));
+            entity.polyline.material = this.createPressureWaveMaterial(index);
+        });
+        this.bubbleEntities.forEach((entity, index) => {
+            if (!entity.polyline)
+                return;
+            entity.polyline.width = new ConstantProperty(getPipeLayerWidth(this.options.width, 0.24));
+            entity.polyline.material = this.createBubbleMaterial(index);
+        });
+    }
+    createPipeShellMaterial() {
+        return new PolylineGlowMaterialProperty({
+            color: Color.fromCssColorString(this.options.color).withAlpha(this.options.pipeOpacity),
+            glowPower: 0.18,
+            taperPower: 0.82,
+        });
+    }
+    createPipeHighlightMaterial() {
+        return new PolylineGlowMaterialProperty({
+            color: Color.WHITE.withAlpha(clamp(this.options.pipeOpacity * 0.55, 0.08, 0.38)),
+            glowPower: 0.08,
+            taperPower: 1,
+        });
+    }
+    createWaterCoreMaterial() {
+        return new PolylineGlowMaterialProperty({
+            color: Color.fromCssColorString(this.options.color).withAlpha(this.options.waterOpacity),
+            glowPower: 0.28,
+            taperPower: 0.44,
+        });
+    }
+    createPressureWaveMaterial(index) {
+        return new PolylineGlowMaterialProperty({
+            color: Color.lerp(Color.fromCssColorString(this.options.color), Color.WHITE, 0.35, new Color()).withAlpha(clamp(this.options.waterOpacity - index * 0.18, 0.22, 0.9)),
+            glowPower: 0.36,
+            taperPower: 0.2,
+        });
+    }
+    createBubbleMaterial(index) {
+        return new PolylineGlowMaterialProperty({
+            color: Color.lerp(Color.fromCssColorString(this.options.color), Color.WHITE, 0.72, new Color()).withAlpha(clamp(0.72 - (index % 4) * 0.08, 0.36, 0.72)),
+            glowPower: 0.18,
+            taperPower: 0,
+        });
+    }
+    getMovingSegmentCartesians(index, length) {
+        const density = Math.max(1, this.options.bubbleDensity);
+        const phase = fract(getAnimationSeconds() * this.options.speed * 0.32 + index / density);
+        const segment = samplePolylineTrail(this.getRenderPositions(), phase, length, 4);
+        return positionsToCartesians(segment);
+    }
+    getRenderCartesians() {
+        return positionsToCartesians(this.getRenderPositions());
+    }
+    getRenderPositions() {
+        return roundPolylineCorners(this.options.positions, this.options.cornerRadius);
+    }
+    startRenderLoop() {
+        if (this.renderFrame || !this.options.visible || typeof window === 'undefined')
+            return;
+        const tick = () => {
+            if (this.destroyed || !this.options.visible) {
+                this.renderFrame = 0;
+                return;
+            }
+            this.viewer.scene.requestRender();
+            this.renderFrame = window.requestAnimationFrame(tick);
+        };
+        this.renderFrame = window.requestAnimationFrame(tick);
+    }
+    stopRenderLoop() {
+        if (!this.renderFrame || typeof window === 'undefined') {
+            this.renderFrame = 0;
+            return;
+        }
+        window.cancelAnimationFrame(this.renderFrame);
+        this.renderFrame = 0;
+    }
+}
+export class LightWallEffect {
+    viewer;
+    dataSource;
+    options;
+    wallEntity = null;
+    outlineEntity = null;
+    material = null;
+    renderFrame = 0;
+    destroyed = false;
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = normalizeLightWallOptions(options);
+        this.dataSource = new CustomDataSource('geo-effect-kit-light-wall');
+        this.dataSource.show = this.options.visible;
+        this.viewer.dataSources.add(this.dataSource);
+        this.renderEntities();
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    update(options) {
+        if (this.destroyed)
+            return;
+        const next = normalizeLightWallOptions({
+            ...this.options,
+            ...options,
+            positions: options.positions ?? this.options.positions,
+            breathing: options.breathing ?? this.options.breathing,
+            outline: options.outline ?? this.options.outline,
+            visible: options.visible ?? this.options.visible,
+        });
+        const rebuildEntities = shouldRebuildLightWall(this.options, next);
+        this.options = next;
+        if (rebuildEntities) {
+            this.renderEntities();
+        }
+        else {
+            this.applyMaterialOptions();
+            this.syncOutlineEntity();
+        }
+        this.dataSource.show = this.options.visible;
+        if (this.options.visible)
+            this.startRenderLoop();
+        else
+            this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    show() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: true };
+        this.dataSource.show = true;
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    hide() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: false };
+        this.dataSource.show = false;
+        this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    flyTo(options = {}) {
+        if (this.destroyed)
+            return;
+        const { center, radius } = getPositionBounds(this.options.positions, this.options.height);
+        this.viewer.camera.flyToBoundingSphere(new BoundingSphere(center, radius), {
+            duration: options.duration ?? 1,
+            offset: new HeadingPitchRange(0, options.pitch ?? -0.58, radius * (options.rangeMultiplier ?? 2.35)),
+        });
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.stopRenderLoop();
+        this.dataSource.entities.removeAll();
+        this.wallEntity = null;
+        this.outlineEntity = null;
+        this.material = null;
+        this.viewer.dataSources.remove(this.dataSource, true);
+        this.viewer.scene.requestRender();
+    }
+    isVisible() {
+        return this.options.visible;
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    getOptions() {
+        return {
+            ...this.options,
+            positions: clonePositions(this.options.positions),
+        };
+    }
+    renderEntities() {
+        clearEntities(this.dataSource);
+        this.outlineEntity = null;
+        this.material = createLightWallMaterialProperty(this.options);
+        this.wallEntity = this.dataSource.entities.add({
+            id: 'geo-effect-kit-light-wall-surface',
+            wall: {
+                positions: positionsToCartesians(this.options.positions),
+                minimumHeights: this.options.positions.map((position) => position.height ?? 0),
+                maximumHeights: this.options.positions.map((position) => (position.height ?? 0) + this.options.height),
+                material: this.material,
+                outline: false,
+            },
+        });
+        this.syncOutlineEntity();
+    }
+    applyMaterialOptions() {
+        if (!this.material)
+            return;
+        this.material.uniforms.color = Color.fromCssColorString(this.options.color).withAlpha(1);
+        this.material.uniforms.opacity = this.options.opacity;
+        this.material.uniforms.speed = this.options.speed;
+        this.material.uniforms.wallType = getLightWallTypeUniform(this.options.type);
+        this.material.uniforms.scanLineCount = this.options.scanLineCount;
+        this.material.uniforms.breathing = this.options.breathing ? 1 : 0;
+    }
+    syncOutlineEntity() {
+        if (!this.options.outline) {
+            if (this.outlineEntity) {
+                this.dataSource.entities.remove(this.outlineEntity);
+                this.outlineEntity = null;
+            }
+            return;
+        }
+        if (this.outlineEntity) {
+            if (this.outlineEntity.polyline) {
+                this.outlineEntity.polyline.positions = new ConstantProperty(positionsToCartesiansAtHeight(this.options.positions, this.options.height));
+                this.outlineEntity.polyline.material = new PolylineGlowMaterialProperty({
+                    color: Color.fromCssColorString(this.options.color).withAlpha(0.86),
+                    glowPower: 0.18,
+                    taperPower: 1,
+                });
+            }
+            return;
+        }
+        this.outlineEntity = this.dataSource.entities.add({
+            id: 'geo-effect-kit-light-wall-outline',
+            polyline: {
+                positions: positionsToCartesiansAtHeight(this.options.positions, this.options.height),
+                width: 2.5,
+                material: new PolylineGlowMaterialProperty({
+                    color: Color.fromCssColorString(this.options.color).withAlpha(0.86),
+                    glowPower: 0.18,
+                    taperPower: 1,
+                }),
+            },
+        });
+    }
+    startRenderLoop() {
+        if (this.renderFrame || !this.options.visible || typeof window === 'undefined')
+            return;
+        const tick = () => {
+            if (this.destroyed || !this.options.visible) {
+                this.renderFrame = 0;
+                return;
+            }
+            this.viewer.scene.requestRender();
+            this.renderFrame = window.requestAnimationFrame(tick);
+        };
+        this.renderFrame = window.requestAnimationFrame(tick);
+    }
+    stopRenderLoop() {
+        if (!this.renderFrame || typeof window === 'undefined') {
+            this.renderFrame = 0;
+            return;
+        }
+        window.cancelAnimationFrame(this.renderFrame);
+        this.renderFrame = 0;
+    }
+}
+export class ScanConeEffect {
+    viewer;
+    dataSource;
+    options;
+    coneEntity = null;
+    originEntity = null;
+    material = null;
+    renderFrame = 0;
+    destroyed = false;
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = normalizeScanConeOptions(options);
+        this.dataSource = new CustomDataSource('geo-effect-kit-scan-cone');
+        this.dataSource.show = this.options.visible;
+        this.viewer.dataSources.add(this.dataSource);
+        this.renderEntities();
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    update(options) {
+        if (this.destroyed)
+            return;
+        const next = normalizeScanConeOptions({
+            ...this.options,
+            ...options,
+            center: options.center ?? this.options.center,
+            showOrigin: options.showOrigin ?? this.options.showOrigin,
+            visible: options.visible ?? this.options.visible,
+        });
+        const rebuildEntities = shouldRebuildScanCone(this.options, next);
+        this.options = next;
+        if (rebuildEntities) {
+            this.renderEntities();
+        }
+        else {
+            this.applyMaterialOptions();
+            this.syncOriginEntity();
+        }
+        this.dataSource.show = this.options.visible;
+        if (this.options.visible)
+            this.startRenderLoop();
+        else
+            this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    show() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: true };
+        this.dataSource.show = true;
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    hide() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: false };
+        this.dataSource.show = false;
+        this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    flyTo(options = {}) {
+        if (this.destroyed)
+            return;
+        const center = this.getOriginCartesian();
+        const radius = Math.max(this.options.radiusMeters, this.options.lengthMeters);
+        this.viewer.camera.flyToBoundingSphere(new BoundingSphere(center, radius), {
+            duration: options.duration ?? 1,
+            offset: new HeadingPitchRange(0, options.pitch ?? -0.46, radius * (options.rangeMultiplier ?? 2.8)),
+        });
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.stopRenderLoop();
+        this.dataSource.entities.removeAll();
+        this.coneEntity = null;
+        this.originEntity = null;
+        this.material = null;
+        this.viewer.dataSources.remove(this.dataSource, true);
+        this.viewer.scene.requestRender();
+    }
+    isVisible() {
+        return this.options.visible;
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    getOptions() {
+        return {
+            ...this.options,
+            center: { ...this.options.center },
+        };
+    }
+    renderEntities() {
+        clearEntities(this.dataSource);
+        this.originEntity = null;
+        this.material = createScanConeMaterialProperty(this.options);
+        this.coneEntity = this.dataSource.entities.add({
+            id: 'geo-effect-kit-scan-cone-volume',
+            position: new CallbackPositionProperty(() => this.getConeCenterCartesian(), false),
+            orientation: new CallbackProperty(() => this.getConeOrientation(), false),
+            cylinder: {
+                length: this.options.lengthMeters,
+                topRadius: 0,
+                bottomRadius: getConeBottomRadius(this.options),
+                slices: 128,
+                numberOfVerticalLines: 24,
+                material: this.material,
+                outline: false,
+            },
+        });
+        this.syncOriginEntity();
+    }
+    applyMaterialOptions() {
+        if (!this.material)
+            return;
+        this.material.uniforms.color = Color.fromCssColorString(this.options.color).withAlpha(1);
+        this.material.uniforms.opacity = this.options.opacity;
+        this.material.uniforms.speed = this.options.speed;
+        this.material.uniforms.coneType = getScanConeTypeUniform(this.options.type);
+        this.material.uniforms.aperture = this.options.aperture;
+    }
+    syncOriginEntity() {
+        if (!this.options.showOrigin) {
+            if (this.originEntity) {
+                this.dataSource.entities.remove(this.originEntity);
+                this.originEntity = null;
+            }
+            return;
+        }
+        const color = Color.fromCssColorString(this.options.color);
+        if (!this.originEntity) {
+            this.originEntity = this.dataSource.entities.add({
+                id: 'geo-effect-kit-scan-cone-origin',
+                position: this.getOriginCartesian(),
+                point: new PointGraphics({
+                    pixelSize: 11,
+                    color: new ConstantProperty(color),
+                    outlineColor: new ConstantProperty(Color.WHITE.withAlpha(0.72)),
+                    outlineWidth: 2,
+                    heightReference: HeightReference.CLAMP_TO_GROUND,
+                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
+                }),
+            });
+            return;
+        }
+        this.originEntity.position = new ConstantPositionProperty(this.getOriginCartesian());
+        if (this.originEntity.point)
+            this.originEntity.point.color = new ConstantProperty(color);
+    }
+    getOriginCartesian() {
+        return Cartesian3.fromDegrees(this.options.center.longitude, this.options.center.latitude, this.options.center.height ?? 0);
+    }
+    getConeCenterCartesian() {
+        return Cartesian3.fromDegrees(this.options.center.longitude, this.options.center.latitude, (this.options.center.height ?? 0) + this.options.lengthMeters / 2);
+    }
+    getConeOrientation() {
+        const heading = this.options.heading + getAnimationSeconds() * this.options.speed * 36;
+        const hpr = HeadingPitchRoll.fromDegrees(heading, this.options.pitch, 0);
+        return Transforms.headingPitchRollQuaternion(this.getConeCenterCartesian(), hpr);
+    }
+    startRenderLoop() {
+        if (this.renderFrame || !this.options.visible || typeof window === 'undefined')
+            return;
+        const tick = () => {
+            if (this.destroyed || !this.options.visible) {
+                this.renderFrame = 0;
+                return;
+            }
+            this.viewer.scene.requestRender();
+            this.renderFrame = window.requestAnimationFrame(tick);
+        };
+        this.renderFrame = window.requestAnimationFrame(tick);
+    }
+    stopRenderLoop() {
+        if (!this.renderFrame || typeof window === 'undefined') {
+            this.renderFrame = 0;
+            return;
+        }
+        window.cancelAnimationFrame(this.renderFrame);
+        this.renderFrame = 0;
+    }
+}
+export class ShieldDomeEffect {
+    viewer;
+    dataSource;
+    options;
+    domeEntity = null;
+    ringEntity = null;
+    material = null;
+    renderFrame = 0;
+    destroyed = false;
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = normalizeShieldDomeOptions(options);
+        this.dataSource = new CustomDataSource('geo-effect-kit-shield-dome');
+        this.dataSource.show = this.options.visible;
+        this.viewer.dataSources.add(this.dataSource);
+        this.renderEntities();
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    update(options) {
+        if (this.destroyed)
+            return;
+        const next = normalizeShieldDomeOptions({
+            ...this.options,
+            ...options,
+            center: options.center ?? this.options.center,
+            radiusMeters: options.radiusMeters ?? this.options.radiusMeters,
+            ring: options.ring ?? this.options.ring,
+            visible: options.visible ?? this.options.visible,
+        });
+        const rebuildEntities = shouldRebuildShieldDome(this.options, next);
+        this.options = next;
+        if (rebuildEntities) {
+            this.renderEntities();
+        }
+        else {
+            this.applyMaterialOptions();
+            this.syncRingEntity();
+        }
+        this.dataSource.show = this.options.visible;
+        if (this.options.visible)
+            this.startRenderLoop();
+        else
+            this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    show() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: true };
+        this.dataSource.show = true;
+        this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    hide() {
+        if (this.destroyed)
+            return;
+        this.options = { ...this.options, visible: false };
+        this.dataSource.show = false;
+        this.stopRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    flyTo(options = {}) {
+        if (this.destroyed)
+            return;
+        const center = Cartesian3.fromDegrees(this.options.center.longitude, this.options.center.latitude, this.options.center.height ?? 0);
+        this.viewer.camera.flyToBoundingSphere(new BoundingSphere(center, this.options.radiusMeters), {
+            duration: options.duration ?? 1,
+            offset: new HeadingPitchRange(0, options.pitch ?? -0.52, this.options.radiusMeters * (options.rangeMultiplier ?? 2.65)),
+        });
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.stopRenderLoop();
+        this.dataSource.entities.removeAll();
+        this.domeEntity = null;
+        this.ringEntity = null;
+        this.material = null;
+        this.viewer.dataSources.remove(this.dataSource, true);
+        this.viewer.scene.requestRender();
+    }
+    isVisible() {
+        return this.options.visible;
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    getOptions() {
+        return {
+            ...this.options,
+            center: { ...this.options.center },
+        };
+    }
+    renderEntities() {
+        clearEntities(this.dataSource);
+        this.ringEntity = null;
+        this.material = createShieldDomeMaterialProperty(this.options);
+        this.domeEntity = this.dataSource.entities.add({
+            id: 'geo-effect-kit-shield-dome-shell',
+            position: Cartesian3.fromDegrees(this.options.center.longitude, this.options.center.latitude, this.options.center.height ?? 0),
+            ellipsoid: {
+                radii: new Cartesian3(this.options.radiusMeters, this.options.radiusMeters, this.options.radiusMeters),
+                maximumCone: CesiumMath.PI_OVER_TWO,
+                stackPartitions: 64,
+                slicePartitions: 96,
+                material: this.material,
+                outline: false,
+            },
+        });
+        this.syncRingEntity();
+    }
+    applyMaterialOptions() {
+        if (!this.material)
+            return;
+        this.material.uniforms.color = Color.fromCssColorString(this.options.color).withAlpha(1);
+        this.material.uniforms.opacity = this.options.opacity;
+        this.material.uniforms.speed = this.options.speed;
+        this.material.uniforms.domeType = getShieldDomeTypeUniform(this.options.type);
+        this.material.uniforms.gridDensity = this.options.gridDensity;
+        this.material.uniforms.pulseStrength = this.options.pulseStrength;
+    }
+    syncRingEntity() {
+        if (!this.options.ring) {
+            if (this.ringEntity) {
+                this.dataSource.entities.remove(this.ringEntity);
+                this.ringEntity = null;
+            }
+            return;
+        }
+        const ringMaterial = Color.fromCssColorString(this.options.color).withAlpha(0.11);
+        if (this.ringEntity) {
+            if (this.ringEntity.ellipse) {
+                this.ringEntity.ellipse.semiMajorAxis = new ConstantProperty(this.options.radiusMeters);
+                this.ringEntity.ellipse.semiMinorAxis = new ConstantProperty(this.options.radiusMeters);
+                this.ringEntity.ellipse.material = new ColorMaterialProperty(ringMaterial);
+                this.ringEntity.ellipse.outlineColor = new ConstantProperty(Color.fromCssColorString(this.options.color).withAlpha(0.82));
+            }
+            return;
+        }
+        this.ringEntity = this.dataSource.entities.add({
+            id: 'geo-effect-kit-shield-dome-ground-ring',
+            position: Cartesian3.fromDegrees(this.options.center.longitude, this.options.center.latitude, this.options.center.height ?? 0),
+            ellipse: {
+                semiMajorAxis: this.options.radiusMeters,
+                semiMinorAxis: this.options.radiusMeters,
+                material: ringMaterial,
+                outline: true,
+                outlineColor: Color.fromCssColorString(this.options.color).withAlpha(0.82),
+                outlineWidth: 2,
+            },
+        });
+    }
+    startRenderLoop() {
+        if (this.renderFrame || !this.options.visible || typeof window === 'undefined')
+            return;
+        const tick = () => {
+            if (this.destroyed || !this.options.visible) {
+                this.renderFrame = 0;
+                return;
+            }
+            this.viewer.scene.requestRender();
+            this.renderFrame = window.requestAnimationFrame(tick);
+        };
+        this.renderFrame = window.requestAnimationFrame(tick);
+    }
+    stopRenderLoop() {
+        if (!this.renderFrame || typeof window === 'undefined') {
+            this.renderFrame = 0;
+            return;
+        }
+        window.cancelAnimationFrame(this.renderFrame);
+        this.renderFrame = 0;
+    }
+}
+function registerRadarScanMaterial(options) {
+    const cache = Material._materialCache;
+    if (!cache || cache.getMaterial(GEO_RADAR_SCAN_MATERIAL_TYPE))
+        return;
+    cache.addMaterial(GEO_RADAR_SCAN_MATERIAL_TYPE, {
+        fabric: {
+            type: GEO_RADAR_SCAN_MATERIAL_TYPE,
+            uniforms: {
+                color: Color.CYAN,
+                opacity: options.opacity,
+                ringsEnabled: options.rings ? 1 : 0,
+                radarType: getRadarScanTypeUniform(options.type),
+                scanDurationMs: options.scanDurationMs,
+            },
+            source: buildRadarScanMaterialSource(options),
+        },
+        translucent() {
+            return true;
+        },
+    });
+}
+function createRadarScanMaterial(options) {
+    const material = Material.fromType(GEO_RADAR_SCAN_MATERIAL_TYPE, {
+        color: Color.fromCssColorString(options.color).withAlpha(1),
+        opacity: options.opacity,
+        ringsEnabled: options.rings ? 1 : 0,
+        radarType: getRadarScanTypeUniform(options.type),
+        scanDurationMs: options.scanDurationMs,
+    });
+    return material;
+}
+function registerRippleSpreadMaterial(options) {
+    const cache = Material._materialCache;
+    if (!cache || cache.getMaterial(GEO_RIPPLE_SPREAD_MATERIAL_TYPE))
+        return;
+    cache.addMaterial(GEO_RIPPLE_SPREAD_MATERIAL_TYPE, {
+        fabric: {
+            type: GEO_RIPPLE_SPREAD_MATERIAL_TYPE,
+            uniforms: {
+                color: Color.CYAN,
+                opacity: options.opacity,
+                rippleType: getRippleSpreadTypeUniform(options.type),
+                ringCount: options.ringCount,
+                durationMs: options.durationMs,
+            },
+            source: buildRippleSpreadMaterialSource(),
+        },
+        translucent() {
+            return true;
+        },
+    });
+}
+function createRippleSpreadMaterial(options) {
+    const material = Material.fromType(GEO_RIPPLE_SPREAD_MATERIAL_TYPE, {
+        color: Color.fromCssColorString(options.color).withAlpha(1),
+        opacity: options.opacity,
+        rippleType: getRippleSpreadTypeUniform(options.type),
+        ringCount: options.ringCount,
+        durationMs: options.durationMs,
+    });
+    return material;
+}
+function registerTemperatureFieldMaterial(options) {
+    registerMaterial(GEO_TEMPERATURE_FIELD_MATERIAL_TYPE, createTemperatureFieldUniforms(options), buildTemperatureFieldMaterialSource());
+}
+function createTemperatureFieldMaterial(options) {
+    return Material.fromType(GEO_TEMPERATURE_FIELD_MATERIAL_TYPE, createTemperatureFieldUniforms(options));
+}
+function createSceneWeatherUniforms(options) {
+    return {
+        weatherType: getSceneWeatherTypeUniform(options.type),
+        intensity: options.intensity,
+        speed: options.speed,
+        windDirection: options.windDirection,
+        color: Color.fromCssColorString(options.color).withAlpha(1),
+    };
+}
+function createPostProcessUniforms(options) {
+    return {
+        effectType: getPostProcessTypeUniform(options.type),
+        strength: options.strength,
+        brightness: options.brightness,
+        contrast: options.contrast,
+        saturation: options.saturation,
+    };
+}
+function createTemperatureFieldUniforms(options) {
+    const stops = normalizeTemperatureFieldStops(options.stops);
+    const seedVector = getTemperatureFieldSeedVector(options.seed);
+    const hotSpot0 = getTemperatureFieldSpot(options.seed, 11, 0.14, 0.24);
+    const hotSpot1 = getTemperatureFieldSpot(options.seed, 29, 0.1, 0.18);
+    const coldSpot0 = getTemperatureFieldSpot(options.seed, 47, 0.18, 0.26);
+    return {
+        lowColor: Color.fromCssColorString(stops[0]?.color ?? '#57c7ff').withAlpha(1),
+        lowerColor: Color.fromCssColorString(stops[1]?.color ?? '#6ddb73').withAlpha(1),
+        mediumColor: Color.fromCssColorString(stops[2]?.color ?? '#ffd047').withAlpha(1),
+        higherColor: Color.fromCssColorString(stops[3]?.color ?? '#ff8a2d').withAlpha(1),
+        highColor: Color.fromCssColorString(stops[4]?.color ?? '#ff3e2f').withAlpha(1),
+        opacity: options.opacity,
+        noiseStrength: options.noiseStrength,
+        contourLines: options.contourLines ? 1 : 0,
+        contourStrength: options.contourStrength,
+        seedVector,
+        hotSpot0Center: hotSpot0.center,
+        hotSpot0Radius: hotSpot0.radius,
+        hotSpot0Strength: hotSpot0.strength,
+        hotSpot1Center: hotSpot1.center,
+        hotSpot1Radius: hotSpot1.radius,
+        hotSpot1Strength: hotSpot1.strength,
+        coldSpot0Center: coldSpot0.center,
+        coldSpot0Radius: coldSpot0.radius,
+        coldSpot0Strength: coldSpot0.strength,
+        ...createTemperatureFieldSampleUniforms(options),
+    };
+}
+class DynamicCesiumMaterialProperty {
+    definitionChanged = new Event();
+    isConstant = false;
+    uniforms;
+    type;
+    constructor(type, uniforms) {
+        this.type = type;
+        this.uniforms = uniforms;
+    }
+    getType(_time) {
+        return this.type;
+    }
+    getValue(_time, result = {}) {
+        return Object.assign(result, this.uniforms);
+    }
+    equals(other) {
+        return this === other;
+    }
+}
+function createLightWallMaterialProperty(options) {
+    registerLightWallMaterial();
+    return new DynamicCesiumMaterialProperty(GEO_LIGHT_WALL_MATERIAL_TYPE, {
+        color: Color.fromCssColorString(options.color).withAlpha(1),
+        opacity: options.opacity,
+        speed: options.speed,
+        wallType: getLightWallTypeUniform(options.type),
+        scanLineCount: options.scanLineCount,
+        breathing: options.breathing ? 1 : 0,
+    });
+}
+function createScanConeMaterialProperty(options) {
+    registerScanConeMaterial();
+    return new DynamicCesiumMaterialProperty(GEO_SCAN_CONE_MATERIAL_TYPE, {
+        color: Color.fromCssColorString(options.color).withAlpha(1),
+        opacity: options.opacity,
+        speed: options.speed,
+        coneType: getScanConeTypeUniform(options.type),
+        aperture: options.aperture,
+    });
+}
+function createShieldDomeMaterialProperty(options) {
+    registerShieldDomeMaterial();
+    return new DynamicCesiumMaterialProperty(GEO_SHIELD_DOME_MATERIAL_TYPE, {
+        color: Color.fromCssColorString(options.color).withAlpha(1),
+        opacity: options.opacity,
+        speed: options.speed,
+        domeType: getShieldDomeTypeUniform(options.type),
+        gridDensity: options.gridDensity,
+        pulseStrength: options.pulseStrength,
+    });
+}
+function createWaterSurfaceMaterialProperty(options) {
+    registerWaterSurfaceMaterial();
+    return new DynamicCesiumMaterialProperty(GEO_WATER_SURFACE_MATERIAL_TYPE, createWaterSurfaceUniforms(options));
+}
+function createWaterSurfaceUniforms(options) {
+    return {
+        color: Color.fromCssColorString(options.color).withAlpha(1),
+        opacity: options.opacity,
+        speed: options.speed,
+        waterType: getWaterSurfaceTypeUniform(options.type),
+        waveStrength: options.waveStrength,
+        reflectionStrength: options.reflectionStrength,
+        distortionScale: options.distortionScale,
+        reflectivity: options.reflectivity,
+        refractionStrength: options.refractionStrength,
+        fresnelPower: options.fresnelPower,
+        flowDirection: options.flowDirection,
+    };
+}
+function registerLightWallMaterial() {
+    registerMaterial(GEO_LIGHT_WALL_MATERIAL_TYPE, {
+        color: Color.CYAN,
+        opacity: 0.72,
+        speed: 1,
+        wallType: 1,
+        scanLineCount: 4,
+        breathing: 1,
+    }, buildLightWallMaterialSource());
+}
+function registerScanConeMaterial() {
+    registerMaterial(GEO_SCAN_CONE_MATERIAL_TYPE, {
+        color: Color.CYAN,
+        opacity: 0.62,
+        speed: 1,
+        coneType: 1,
+        aperture: 34,
+    }, buildScanConeMaterialSource());
+}
+function registerShieldDomeMaterial() {
+    registerMaterial(GEO_SHIELD_DOME_MATERIAL_TYPE, {
+        color: Color.CYAN,
+        opacity: 0.56,
+        speed: 1,
+        domeType: 1,
+        gridDensity: 14,
+        pulseStrength: 0.72,
+    }, buildShieldDomeMaterialSource());
+}
+function registerWaterSurfaceMaterial() {
+    registerMaterial(GEO_WATER_SURFACE_MATERIAL_TYPE, {
+        color: Color.CYAN,
+        opacity: 0.72,
+        speed: 1,
+        waterType: 1,
+        waveStrength: 0.48,
+        reflectionStrength: 0.36,
+        distortionScale: 18,
+        reflectivity: 0.58,
+        refractionStrength: 0.42,
+        fresnelPower: 4,
+        flowDirection: 90,
+    }, buildWaterSurfaceMaterialSource());
+}
+function registerMaterial(type, uniforms, source) {
+    const cache = Material._materialCache;
+    if (!cache || cache.getMaterial(type))
+        return;
+    cache.addMaterial(type, {
+        fabric: {
+            type,
+            uniforms,
+            source,
+        },
+        translucent() {
+            return true;
+        },
+    });
+}
+function normalizeRadarScanType(type) {
+    return RADAR_SCAN_TYPE_VALUES.includes(type) ? type : 'classic';
+}
+function normalizeRippleSpreadType(type) {
+    return RIPPLE_SPREAD_TYPE_VALUES.includes(type) ? type : 'water';
+}
+function normalizeSceneWeatherType(type) {
+    return SCENE_WEATHER_TYPE_VALUES.includes(type) ? type : 'rain';
+}
+function normalizePostProcessType(type) {
+    return POST_PROCESS_TYPE_VALUES.includes(type) ? type : 'bloom';
+}
+function normalizePolylineFlowType(type) {
+    return POLYLINE_FLOW_TYPE_VALUES.includes(type) ? type : 'dispatch';
+}
+function normalizeFlyLineMode(mode) {
+    return FLY_LINE_MODE_VALUES.includes(mode) ? mode : 'single-arc';
+}
+function normalizeLightWallType(type) {
+    return LIGHT_WALL_TYPE_VALUES.includes(type) ? type : 'security';
+}
+function normalizeScanConeType(type) {
+    return SCAN_CONE_TYPE_VALUES.includes(type) ? type : 'searchlight';
+}
+function normalizeShieldDomeType(type) {
+    return SHIELD_DOME_TYPE_VALUES.includes(type) ? type : 'hex';
+}
+function normalizeWaterSurfaceType(type) {
+    return WATER_SURFACE_TYPE_VALUES.includes(type) ? type : 'river';
+}
+function getRadarScanTypeUniform(type) {
+    if (type === 'classic')
+        return 1;
+    if (type === 'sector')
+        return 2;
+    if (type === 'pulse')
+        return 3;
+    return 4;
+}
+function getRippleSpreadTypeUniform(type) {
+    if (type === 'water')
+        return 1;
+    if (type === 'energy')
+        return 2;
+    return 3;
+}
+function getSceneWeatherTypeUniform(type) {
+    if (type === 'rain')
+        return 1;
+    if (type === 'snow')
+        return 2;
+    if (type === 'fog')
+        return 3;
+    return 4;
+}
+function getPostProcessTypeUniform(type) {
+    if (type === 'bloom')
+        return 1;
+    if (type === 'night-vision')
+        return 2;
+    if (type === 'black-white')
+        return 3;
+    if (type === 'brightness')
+        return 4;
+    if (type === 'mosaic')
+        return 5;
+    return 6;
+}
+function getLightWallTypeUniform(type) {
+    if (type === 'security')
+        return 1;
+    if (type === 'warning')
+        return 2;
+    if (type === 'data')
+        return 3;
+    if (type === 'fence')
+        return 4;
+    return 5;
+}
+function getScanConeTypeUniform(type) {
+    if (type === 'searchlight')
+        return 1;
+    if (type === 'radar')
+        return 2;
+    if (type === 'camera')
+        return 3;
+    if (type === 'drone')
+        return 4;
+    return 5;
+}
+function getShieldDomeTypeUniform(type) {
+    if (type === 'hex')
+        return 1;
+    if (type === 'plasma')
+        return 2;
+    if (type === 'matrix')
+        return 3;
+    if (type === 'aegis')
+        return 4;
+    return 5;
+}
+function getWaterSurfaceTypeUniform(type) {
+    if (type === 'river')
+        return 1;
+    if (type === 'lake')
+        return 2;
+    return 3;
+}
+function getPolylineFlowColor(type, color) {
+    const base = Color.fromCssColorString(color);
+    if (type === 'migration')
+        return Color.lerp(base, Color.fromCssColorString('#b8ff58'), 0.28, new Color());
+    if (type === 'attack')
+        return Color.lerp(base, Color.fromCssColorString('#ff315a'), 0.42, new Color());
+    if (type === 'comet')
+        return Color.lerp(base, Color.fromCssColorString('#ffffff'), 0.32, new Color());
+    if (type === 'electric')
+        return Color.lerp(base, Color.fromCssColorString('#9b6dff'), 0.38, new Color());
+    return base;
+}
+function getPolylineFlowProfile(type) {
+    if (type === 'migration')
+        return { tail: 2, power: 1 };
+    if (type === 'attack')
+        return { tail: 1.6, power: 1.35 };
+    if (type === 'comet')
+        return { tail: 1.72, power: 1 };
+    if (type === 'electric')
+        return { tail: 1.35, power: 0.72 };
+    return { tail: 1.72, power: 1 };
+}
+function getTrailSampleCount(type) {
+    if (type === 'attack')
+        return 5;
+    if (type === 'electric')
+        return 9;
+    if (type === 'migration')
+        return 8;
+    return 7;
+}
+function getFlyLineBaseSampleCount(mode) {
+    if (mode === 'hub-spoke')
+        return 28;
+    if (mode === 'bidirectional')
+        return 30;
+    return 26;
+}
+function getFlyLineTrailSampleCount(mode) {
+    if (mode === 'hub-spoke')
+        return 8;
+    if (mode === 'bidirectional')
+        return 7;
+    return 6;
+}
+function getFlyLineSpeedScale(mode) {
+    if (mode === 'hub-spoke')
+        return 0.24;
+    if (mode === 'bidirectional')
+        return 0.28;
+    return 0.22;
+}
+function getFlyLineBaseColor(mode, color) {
+    const base = Color.fromCssColorString(color);
+    if (mode === 'hub-spoke')
+        return Color.lerp(base, Color.fromCssColorString('#ff58c8'), 0.18, new Color());
+    if (mode === 'bidirectional')
+        return Color.lerp(base, Color.WHITE, 0.16, new Color());
+    return base;
+}
+function getFlyLineTrailColor(mode, color) {
+    const base = Color.fromCssColorString(color);
+    if (mode === 'hub-spoke')
+        return Color.lerp(base, Color.fromCssColorString('#ff58c8'), 0.34, new Color());
+    if (mode === 'bidirectional')
+        return Color.lerp(base, Color.fromCssColorString('#e8ff72'), 0.3, new Color());
+    return Color.lerp(base, Color.WHITE, 0.18, new Color());
+}
+function getPipeLayerWidth(width, multiplier) {
+    return Math.max(1, Math.round(width * multiplier * 1000) / 1000);
+}
+function getConeBottomRadius(options) {
+    const apertureRadius = Math.tan(CesiumMath.toRadians(options.aperture) / 2) * options.lengthMeters;
+    return Math.max(options.radiusMeters, apertureRadius);
+}
+function normalizePositions(positions, close) {
+    const normalized = (positions.length ? positions : [{ longitude: 0, latitude: 0 }]).map(normalizePosition);
+    const onlyPosition = normalized[0];
+    if (normalized.length === 1 && onlyPosition)
+        normalized.push({ ...onlyPosition });
+    if (close && normalized.length > 2) {
+        const first = normalized[0];
+        const last = normalized[normalized.length - 1];
+        if (first && last && !positionEqual(first, last))
+            normalized.push({ ...first });
+    }
+    return normalized;
+}
+function normalizeFlyLineRoutes(lines) {
+    const fallback = {
+        from: { longitude: 0, latitude: 0 },
+        to: { longitude: 0, latitude: 0 },
+    };
+    return (lines.length ? lines : [fallback]).map((line) => ({
+        from: normalizePosition(line.from),
+        to: normalizePosition(line.to),
+    }));
+}
+function normalizePosition(position) {
+    const normalized = {
+        longitude: finiteOr(position.longitude, 0),
+        latitude: finiteOr(position.latitude, 0),
+    };
+    if (position.height !== undefined)
+        normalized.height = finiteOr(position.height, 0);
+    return normalized;
+}
+function normalizeFireBillboardPoints(points) {
+    return points
+        .filter((point) => typeof point.gif === 'string' && point.gif.trim().length > 0)
+        .map((point) => {
+        const normalized = {
+            longitude: finiteOr(point.longitude, 0),
+            latitude: finiteOr(point.latitude, 0),
+            height: finiteOr(point.height ?? 0, 0),
+            gif: point.gif.trim(),
+        };
+        if (point.id)
+            normalized.id = point.id;
+        if (point.label)
+            normalized.label = point.label;
+        return normalized;
+    });
+}
+function cloneFireBillboardPoints(points) {
+    return points.map((point) => ({ ...point }));
+}
+function fireBillboardPointsEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((point, index) => {
+        const other = right[index];
+        return (other !== undefined &&
+            point.longitude === other.longitude &&
+            point.latitude === other.latitude &&
+            (point.height ?? 0) === (other.height ?? 0) &&
+            point.gif === other.gif &&
+            point.id === other.id &&
+            point.label === other.label);
+    });
+}
+function normalizeTemperatureFieldPolygons(polygons) {
+    return polygons
+        .map((polygon) => ({
+        outer: normalizeTemperatureRing(polygon.outer),
+        holes: (polygon.holes ?? []).map(normalizeTemperatureRing).filter((hole) => hole.length >= 3),
+    }))
+        .filter((polygon) => polygon.outer.length >= 3);
+}
+function normalizeTemperatureRing(ring) {
+    return ring.map(([longitude, latitude]) => [finiteOr(longitude, 0), finiteOr(latitude, 0)]);
+}
+function normalizeTemperatureFieldStops(stops = getDefaultTemperatureFieldStops()) {
+    const sortedStops = [...(stops.length ? stops : getDefaultTemperatureFieldStops())]
+        .map((stop) => ({
+        value: clamp(finiteOr(stop.value, 0), 0, 100),
+        color: stop.color || '#57c7ff',
+        label: stop.label ?? '',
+    }))
+        .sort((a, b) => a.value - b.value);
+    if (sortedStops.length >= 5) {
+        return sortedStops.slice(0, 5);
+    }
+    const defaults = getDefaultTemperatureFieldStops();
+    return defaults.map((fallback, index) => sortedStops[index] ?? fallback);
+}
+function getDefaultTemperatureFieldStops() {
+    return [
+        { value: 0, color: '#57c7ff', label: 'low' },
+        { value: 20, color: '#6ddb73', label: 'lower' },
+        { value: 40, color: '#ffd047', label: 'medium' },
+        { value: 60, color: '#ff8a2d', label: 'higher' },
+        { value: 100, color: '#ff3e2f', label: 'high' },
+    ];
+}
+function normalizeTemperatureFieldSamples(samples = []) {
+    return samples
+        .map((sample) => ({
+        longitude: finiteOr(sample.longitude, 0),
+        latitude: finiteOr(sample.latitude, 0),
+        value: clamp(finiteOr(sample.value, 0), 0, 100),
+        type: sample.type ?? '',
+    }))
+        .filter((sample) => sample.longitude >= -180 && sample.longitude <= 180 && sample.latitude >= -90 && sample.latitude <= 90)
+        .slice(0, 16);
+}
+function normalizeTemperatureFieldBounds(bounds) {
+    if (!bounds)
+        return null;
+    return {
+        west: finiteOr(bounds.west, 0),
+        south: finiteOr(bounds.south, 0),
+        east: finiteOr(bounds.east, 0),
+        north: finiteOr(bounds.north, 0),
+    };
+}
+function getTemperatureFieldBounds(polygons) {
+    const points = polygons.flatMap((polygon) => [polygon.outer, ...polygon.holes]).flat();
+    if (points.length === 0)
+        return null;
+    return points.reduce((bounds, [longitude, latitude]) => ({
+        west: Math.min(bounds.west, longitude),
+        south: Math.min(bounds.south, latitude),
+        east: Math.max(bounds.east, longitude),
+        north: Math.max(bounds.north, latitude),
+    }), {
+        west: Number.POSITIVE_INFINITY,
+        south: Number.POSITIVE_INFINITY,
+        east: Number.NEGATIVE_INFINITY,
+        north: Number.NEGATIVE_INFINITY,
+    });
+}
+function normalizeSeed(seed) {
+    const value = finiteOr(seed ?? 0, 0);
+    return Math.max(0, Math.floor(value));
+}
+function temperatureFieldPolygonsEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((polygon, index) => {
+        const other = right[index];
+        if (!other)
+            return false;
+        if (!temperatureRingsEqual(polygon.outer, other.outer))
+            return false;
+        if (polygon.holes.length !== other.holes.length)
+            return false;
+        return polygon.holes.every((hole, holeIndex) => temperatureRingsEqual(hole, other.holes[holeIndex] ?? []));
+    });
+}
+function temperatureRingsEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((point, index) => {
+        const other = right[index];
+        return other !== undefined && point[0] === other[0] && point[1] === other[1];
+    });
+}
+function cloneTemperatureFieldOptions(options) {
+    return {
+        ...options,
+        bounds: options.bounds ? { ...options.bounds } : null,
+        polygons: options.polygons.map((polygon) => ({
+            outer: polygon.outer.map(([longitude, latitude]) => [longitude, latitude]),
+            holes: polygon.holes.map((hole) => hole.map(([longitude, latitude]) => [longitude, latitude])),
+        })),
+        stops: options.stops.map((stop) => ({ ...stop })),
+        samples: options.samples.map((sample) => ({ ...sample })),
+    };
+}
+function isTemperatureRingClosed(ring) {
+    const first = ring[0];
+    const last = ring[ring.length - 1];
+    return Boolean(first && last && first[0] === last[0] && first[1] === last[1]);
+}
+function getTemperatureFieldSeedVector(seed) {
+    const angle = seededUnit(seed, 3) * Math.PI * 2;
+    return new Cartesian4(Math.cos(angle), Math.sin(angle), seededUnit(seed, 7), seededUnit(seed, 13));
+}
+function getTemperatureFieldSpot(seed, offset, minRadius, maxRadius) {
+    return {
+        center: new Cartesian2(0.18 + seededUnit(seed, offset) * 0.64, 0.16 + seededUnit(seed, offset + 5) * 0.68),
+        radius: minRadius + seededUnit(seed, offset + 11) * (maxRadius - minRadius),
+        strength: 0.12 + seededUnit(seed, offset + 17) * 0.24,
+    };
+}
+function createTemperatureFieldSampleUniforms(options) {
+    const uniforms = {
+        sampleCount: options.bounds ? options.samples.length : 0,
+    };
+    for (let index = 0; index < 16; index += 1) {
+        const sample = options.samples[index];
+        uniforms[`sample${index}`] =
+            sample && options.bounds ? getTemperatureFieldSampleVector(sample, options.bounds, index) : new Cartesian4(0, 0, 0, 0);
+    }
+    return uniforms;
+}
+function getTemperatureFieldSampleVector(sample, bounds, index) {
+    const width = Math.max(0.000001, bounds.east - bounds.west);
+    const height = Math.max(0.000001, bounds.north - bounds.south);
+    return new Cartesian4(clamp01((sample.longitude - bounds.west) / width), clamp01((sample.latitude - bounds.south) / height), sample.value / 100, 0.4 + seededUnit(Math.round(sample.value * 10), index + 101) * 0.6);
+}
+function seededUnit(seed, offset) {
+    const value = Math.sin((seed + 1) * (offset + 12.9898) * 78.233) * 43_758.5453;
+    return fract(value);
+}
+function clonePositions(positions) {
+    return positions.map((position) => ({ ...position }));
+}
+function cloneFlyLineRoutes(lines) {
+    return lines.map((line) => ({
+        from: { ...line.from },
+        to: { ...line.to },
+    }));
+}
+function positionsEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((position, index) => {
+        const other = right[index];
+        return other !== undefined && positionEqual(position, other);
+    });
+}
+function flyLineRoutesEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((line, index) => {
+        const other = right[index];
+        return other !== undefined && positionEqual(line.from, other.from) && positionEqual(line.to, other.to);
+    });
+}
+function uniqueFlyLineEndpoints(lines) {
+    const endpoints = [];
+    normalizeFlyLineRoutes(lines).forEach((line) => {
+        pushDistinctEndpoint(endpoints, line.from);
+        pushDistinctEndpoint(endpoints, line.to);
+    });
+    return endpoints;
+}
+function pushDistinctEndpoint(endpoints, position) {
+    if (!endpoints.some((endpoint) => positionEqual(endpoint, position)))
+        endpoints.push({ ...position });
+}
+function positionEqual(left, right) {
+    return (left.longitude === right.longitude &&
+        left.latitude === right.latitude &&
+        (left.height ?? 0) === (right.height ?? 0));
+}
+function positionsToCartesians(positions) {
+    return positions.map((position) => Cartesian3.fromDegrees(position.longitude, position.latitude, position.height ?? 0));
+}
+function positionsToCartesiansAtHeight(positions, heightOffset) {
+    return positions.map((position) => Cartesian3.fromDegrees(position.longitude, position.latitude, (position.height ?? 0) + heightOffset));
+}
+function roundPolylineCorners(positions, radius) {
+    if (radius <= 0 || positions.length < 3)
+        return positions;
+    const rounded = [{ ...(positions[0] ?? { longitude: 0, latitude: 0 }) }];
+    for (let index = 1; index < positions.length - 1; index += 1) {
+        const previous = positions[index - 1];
+        const corner = positions[index];
+        const next = positions[index + 1];
+        if (!previous || !corner || !next || positionEqual(previous, corner) || positionEqual(corner, next)) {
+            if (corner)
+                rounded.push({ ...corner });
+            continue;
+        }
+        const before = lerpPosition(corner, previous, radius);
+        const after = lerpPosition(corner, next, radius);
+        pushDistinctPosition(rounded, before);
+        for (let step = 1; step < 6; step += 1) {
+            const amount = step / 6;
+            pushDistinctPosition(rounded, quadraticBezierPosition(before, corner, after, amount));
+        }
+        pushDistinctPosition(rounded, after);
+    }
+    pushDistinctPosition(rounded, { ...(positions[positions.length - 1] ?? positions[0] ?? { longitude: 0, latitude: 0 }) });
+    return rounded;
+}
+function lerpPosition(start, end, amount) {
+    const t = clamp01(amount);
+    return {
+        longitude: lerp(start.longitude, end.longitude, t),
+        latitude: lerp(start.latitude, end.latitude, t),
+        height: lerp(start.height ?? 0, end.height ?? 0, t),
+    };
+}
+function quadraticBezierPosition(start, control, end, amount) {
+    const t = clamp01(amount);
+    const inverse = 1 - t;
+    return {
+        longitude: inverse * inverse * start.longitude + 2 * inverse * t * control.longitude + t * t * end.longitude,
+        latitude: inverse * inverse * start.latitude + 2 * inverse * t * control.latitude + t * t * end.latitude,
+        height: inverse * inverse * (start.height ?? 0) + 2 * inverse * t * (control.height ?? 0) + t * t * (end.height ?? 0),
+    };
+}
+function pushDistinctPosition(positions, position) {
+    const previous = positions[positions.length - 1];
+    if (!previous || !positionEqual(previous, position))
+        positions.push(position);
+}
+function clearEntities(dataSource) {
+    if (dataSource.entities.values.length > 0)
+        dataSource.entities.removeAll();
+}
+const gifFrameImageCache = new Map();
+const GIF_FETCH_TIMEOUT_MS = 5000;
+function loadGifFrameImages(gif) {
+    const cached = gifFrameImageCache.get(gif);
+    if (cached)
+        return cached;
+    const promise = decodeGifFrameImages(gif).catch(() => {
+        gifFrameImageCache.delete(gif);
+        return [gif];
+    });
+    gifFrameImageCache.set(gif, promise);
+    return promise;
+}
+async function decodeGifFrameImages(gif) {
+    if (typeof fetch !== 'function' || typeof document === 'undefined')
+        return [gif];
+    const response = await fetchWithTimeout(gif, GIF_FETCH_TIMEOUT_MS);
+    if (!response.ok)
+        throw new Error(`Failed to load GIF: ${response.status}`);
+    const buffer = await response.arrayBuffer();
+    const parsed = parseGIF(buffer);
+    const frames = decompressFrames(parsed, true);
+    if (frames.length <= 1)
+        return [gif];
+    return renderGifFramesToDataUrls(frames, parsed.lsd.width, parsed.lsd.height, gif);
+}
+function fetchWithTimeout(url, timeoutMs) {
+    if (typeof AbortController !== 'function')
+        return fetch(url);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    return fetch(url, { signal: controller.signal }).finally(() => {
+        clearTimeout(timer);
+    });
+}
+function renderGifFramesToDataUrls(frames, width, height, fallback) {
+    const canvas = document.createElement('canvas');
+    canvas.width = Math.max(1, finiteOr(width, 1));
+    canvas.height = Math.max(1, finiteOr(height, 1));
+    const context = canvas.getContext('2d');
+    if (!context)
+        return [fallback];
+    const previousCanvas = document.createElement('canvas');
+    previousCanvas.width = canvas.width;
+    previousCanvas.height = canvas.height;
+    const previousContext = previousCanvas.getContext('2d');
+    const imageUrls = [];
+    frames.forEach((frame) => {
+        const previousImage = frame.disposalType === 3 && previousContext ? context.getImageData(0, 0, canvas.width, canvas.height) : null;
+        const imageData = context.createImageData(frame.dims.width, frame.dims.height);
+        imageData.data.set(frame.patch);
+        context.putImageData(imageData, frame.dims.left, frame.dims.top);
+        imageUrls.push(canvas.toDataURL('image/png'));
+        if (frame.disposalType === 2) {
+            context.clearRect(frame.dims.left, frame.dims.top, frame.dims.width, frame.dims.height);
+        }
+        else if (frame.disposalType === 3 && previousImage && previousContext) {
+            previousContext.putImageData(previousImage, 0, 0);
+            context.clearRect(0, 0, canvas.width, canvas.height);
+            context.drawImage(previousCanvas, 0, 0);
+        }
+    });
+    return imageUrls.length > 0 ? imageUrls : [fallback];
+}
+function getPositionBounds(positions, fallbackRadius) {
+    const cartesians = positionsToCartesians(positions);
+    const sphere = BoundingSphere.fromPoints(cartesians);
+    return {
+        center: sphere.center,
+        radius: Math.max(fallbackRadius, sphere.radius),
+    };
+}
+export function expandFlyLineRoutes(lines, mode = 'single-arc') {
+    const routes = normalizeFlyLineRoutes(lines);
+    if (normalizeFlyLineMode(mode) !== 'bidirectional')
+        return cloneFlyLineRoutes(routes);
+    return routes.flatMap((line) => [
+        { from: { ...line.from }, to: { ...line.to } },
+        { from: { ...line.to }, to: { ...line.from } },
+    ]);
+}
+export function sampleFlyLineArc(line, arcHeight = 38000, sampleCount = 28) {
+    const route = normalizeFlyLineRoutes([line])[0];
+    if (!route)
+        return [];
+    const samples = clampInteger(finiteOr(sampleCount, 28), 2, 96);
+    const height = Math.max(0, finiteOr(arcHeight, 0));
+    const fromHeight = route.from.height ?? 0;
+    const toHeight = route.to.height ?? 0;
+    const control = {
+        longitude: (route.from.longitude + route.to.longitude) / 2,
+        latitude: (route.from.latitude + route.to.latitude) / 2,
+        height: Math.max(fromHeight, toHeight) + height * 2,
+    };
+    return Array.from({ length: samples }, (_, index) => {
+        if (index === 0)
+            return { ...route.from };
+        if (index === samples - 1)
+            return { ...route.to };
+        const amount = index / Math.max(1, samples - 1);
+        return quadraticBezierPosition(route.from, control, route.to, amount);
+    });
+}
+export function sampleFlyLineTrail(line, arcHeight, progress, trailLength, sampleCount) {
+    const arc = sampleFlyLineArc(line, arcHeight, Math.max(24, sampleCount * 4));
+    return samplePolylineTrail(arc, progress, trailLength, sampleCount);
+}
+function samplePolylineTrail(positions, progress, trailLength, sampleCount) {
+    const safePositions = normalizePositions(positions, false);
+    const samples = clampInteger(sampleCount, 2, 16);
+    const distances = getPolylineCumulativeDistances(safePositions);
+    const totalDistance = distances[distances.length - 1] ?? 0;
+    if (totalDistance <= 0)
+        return safePositions;
+    const head = fract(progress) * totalDistance;
+    const length = clamp01(trailLength) * totalDistance;
+    const start = Math.max(0, head - length);
+    const sampledDistances = Array.from({ length: samples }, (_, index) => {
+        const amount = index / Math.max(1, samples - 1);
+        return lerp(start, head, amount);
+    });
+    const vertexDistances = distances.filter((distance) => distance > start && distance < head);
+    const targetDistances = uniqueSortedDistances([...sampledDistances, ...vertexDistances]);
+    return targetDistances.map((distance) => interpolatePolylinePosition(safePositions, distances, distance));
+}
+function getPolylineCumulativeDistances(positions) {
+    const distances = [0];
+    for (let index = 1; index < positions.length; index += 1) {
+        const previous = positions[index - 1];
+        const current = positions[index];
+        if (!previous || !current)
+            continue;
+        const previousCartesian = Cartesian3.fromDegrees(previous.longitude, previous.latitude, previous.height ?? 0);
+        const currentCartesian = Cartesian3.fromDegrees(current.longitude, current.latitude, current.height ?? 0);
+        distances.push((distances[distances.length - 1] ?? 0) + Cartesian3.distance(previousCartesian, currentCartesian));
+    }
+    return distances;
+}
+function interpolatePolylinePosition(positions, distances, targetDistance) {
+    if (targetDistance <= 0)
+        return { ...(positions[0] ?? { longitude: 0, latitude: 0 }) };
+    for (let index = 1; index < distances.length; index += 1) {
+        const previousDistance = distances[index - 1] ?? 0;
+        const currentDistance = distances[index] ?? previousDistance;
+        if (targetDistance > currentDistance)
+            continue;
+        const previous = positions[index - 1] ?? positions[0];
+        const current = positions[index] ?? previous;
+        if (!previous || !current)
+            return { longitude: 0, latitude: 0 };
+        const span = Math.max(1, currentDistance - previousDistance);
+        const t = clamp01((targetDistance - previousDistance) / span);
+        return {
+            longitude: lerp(previous.longitude, current.longitude, t),
+            latitude: lerp(previous.latitude, current.latitude, t),
+            height: lerp(previous.height ?? 0, current.height ?? 0, t),
+        };
+    }
+    return { ...(positions[positions.length - 1] ?? positions[0] ?? { longitude: 0, latitude: 0 }) };
+}
+function uniqueSortedDistances(distances) {
+    const epsilon = 1e-6;
+    return [...distances].sort((first, second) => first - second).filter((distance, index, sorted) => {
+        const previous = sorted[index - 1];
+        return previous === undefined || Math.abs(distance - previous) > epsilon;
+    });
+}
+function getAnimationSeconds() {
+    if (typeof performance !== 'undefined')
+        return performance.now() / 1000;
+    return Date.now() / 1000;
+}
+function fract(value) {
+    return value - Math.floor(value);
+}
+function lerp(start, end, amount) {
+    return start + (end - start) * amount;
+}
+function roundWeight(value) {
+    return Math.round(value * 100) / 100;
+}
+function finiteOr(value, fallback) {
+    return Number.isFinite(value) ? value : fallback;
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function clampInteger(value, min, max) {
+    return Math.max(min, Math.min(max, Math.round(value)));
+}
+function clamp01(value) {
+    return Math.max(0, Math.min(1, value));
+}
+//# sourceMappingURL=index.js.map