leiting-bim 2.1.36 → 2.1.39

package/plugins/plugins/cesium-core/src/components/Material/help/PolylineFlowMaterialProperty.ts

@@ -0,0 +1,116 @@
+interface PolylineFlowMaterialOptions {
+  color?: any; // 一般是 Cesium.Color | Cesium.Property
+  duration?: number; // 流动持续时间
+  materialType?: string;
+}
+
+/**
+ * 注册 polyline 流动材质并返回对应的 MaterialProperty
+ */
+export function getPolylineFlowMaterialProperty(
+  Cesium: any,
+  options: PolylineFlowMaterialOptions,
+): any {
+  const Color = Cesium.Color;
+  const defaultValue = Cesium.defaultValue;
+  const defineProperties = Object.defineProperties;
+  const Event = Cesium.Event;
+  const createPropertyDescriptor = Cesium.createPropertyDescriptor;
+  const Property = Cesium.Property;
+  
+  let _materialType =
+    options.materialType || 'PolylineFlow' + Date.now() + Math.floor(Math.random() * 1000);
+
+  // 构造函数保持 function + prototype 形式
+  function PolylineFlowMaterialProperty(this: any, opts: PolylineFlowMaterialOptions) {
+    opts = defaultValue(opts, defaultValue.EMPTY_OBJECT);
+    this._definitionChanged = new Event();
+    this._color = undefined;
+    this._colorSubscription = undefined;
+    this.color = opts.color || Color.fromBytes(0, 255, 255, 255);
+    this._duration = undefined;
+    this._durationSubscription = undefined;
+    this.duration = defaultValue(opts.duration, 45);
+  }
+
+  defineProperties(PolylineFlowMaterialProperty.prototype, {
+    isConstant: {
+      get(): boolean {
+        return false;
+      },
+    },
+    definitionChanged: {
+      get(): any {
+        return this._definitionChanged;
+      },
+    },
+  });
+
+  PolylineFlowMaterialProperty.prototype.getType = function (_time: any): string {
+    return _materialType;
+  };
+
+  PolylineFlowMaterialProperty.prototype.getValue = function (time: any, result?: any): any {
+    if (!result) {
+      result = {};
+    }
+    result.color = Property.getValueOrClonedDefault(
+      this._color,
+      time,
+      Cesium.Color.WHITE,
+      result.color,
+    );
+    result.duration = this._duration;
+    return result;
+  };
+
+  PolylineFlowMaterialProperty.prototype.equals = function (other?: any): boolean {
+    return (
+      this === other ||
+      (other instanceof PolylineFlowMaterialProperty &&
+        Property.equals(this._color, (other as any)._color))
+    );
+  };
+
+  defineProperties(PolylineFlowMaterialProperty.prototype, {
+    color: createPropertyDescriptor('color'),
+    duration: createPropertyDescriptor('duration'),
+  });
+
+  // 挂到 Cesium 方便外部直接使用
+  Cesium.PolylineFlowMaterialProperty = PolylineFlowMaterialProperty;
+
+  Cesium.Material._materialCache.addMaterial(_materialType, {
+    fabric: {
+      type: _materialType,
+      uniforms: {
+        color: new Color(1.0, 1.0, 1.0, 1),
+        duration: 45,
+      },
+      source: (function () {
+        return `uniform vec4 color;
+        uniform float duration;
+        czm_material czm_getMaterial(czm_materialInput materialInput){
+          czm_material material = czm_getDefaultMaterial(materialInput);
+          vec2 st = materialInput.st;
+          float t = fract(czm_frameNumber / duration);
+          t *= 1.03;
+          float alpha = smoothstep(t - 0.03, t, st.s) * step(-t, -st.s);
+          alpha += 0.2;
+          vec4 fragColor;
+          fragColor.rgb = color.rgb;
+          fragColor = czm_gammaCorrect(fragColor);
+          material.diffuse = fragColor.rgb;
+          material.alpha = alpha;
+          material.emission = fragColor.rgb;
+          return material;
+        }`;
+      })(),
+    },
+    translucent(): boolean {
+      return true;
+    },
+  });
+
+  return new (PolylineFlowMaterialProperty as any)(options);
+}

package/plugins/plugins/cesium-core/src/components/Material/help/dynamicImgMaterial.ts

@@ -0,0 +1,236 @@
+interface DynamicImgMaterialOptions {
+  color?: any; // 通常是 Cesium.Color | Cesium.Property
+  duration?: number;
+  image: string;
+  count: number;
+  freely?: 'vertical' | 'horizontal';
+  direction: string; // 例如 '+' 或 '-'，传给 GLSL
+  isCustomColor?: boolean;
+  materialType?: string;
+}
+
+/**
+ * 注册动态图片材质并返回 TrailLineMaterialProperty 实例
+ */
+export function getDynamicImgMaterial(Cesium: any, options: DynamicImgMaterialOptions): any {
+  const MaterialType =
+    options.materialType || 'DynamicImgMaterial' + Date.now() + Math.floor(Math.random() * 1000);
+
+  // 构造材质属性的构造函数 —— 保留 function + prototype 形式
+  function TrailLineMaterialProperty(this: any, opts: DynamicImgMaterialOptions) {
+    this._definitionChanged = new Cesium.Event();
+    this._color = opts.color;
+    this._colorSubscription = undefined;
+    this.color = opts.color;
+    this.duration = opts.duration;
+    this._time = Date.now();
+  }
+
+  Object.defineProperties(TrailLineMaterialProperty.prototype, {
+    isConstant: {
+      get(): boolean {
+        return false;
+      },
+    },
+    definitionChanged: {
+      get(): any {
+        return this._definitionChanged;
+      },
+    },
+    color: Cesium.createPropertyDescriptor('color'),
+  });
+
+  TrailLineMaterialProperty.prototype.getType = function (): string {
+    return MaterialType;
+  };
+
+  TrailLineMaterialProperty.prototype.getValue = function (time: any, result?: any): any {
+    if (!Cesium.defined(result)) {
+      result = {};
+    }
+    result.color = Cesium.Property.getValueOrClonedDefault(
+      this._color,
+      time,
+      Cesium.Color.WHITE,
+      result.color,
+    );
+    result.image = options.image;
+    // if (this.duration) {
+    //   result.time = ((Date.now() - this._time) % this.duration) / this.duration;
+    // }
+    return result;
+  };
+
+  TrailLineMaterialProperty.prototype.equals = function (other: any): boolean {
+    return (
+      this === other ||
+      (other instanceof TrailLineMaterialProperty &&
+        Cesium.Property.equals(this._color, (other as any)._color))
+    );
+  };
+
+  // 着色器源码生成
+  const _getWallShader = function (opts: {
+    count: number;
+    freely: string;
+    direction: string;
+    duration: number;
+    isCustomColor?: boolean;
+  }): string {
+    let material = `
+      czm_material czm_getMaterial(czm_materialInput materialInput)
+      {
+      czm_material material = czm_getDefaultMaterial(materialInput);
+      vec2 st = materialInput.st;
+      float time = fract(mod(float(czm_frameNumber * 33.0) , float(${opts.duration})) / float(${opts.duration}));
+      ${
+        opts.freely === 'vertical'
+          ? `vec4 colorImage = texture(image, vec2(fract(float(${opts.count}) *st.t ${opts.direction} time), fract(st.s)));`
+          : `vec4 colorImage = texture(image, vec2(fract(float(${opts.count}) *st.s ${opts.direction} time), fract(st.t)));`
+      }
+      ${opts.isCustomColor ? 'material.diffuse = color.rgb;' : 'material.diffuse = colorImage.rgb;'}
+       material.alpha = colorImage.a;\n\
+      return material;\n\
+      }`;
+    return material;
+  };
+
+  Cesium.Material._materialCache.addMaterial(MaterialType, {
+    fabric: {
+      type: MaterialType,
+      uniforms: {
+        color: options.color,
+        image: options.image,
+        time: 1000,
+      },
+      source: _getWallShader({
+        count: options.count,
+        freely: options.freely || '',
+        direction: options.direction,
+        duration: options.duration || 100,
+        isCustomColor: options.isCustomColor,
+      }),
+    },
+    translucent(): boolean {
+      return true;
+    },
+  });
+
+  return new (TrailLineMaterialProperty as any)(options);
+}
+
+export function getWallMaterial(Cesium: any, options: any) {
+  const MaterialType =
+    options.MaterialType || 'wallType' + new Date().getTime() + parseInt(Math.random() * 1000 + '');
+  function TrailLineMaterialProperty(this: any, options: any) {
+    // 默认参数设置
+    this._definitionChanged = new Cesium.Event();
+    this._color = undefined;
+    this._colorSubscription = undefined;
+    this.color = options.color;
+    this.duration = options.duration;
+    this._time = new Date().getTime();
+  }
+  Object.defineProperties(TrailLineMaterialProperty.prototype, {
+    isConstant: {
+      get: function () {
+        return false;
+      },
+    },
+    definitionChanged: {
+      get: function (this: any) {
+        return this._definitionChanged;
+      },
+    },
+    color: Cesium.createPropertyDescriptor('color'),
+  });
+  TrailLineMaterialProperty.prototype.getType = function () {
+    return MaterialType;
+  };
+  TrailLineMaterialProperty.prototype.getValue = function (this: any, time: any, result: any) {
+    if (!Cesium.defined(result)) {
+      result = {};
+    }
+    // result.color = Cesium.Property.getValueOrClonedDefault(
+    //   this._color,
+    //   time,
+    //   Cesium.Color.WHITE,
+    //   result.color,
+    // );
+    result.image = options.image;
+    if (this.duration) {
+      result.time = ((new Date().getTime() - this._time) % this.duration) / this.duration;
+    }
+    return result;
+  };
+  TrailLineMaterialProperty.prototype.equals = function (this: any, other: any) {
+    return (
+      this === other ||
+      (other instanceof TrailLineMaterialProperty &&
+        Cesium.Property.equals(this._color, (other as any)._color))
+    );
+  };
+
+  const _getWallShader = function (options: any) {
+    let materail =
+      'czm_material czm_getMaterial(czm_materialInput materialInput)\n\
+            {\n\
+            czm_material material = czm_getDefaultMaterial(materialInput);\n\
+            vec2 st = materialInput.st;\n\
+            \n ';
+    if (options.freely == 'vertical') {
+      //（由下到上）
+
+      materail +=
+        'vec4 colorImage = texture(image, vec2(fract(float(' +
+        options.count +
+        ')*st.t ' +
+        options.direction +
+        ' time), fract(st.s)));\n ';
+    } else {
+      //（逆时针）
+
+      materail +=
+        'vec4 colorImage = texture(image, vec2(fract(float(' +
+        options.count +
+        ')*st.s ' +
+        options.direction +
+        ' time), fract(st.t)));\n ';
+    }
+    //泛光
+    materail +=
+      'vec4 fragColor;\n\
+            fragColor.rgb = (colorImage.rgb) / 1.0;\n\
+            fragColor = czm_gammaCorrect(fragColor);\n ';
+
+    materail +=
+      ' material.diffuse = colorImage.rgb;\n\
+            material.alpha = colorImage.a;\n\
+            material.emission = fragColor.rgb;\n\
+            \n\
+            return material;\n\
+            }\n\
+            ';
+    return materail;
+  };
+
+  Cesium.Material._materialCache.addMaterial(MaterialType, {
+    fabric: {
+      type: MaterialType,
+      uniforms: {
+        color: new Cesium.Color(1.0, 0.0, 0.0, 0.5),
+        image: options.image,
+        time: 0,
+      },
+      source: _getWallShader({
+        count: options.count,
+        freely: options.freely,
+        direction: options.direction,
+      }),
+    },
+    translucent: function () {
+      return true;
+    },
+  });
+  return new (TrailLineMaterialProperty as any)(options);
+}

package/plugins/plugins/cesium-core/src/components/Material/index.ts

@@ -0,0 +1,3 @@
+export { getDynamicImgMaterial, getWallMaterial } from './help/dynamicImgMaterial';
+export { getPolylineFlowMaterialProperty } from './help/PolylineFlowMaterialProperty';
+export { MaterialManager } from './MaterialManager';

package/plugins/plugins/cesium-core/src/components/TooltipManager.ts

@@ -0,0 +1,52 @@
+export class TooltipManager {
+  private tooltipEl: HTMLDivElement;
+  private visible: boolean = false;
+  private offsetX = 10;
+  private offsetY = -20;
+  private onMouseMove: ((e: MouseEvent) => void) | null = null;
+
+  constructor() {
+    this.tooltipEl = document.createElement("div");
+    this.tooltipEl.style.position = "fixed";
+    this.tooltipEl.style.pointerEvents = "none";
+    this.tooltipEl.style.zIndex = "10000";
+    this.tooltipEl.style.padding = "4px 8px";
+    this.tooltipEl.style.borderRadius = "4px";
+    this.tooltipEl.style.background = "rgba(0, 0, 0, 0.7)";
+    this.tooltipEl.style.color = "#fff";
+    this.tooltipEl.style.fontSize = "13px";
+    this.tooltipEl.style.transition = "opacity 0.1s ease";
+    this.tooltipEl.style.opacity = "0";
+
+    document.body.appendChild(this.tooltipEl);
+
+    this.onMouseMove = (e: MouseEvent) => {
+      if (!this.visible) return;
+      this.tooltipEl.style.left = `${e.clientX + this.offsetX}px`;
+      this.tooltipEl.style.top = `${e.clientY + this.offsetY}px`;
+    };
+
+    window.addEventListener("mousemove", this.onMouseMove);
+  }
+
+  show(text: string) {
+    this.tooltipEl.innerText = text;
+    this.tooltipEl.style.opacity = "1";
+    this.visible = true;
+  }
+
+  hide() {
+    this.tooltipEl.style.opacity = "0";
+    this.visible = false;
+  }
+
+  destroy() {
+    if (this.onMouseMove) {
+      window.removeEventListener("mousemove", this.onMouseMove);
+      this.onMouseMove = null;
+    }
+    if (this.tooltipEl.parentElement) {
+      this.tooltipEl.parentElement.removeChild(this.tooltipEl);
+    }
+  }
+}

package/plugins/plugins/cesium-core/src/components/draw/DrawTool.ts

@@ -0,0 +1,55 @@
+import { DrawType, DrawOptions, IDrawer } from './types';
+import PointDrawer from './handlers/PointDrawer';
+import LineDrawer from './handlers/LineDrawer';
+import RectangleDrawer from './handlers/RectangleDrawer';
+import CircleDrawer from './handlers/CircleDrawer';
+import PolygonDrawer from './handlers/PolygonDrawer';
+
+export class DrawTool {
+  private viewer;
+  private Cesium;
+  private activeDrawer: IDrawer | null = null;
+
+  constructor(Cesium: any, viewer: any) {
+    this.viewer = viewer;
+    this.Cesium = Cesium;
+  }
+
+  draw(type: DrawType, options: DrawOptions) {
+    this.clear();
+
+    switch (type) {
+      case 'point':
+        this.activeDrawer = new PointDrawer(this.Cesium, this.viewer);
+        break;
+      case 'line':
+        this.activeDrawer = new LineDrawer(this.Cesium, this.viewer);
+        break;
+      case 'rectangle':
+        this.activeDrawer = new RectangleDrawer(this.Cesium, this.viewer);
+        break;
+      case 'circle':
+        this.activeDrawer = new CircleDrawer(this.Cesium, this.viewer);
+        break;
+      case 'polygon':
+        this.activeDrawer = new PolygonDrawer(this.Cesium, this.viewer);
+        break;
+      default:
+        throw new Error(`Unsupported draw type: ${type}`);
+    }
+
+    this.activeDrawer?.startDrawing(options);
+  }
+
+  clear() {
+    if (this.activeDrawer) {
+      this.activeDrawer.stopDrawing();
+      this.activeDrawer.clear();
+      this.activeDrawer = null;
+    }
+  }
+
+  cancel() {
+    this.clear();
+  }
+}

package/plugins/plugins/cesium-core/src/components/draw/handlers/CircleDrawer.ts

@@ -0,0 +1,159 @@
+import { DrawOptions, IDrawer } from '../types';
+
+export default class CircleDrawer implements IDrawer {
+  private viewer: any;
+  private Cesium: any;
+  private handler: any = null;
+  private entity: any = null;
+  private positions: any[] = [];
+  private _isDrawing: boolean = false;
+  private currentRadius: number = 0;
+
+  constructor(CesiumInstance: any, viewerInstance: any) {
+    this.Cesium = CesiumInstance;
+    this.viewer = viewerInstance;
+  }
+
+  public startDrawing(options: DrawOptions): void {
+    this.clear();
+    this.handler = new this.Cesium.ScreenSpaceEventHandler(this.viewer.canvas);
+    this._isDrawing = true;
+
+    // 第一次点击：确定圆心
+    this.handler.setInputAction((click: any) => {
+      const position = this.viewer.scene.pickPosition(click.position);
+      if (!position) return;
+
+      this.positions.push(position);
+
+      // 如果已经有两个点，则绘制最终图形
+      if (this.positions.length === 2) {
+        this.stopDrawing();
+        this.drawFinalCircle(options);
+      }
+    }, this.Cesium.ScreenSpaceEventType.LEFT_CLICK);
+
+    // 鼠标移动：实时预览圆
+    this.handler.setInputAction((movement: any) => {
+      if (this.positions.length !== 1) return;
+
+      const center = this.positions[0];
+      const ray = this.viewer.camera.getPickRay(movement.endPosition);
+      const edge = this.viewer.scene.globe.pick(ray, this.viewer.scene);
+
+      if (edge) {
+        this.drawPreviewCircle(center, edge, options);
+      }
+    }, this.Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+  }
+
+  private drawPreviewCircle(center: any, edge: any, options: DrawOptions): void {
+    const radius = this.Cesium.Cartesian3.distance(center, edge);
+
+    // 若未添加 entity，先添加并使用 CallbackProperty
+    if (!this.entity) {
+      this.currentRadius = radius;
+      const dynamicRadius = new this.Cesium.CallbackProperty(() => this.currentRadius, false);
+
+      this.entity = this.viewer.entities.add({
+        position: center,
+        ellipse: {
+          semiMajorAxis: dynamicRadius,
+          semiMinorAxis: dynamicRadius,
+          material: options.color || this.Cesium.Color.YELLOW.withAlpha(0.5),
+          outline: true,
+          outlineColor: options.color || this.Cesium.Color.YELLOW,
+          heightReference: this.Cesium.HeightReference.NONE,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+        },
+      });
+    } else {
+      // 控制最小变动阈值，避免频繁更新
+      if (Math.abs(this.currentRadius - radius) > 0.5) {
+        this.currentRadius = radius;
+      }
+    }
+  }
+
+  private drawFinalCircle(options: DrawOptions): void {
+    const [center, edge] = this.positions;
+    const radius = this.Cesium.Cartesian3.distance(center, edge);
+    const centerCarto = this.Cesium.Cartographic.fromCartesian(center);
+
+    const centerLngLat = {
+      lng: this.Cesium.Math.toDegrees(centerCarto.longitude),
+      lat: this.Cesium.Math.toDegrees(centerCarto.latitude),
+      height: centerCarto.height,
+    };
+
+    const step = options?.step || 1;
+    const circlePoints: any[] = [];
+    const circleLnglats: { lng: number; lat: number; height: number }[] = [];
+
+    for (let angle = 0; angle < 360; angle += step) {
+      const angleRad = this.Cesium.Math.toRadians(angle);
+      const geodesic = new this.Cesium.EllipsoidGeodesic();
+
+      geodesic.setEndPoints(
+        centerCarto,
+        new this.Cesium.Cartographic(
+          centerCarto.longitude + 0.0001 * Math.cos(angleRad),
+          centerCarto.latitude + 0.0001 * Math.sin(angleRad),
+        ),
+      );
+
+      const interpolated = geodesic.interpolateUsingSurfaceDistance(radius);
+      const destCartesian = this.Cesium.Ellipsoid.WGS84.cartographicToCartesian(interpolated);
+      circlePoints.push(destCartesian);
+
+      const carto = this.Cesium.Cartographic.fromCartesian(destCartesian);
+      circleLnglats.push({
+        lng: this.Cesium.Math.toDegrees(carto.longitude),
+        lat: this.Cesium.Math.toDegrees(carto.latitude),
+        height: carto.height,
+      });
+    }
+    circleLnglats.push(circleLnglats[0]);
+    const lnglats = this.positions.map((p) => {
+      const carto = this.Cesium.Cartographic.fromCartesian(p);
+      return {
+        lng: this.Cesium.Math.toDegrees(carto.longitude),
+        lat: this.Cesium.Math.toDegrees(carto.latitude),
+        height: carto.height,
+      };
+    });
+
+    options.onComplete?.({
+      entity: this.entity,
+      positions: this.positions,
+      lnglats,
+      circlePoints,
+      circleLnglats,
+      center: centerLngLat,
+      radius,
+      clear: () => {
+        this.clear();
+      },
+    });
+  }
+
+  public stopDrawing(): void {
+    if (this.handler) {
+      this.handler.destroy();
+      this.handler = null;
+    }
+    this._isDrawing = false;
+  }
+
+  public clear(): void {
+    this.stopDrawing();
+
+    if (this.entity) {
+      this.viewer.entities.remove(this.entity);
+      this.entity = null;
+    }
+
+    this.positions = [];
+    this.currentRadius = 0;
+  }
+}