@yangyongtao/gaea 1.0.3 → 1.1.0

package/public/GaeaMethods.js

@@ -0,0 +1,4342 @@
+/**
+ * Gaea-version:"4.0.0"
+ * version:"4.0.0"
+ * 修改时间：2023/3/10
+ * 方法作者: nx
+ */
+
+import Gaea from "./index.js";
+// import * as turf from "@/utils/turf.js";
+import { Tween, Group, Easing } from "@tweenjs/tween.js";
+import pinia from "@/store/store.js";
+import { storeToRefs } from "pinia";
+import gaeaData from "@/store/module/gaeaData.js";
+import groundLine from "@/assets/js/groundLine.js";
+import { serveUrl, getServerAssets, TerrainList, serveLocal } from "./config.js";
+
+const gaeaExample = gaeaData(pinia);
+const { rollerPower, gltfList, MoveCoordinates, ScreenIconList, groundLineList, iconLayerVisible } =
+  storeToRefs(gaeaExample);
+// const {
+//   changeCoordinates
+// } = gaeaExample;
+
+//获取当前时间
+Date.prototype.Format = function (fmt) {
+  var o = {
+    "M+": this.getMonth() + 1, //月份
+    "d+": this.getDate(), //日
+    "H+": this.getHours(), //小时
+    "m+": this.getMinutes(), //分
+    "s+": this.getSeconds(), //秒
+    "q+": Math.floor((this.getMonth() + 3) / 3), //季度
+    S: this.getMilliseconds(), //毫秒
+  };
+  if (/(y+)/.test(fmt))
+    fmt = fmt.replace(
+      RegExp.$1,
+      (this.getFullYear() + "").substr(4 - RegExp.$1.length)
+    );
+  for (var k in o)
+    if (new RegExp("(" + k + ")").test(fmt))
+      fmt = fmt.replace(
+        RegExp.$1,
+        RegExp.$1.length == 1 ? o[k] : ("00" + o[k]).substr(("" + o[k]).length)
+      );
+  return fmt;
+};
+//加载资源
+function LoadResourceAsync(url = "") {
+  let name = url.substring(url.lastIndexOf("/") + 1);
+  return new Promise((res, rej) => {
+    Gaea.GaeaResourceLoader.Instance.LoadResourceFromUrl1(
+      url,
+      name,
+      (code, msg) => {
+        if (code == 200) {
+          res();
+        } else {
+          rej(new Error("出错啦!!!!!"));
+        }
+      }
+    );
+  });
+}
+async function LoadResourceFromUrl(url, name) {
+  return new Promise((res, rej) => {
+    Gaea.GaeaResourceLoader.Instance.LoadResourceFromUrl1(
+      url,
+      name,
+      (code, msg) => {
+        if (code == 200) {
+          res(true);
+        } else {
+          console.log(msg);
+          rej(false);
+        }
+      }
+    );
+  });
+}
+/**
+ * 获取路径中的文件名称
+ * @param {string} url
+ */
+function getFlieName(url) {
+  // console.log(url);
+  // // url=url.replace(/\%23/g,"#")
+  // let index = url.lastIndexOf("/");
+  // let flieName = url.substring(index + 1, url.length);
+  // return flieName;
+  return url.split("/").pop().split("?")[0];
+}
+
+//生成uuid
+/**
+ * @param {number} len 生成长度
+ * @param {number} radix 进制
+ * @return {string}
+ */
+function uuid(len = 8, radix = 16) {
+  var chars =
+    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("");
+  var uuid = [],
+    i;
+  radix = radix || chars.length;
+
+  if (len) {
+    // Compact form
+    for (i = 0; i < len; i++) uuid[i] = chars[0 | (Math.random() * radix)];
+  } else {
+    // rfc4122, version 4 form
+    var r;
+
+    // rfc4122 requires these characters
+    uuid[8] = uuid[13] = uuid[18] = uuid[23] = "-";
+    uuid[14] = "4";
+
+    // Fill in random data.  At i==19 set the high bits of clock sequence as
+    // per rfc4122, sec. 4.1.5
+    for (i = 0; i < 36; i++) {
+      if (!uuid[i]) {
+        r = 0 | (Math.random() * 16);
+        uuid[i] = chars[i == 19 ? (r & 0x3) | 0x8 : r];
+      }
+    }
+  }
+
+  return uuid.join("");
+}
+//识别是否base64路径
+function base64FileHeaderMapper(fileBase64) {
+  let fileHeader = new Map();
+
+  //获取不同文件的文件头前3个字作为判断依据
+  fileHeader.set("/9j", "JPG");
+  fileHeader.set("iVB", "PNG");
+  fileHeader.set("Qk0", "BMP");
+  fileHeader.set("SUk", "TIFF");
+  fileHeader.set("JVB", "PDF");
+  fileHeader.set("UEs", "OFD");
+
+  let res = "";
+
+  //遍历map中所提及的文件头特征
+  fileHeader.forEach((v, k) => {
+    if (k == fileBase64.substr(0, 3)) {
+      res = v;
+    }
+  });
+
+  //如果不在map中返回unknown file
+  if (res == "") {
+    res = "unknown file";
+  }
+
+  //否则返回map中的value值
+  return res;
+}
+function parseColorString(colorString) {
+  //配置颜色
+  const colors = {};
+  // 将16进制颜色值转换为Gaea颜色
+  function hexToGaeaColor(hex) {
+    // 去除前缀 #
+    hex = hex.replace(/^#/, "");
+
+    // 处理6位或3位的16进制颜色值
+    if (hex.length === 6) {
+      const r = parseInt(hex.slice(0, 2), 16) / 255;
+      const g = parseInt(hex.slice(2, 4), 16) / 255;
+      const b = parseInt(hex.slice(4, 6), 16) / 255;
+      const GaeaColor = new Gaea.Color(r, g, b, 1);
+      console.log(GaeaColor);
+      return GaeaColor;
+    } else if (hex.length === 3) {
+      const r = parseInt(hex.charAt(0) + hex.charAt(0), 16) / 255;
+      const g = parseInt(hex.charAt(1) + hex.charAt(1), 16) / 255;
+      const b = parseInt(hex.charAt(2) + hex.charAt(2), 16) / 255;
+      const GaeaColor = new Gaea.Color(r, g, b, 1);
+      console.log(r, g, b);
+      console.log(GaeaColor);
+      return GaeaColor;
+    } else {
+      throw new Error("Invalid hex color string");
+    }
+  }
+
+  // 将RGBA颜色值转换为Gaea颜色
+  function rgbaToGaeaColor(rgba) {
+    const rgbaRegex = /^rgba?\((\d+),\s*(\d+),\s*(\d+),?\s*([\d.]+)?\)$/;
+    const matches = rgba.match(rgbaRegex);
+
+    if (matches) {
+      const r = parseInt(matches[1]) / 255;
+      const g = parseInt(matches[2]) / 255;
+      const b = parseInt(matches[3]) / 255;
+      const a = parseFloat(matches[4] || 1);
+      console.log(new Gaea.Color(r, g, b, a));
+      return new Gaea.Color(r, g, b, a);
+    } else {
+      throw new Error("Invalid RGBA color string");
+    }
+  }
+  // 匹配16进制颜色值
+  const hexRegex = /^#?([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;
+  // 匹配rgba颜色值
+  const rgbaRegex = /^rgba?\((\d+),\s*(\d+),\s*(\d+),?\s*([\d.]+)?\)$/;
+  // 判断字符串格式并进行转换
+  if (hexRegex.test(colorString)) {
+    return hexToGaeaColor(colorString);
+  } else if (rgbaRegex.test(colorString)) {
+    return rgbaToGaeaColor(colorString);
+  } else if (colors[colorString]) {
+    return colors[colorString];
+  } else {
+    console.error("not color string");
+    return false;
+  }
+}
+//rgb转gaea内置颜色
+function RgbcolorToGaeaColor(rgb) {
+  if (typeof rgb !== "string") return false;
+  let regex = /\((.+?)\)/g;
+  let newRgb = rgb.match(regex)[0];
+  let newRgbArr = newRgb.substring(1, newRgb.length - 1).split(",");
+  let gaeaColor = new Gaea.Color(
+    newRgbArr[0] / 255,
+    newRgbArr[1] / 255,
+    newRgbArr[2] / 255,
+    1
+  );
+  console.log(gaeaColor);
+  return gaeaColor;
+}
+//rgb转vector3颜色
+function RbgColorToVector3(rgb) {
+  if (typeof rgb !== "string") return false;
+  let regex = /\((.+?)\)/g;
+  let newRgb = rgb.match(regex)[0];
+  let newRgbArr = newRgb.substring(1, newRgb.length - 1).split(",");
+  return new Gaea.Color(
+    newRgbArr[0] / 255,
+    newRgbArr[1] / 255,
+    newRgbArr[2] / 255,
+    1.0
+  );
+}
+
+/**
+ * NOTE: 通过tileset.json中的transform计算坐标
+ */
+function fromCartesian(cartesian) {
+  const oneOverRadii = {
+    x: 1.0 / 6378137.0,
+    y: 1.0 / 6378137.0,
+    z: 1.0 / 6356752.3142451793,
+  };
+  const oneOverRadiiSquared = {
+    x: 1.0 / (6378137.0 * 6378137.0),
+    y: 1.0 / (6378137.0 * 6378137.0),
+    z: 1.0 / (6356752.3142451793 * 6356752.3142451793),
+  };
+
+  const p = scaleToGeodeticSurface(
+    cartesian,
+    oneOverRadii,
+    oneOverRadiiSquared,
+    0.1
+  );
+
+  if (!(p !== undefined && p !== null)) {
+    return undefined;
+  }
+
+  let n = {
+    x: p.x * oneOverRadiiSquared.x,
+    y: p.y * oneOverRadiiSquared.y,
+    z: p.z * oneOverRadiiSquared.z,
+  };
+  const m1 = magnitude(n);
+  n = {
+    x: n.x / m1,
+    y: n.y / m1,
+    z: n.z / m1,
+  };
+
+  const h = {
+    x: cartesian.x - p.x,
+    y: cartesian.y - p.y,
+    z: cartesian.z - p.z,
+  };
+
+  const longitude = Math.atan2(n.y, n.x);
+  const latitude = Math.asin(n.z);
+  const height =
+    Math.sign(h.x * cartesian.x + h.y * cartesian.y + h.z * cartesian.z) *
+    magnitude(h);
+
+  let result = {};
+  result.longitude = (longitude * 180.0) / Math.PI;
+  result.latitude = (latitude * 180.0) / Math.PI;
+  result.height = height;
+  return result;
+}
+
+function scaleToGeodeticSurface(
+  cartesian,
+  oneOverRadii,
+  oneOverRadiiSquared,
+  centerToleranceSquared
+) {
+  const positionX = cartesian.x;
+  const positionY = cartesian.y;
+  const positionZ = cartesian.z;
+
+  const oneOverRadiiX = oneOverRadii.x;
+  const oneOverRadiiY = oneOverRadii.y;
+  const oneOverRadiiZ = oneOverRadii.z;
+
+  const x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;
+  const y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;
+  const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;
+
+  // Compute the squared ellipsoid norm.
+  const squaredNorm = x2 + y2 + z2;
+  const ratio = Math.sqrt(1.0 / squaredNorm);
+
+  // As an initial approximation, assume that the radial intersection is the projection point.
+  const intersection = {
+    x: cartesian.x * ratio,
+    y: cartesian.y * ratio,
+    z: cartesian.z * ratio,
+  };
+
+  // If the position is near the center, the iteration will not converge.
+  if (squaredNorm < centerToleranceSquared) {
+    return !isFinite(ratio) ? undefined : intersection;
+  }
+
+  const oneOverRadiiSquaredX = oneOverRadiiSquared.x;
+  const oneOverRadiiSquaredY = oneOverRadiiSquared.y;
+  const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
+
+  // Use the gradient at the intersection point in place of the true unit normal.
+  // The difference in magnitude will be absorbed in the multiplier.
+  const gradient = {
+    x: intersection.x * oneOverRadiiSquaredX * 2.0,
+    y: intersection.y * oneOverRadiiSquaredY * 2.0,
+    z: intersection.z * oneOverRadiiSquaredZ * 2.0,
+  };
+
+  // Compute the initial guess at the normal vector multiplier, lambda.
+  let lambda =
+    ((1.0 - ratio) * magnitude(cartesian)) / (0.5 * magnitude(gradient));
+  let correction = 0.0;
+
+  let func;
+  let denominator;
+  let xMultiplier;
+  let yMultiplier;
+  let zMultiplier;
+  let xMultiplier2;
+  let yMultiplier2;
+  let zMultiplier2;
+  let xMultiplier3;
+  let yMultiplier3;
+  let zMultiplier3;
+
+  do {
+    lambda -= correction;
+
+    xMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredX);
+    yMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredY);
+    zMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredZ);
+
+    xMultiplier2 = xMultiplier * xMultiplier;
+    yMultiplier2 = yMultiplier * yMultiplier;
+    zMultiplier2 = zMultiplier * zMultiplier;
+
+    xMultiplier3 = xMultiplier2 * xMultiplier;
+    yMultiplier3 = yMultiplier2 * yMultiplier;
+    zMultiplier3 = zMultiplier2 * zMultiplier;
+
+    func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1.0;
+
+    // "denominator" here refers to the use of this expression in the velocity and acceleration
+    // computations in the sections to follow.
+    denominator =
+      x2 * xMultiplier3 * oneOverRadiiSquaredX +
+      y2 * yMultiplier3 * oneOverRadiiSquaredY +
+      z2 * zMultiplier3 * oneOverRadiiSquaredZ;
+
+    const derivative = -2.0 * denominator;
+
+    correction = func / derivative;
+  } while (Math.abs(func) > 0.000000000001);
+
+  let result = {
+    x: positionX * xMultiplier,
+    y: positionY * yMultiplier,
+    z: positionZ * zMultiplier,
+  };
+  return result;
+}
+
+function magnitude(cartesian) {
+  return Math.sqrt(
+    cartesian.x * cartesian.x +
+    cartesian.y * cartesian.y +
+    cartesian.z * cartesian.z
+  );
+}
+
+
+
+let RiverEditTool;
+let ytImageId;
+let ytTimer;
+// 集雨区
+let jyqpolygonElement = [];
+//三角网
+let vt;
+
+// 台风
+let typhoonData;
+
+// 存储
+const types = {
+  GroundDistance: Gaea.MeasureGroundContactDistanceTool,
+  SpatialDistance: Gaea.MeasureSpatialDistanceTool,
+  Height: Gaea.MeasureHeightTool,
+  Area: Gaea.MeasureAreaPolygonTool,
+  Volume: Gaea.DrawVolumeMeasurementTool,
+};
+// var onload = null
+export default class App {
+  constructor() {
+    //当前图层列表
+    this.layers = [];
+    //影像图层
+    this.tLayers = [];
+    //鼠标点击事件
+    this.mouserUp = null;
+    //鼠标滚动事件
+    this.mouserWheel = null;
+    //鼠标移动事件
+    this.mouseMove = null;
+    // 鼠标双击事件
+    this.mouseDoubleClick = null;
+
+    // 地形数组
+    this.dxyb_Arr = [];
+    // 地形演变定时器
+    this.dxyb_Interval = null;
+
+    // 画线
+    this.importBox = false;
+
+    this.streamline = [];
+
+    // 流场对象
+    this._streaml = null;
+
+    // 服务列表
+    this.serveList = [];
+
+    //用来存储所有点线面生成的element对象，这个需要前端自行管理（例如删除）
+    this.elements = [];
+
+    // 坐标点集合
+    this.pointList = [];
+
+    // 线数组
+    this.lineList = [];
+
+    // 等值云图对象
+    this.isometricRendering = {};
+    this.texture0 = {};
+    this.vt = {};
+    // new add
+    this.iconDict = new Map();
+    this.wmsLayers = [];
+    // VTS矢量服务对象
+    this.vectorServiceList = [];
+    this.groundPolygon = [];
+
+    this.tweenGroup = new Group();
+
+    this.groundWire = []
+  }
+
+  // //获取静态资源路径
+  getServerAssets = async () => {
+    console.log("加载静态资源");
+    Gaea.World.Instance.Is3DTilesNeedCache = false; //缓存关闭
+    Gaea.World.Instance.IsPyramidTileSetNeedCache = false; //缓存关闭
+    //关闭雾
+    var fog_environment = Gaea.Environment.ConvertBy(
+      Gaea.GaeaResourceLoader.Instance.LoadLoaclResource(
+        "res://default_env.tres"
+      )
+    );
+    fog_environment.FogEnabled = false;
+
+    // 关闭大气
+    // var FullScreenQuad = Gaea.WeatherManager.ConvertBy(
+    //   Gaea.World.Instance.GetNode("Camera/FullScreenQuad")
+    // );
+    // FullScreenQuad.Visible = false;
+
+    // const logo = Gaea.World.Instance.GetNode("@@6");
+    // logo.QueueFree()
+    window.Gaea = Gaea;
+    var cfg_code2 = `[Engine]
+          DefaultGlobalOverview="Global2.jpg"
+          AssetHost="${getServerAssets}"`;
+    // Gaea.EngineConfig.Instance.LoadConfig(cfg_code2);
+    // Gaea.World.Instance.LoadDefaultEngineConfig();
+    Gaea.World.Instance.EngineConfigString = cfg_code2;
+    // Gaea.EngineConfig.Instance.engin(cfg_code2);
+    // Gaea.World.Instance.UseHttps = true;
+    Gaea.World.Instance.ForceCloudVisalbe = true;
+    Gaea.World.Instance.CloudVisalbe = false;
+    // Gaea.World.instance.GeometryErrorFineness = 10.0;
+    // await this.InitFontTexture();
+
+    // RiverEditTool = new Gaea.RiverEditTool();
+    var environment = Gaea.Environment.ConvertBy(Gaea.GaeaResourceLoader.Instance.LoadLoaclResource("res://default_env.tres"));
+    environment.BackgroundEnergy = 0.6;
+
+    var sun = Gaea.Sun.ConvertBy(Gaea.World.Instance.GetNode("Sun"));
+    var environment = Gaea.Environment.ConvertBy(Gaea.GaeaResourceLoader.Instance.LoadLoaclResource("res://default_env.tres"));
+    sun.Power = 1.5;
+    // sun.TimeString = "2022-09-15 10:00:00";
+    // setInterval(() => {
+    //   let i = 0
+    //   sun.TimeString = `2022-09-15 ${i}:00:00`;
+    //   i++
+    //   if (i == 24) {
+    //     i = 0
+    //   }
+    // }, 1000);
+    // sun.TimeScale = 7200;
+
+  };
+  //获取服务列表
+  getAllServe = async () => {
+    const url = `${serveUrl}htc/service/wmts?REQUEST=GetCapabilities`;
+    var result = await (
+      await fetch(url)
+    ).text();
+    // var result = await (await fetch('http://172.18.100.213:6080/arcgis/rest/services/yanjiuyuan/soundgwms21/MapServer/WMTS/1.0.0/WMTSCapabilities.xml')).text()
+    // if (Object.prototype.toString.call(result) === "[object Object]") return console.error('图层列表获取失败,请检查请求地址');
+    let hostUrl = `${serveUrl}htc/service/wmts`;
+    // let hostUrl = `http://172.18.100.213:6080/arcgis/rest/services/yanjiuyuan/soundgwms21/MapServer/WMTS/1.0.0/WMTSCapabilities.xml`
+    const layers = Gaea.WMTSImageStore.ParserXml2Capabilities(hostUrl, result);
+    this.layers = [...this.layers, ...layers];
+    return this.layers;
+  };
+
+  //监听鼠标点击事件
+  addMouseUp = () => {
+    document.getElementById("canvas").addEventListener("mousedown", function () {
+      var pointlist = []
+      var pointelement = new Gaea.PointGeometryElement();//创建点element 
+      Gaea.World.Instance.RenderableObjectList.AddLast(pointelement);
+      var result = Gaea.GaeaMath.ProjectPosition(new Gaea.Vector2(event.offsetX, event.offsetY));
+      var lonlat = Gaea.GaeaMath.CartesianToSphericalDeg(result);
+      const pos = {
+        x: lonlat.x,
+        y: lonlat.y,
+        z: lonlat.z,
+      }
+      // 画点
+      // pointelement.Visible = true;
+      // pointlist.push(lonlat);
+      // var pointgeometry = Gaea.Geometry.Create1(Gaea.GeometryType.Point, pointlist);
+      // pointelement.Shape = pointgeometry;
+      // pointelement.NeedIntersectWithMesh = true;
+      // pointlist = []
+      console.log(pos, 'pospos');
+
+    },
+      false);
+  };
+  //移除鼠标点击事件
+  removeMouseUp = () => {
+    if (this.mouserUp) {
+      Gaea.World.Instance.ClearEvent(this.mouserUp);
+      this.mouserUp = null;
+    }
+  };
+  //监听滚动事件
+  addMouseWhill = (cb = null) => {
+    this.mouserWheel = Gaea.World.Instance.OnMouseWheel((p, b) => {
+      if (p == 1 || p == -1) {
+        const { Altitude } = Gaea.World.Instance.DefaultCamera;
+
+        debounce(() => {
+          console.log(Altitude);
+          if (Altitude < 60) {
+            Gaea.World.Instance.DefaultCamera.CameraZoomAcceleration = 0.01;
+          } else {
+            Gaea.World.Instance.DefaultCamera.CameraZoomAcceleration = 2.5;
+          }
+          console.log(Gaea.World.Instance.DefaultCamera.CameraZoomAcceleration);
+          rollerPower.value =
+            Gaea.World.Instance.DefaultCamera.CameraZoomAcceleration;
+          // Gaea.World.Instance.DefaultCamera.CameraZoomAcceleration = 2.5;
+        }, 2000);
+      }
+    });
+  };
+
+  //添加鼠标移动事件
+  addMouseMove = (cb = null) => {
+    this.mouseMove = Gaea.World.Instance.OnMouseMove((p, b) => {
+      var screenpos = new Gaea.Vector2(p.x, p.y);
+      var spacepos = Gaea.GaeaMath.ProjectPosition(screenpos);
+      var latlonalt = Gaea.GaeaMath.CartesianToSphericalDeg(spacepos);
+      // changeCoordinates(latlonalt.instance.x,latlonalt.instance.y,latlonalt.instance.z)
+      MoveCoordinates.value.x = latlonalt.instance.x;
+      MoveCoordinates.value.y = latlonalt.instance.y;
+      MoveCoordinates.value.z = latlonalt.instance.z;
+      // console.log(MoveCoordinates.value,'MoveCoordinates');
+      cb(MoveCoordinates.value);
+    });
+  };
+  //移除鼠标移动事件
+  removeMouseMove = () => {
+    if (this.mouseMove) {
+      Gaea.World.Instance.ClearEvent(this.mouseMove);
+      this.mouseMove = null;
+    }
+  };
+
+  // 降雨
+  WeatherManager = (WeatherManagerObj) => {
+    //开启全球大气
+    // var FullScreenQuad = Gaea.WeatherManager.ConvertBy(Gaea.World.Instance.GetNode("Camera/FullScreenQuad"));
+    // FullScreenQuad.Visible = true;
+
+    // //雨雪方向-1.5为右，1.5为左
+    // FullScreenQuad.WindDirection = -1.5;
+    // //雨雪速度 max:100,min:0
+    // FullScreenQuad.Speed = 30;
+    // //雨雪数量 max:100,min:0
+    // FullScreenQuad.Count = 30;
+    // //闪电频率 默认为4s
+    // FullScreenQuad.FlashFrequency = 1;
+    // //闪电强度
+    // FullScreenQuad.FlashFrequency = 4;
+    // switch (type) {
+    //   case '雨':
+    //     FullScreenQuad.Rainy = true;
+    //     break;
+    //   case '雪':
+    //     FullScreenQuad.Snowy = true;
+    //     break;
+    //   case '闪电':
+    //     FullScreenQuad.Flash = true;
+    //   case '大气':
+    //     FullScreenQuad.NeedAtmosphere = true;
+    //   default:
+    //     break;
+    // }
+    var sun = Gaea.Sun.ConvertBy(Gaea.World.Instance.GetNode("Sun"));
+    var environment = Gaea.Environment.ConvertBy(
+      Gaea.GaeaResourceLoader.Instance.LoadLoaclResource(
+        "res://default_env.tres"
+      )
+    );
+    var FullScreenQuad = Gaea.World.Instance.FullScreenQuad;
+    if (WeatherManagerObj.Rainy) {
+      FullScreenQuad.Visible = true;
+      FullScreenQuad.NeedAtmosphere = false;
+      sun.LightEnergy = 0.05;
+      environment.BackgroundEnergy = 0.11;
+      environment.GlowBlendMode = 1;
+      if (WeatherManagerObj.WindDirection) {
+        FullScreenQuad.WindDirection = WeatherManagerObj.WindDirection;
+      }
+      if (WeatherManagerObj.Speed) {
+        FullScreenQuad.Speed = WeatherManagerObj.Speed;
+      }
+      if (WeatherManagerObj.Count) {
+        FullScreenQuad.Count = WeatherManagerObj.Count;
+      }
+    } else {
+      FullScreenQuad.Visible = false;
+      FullScreenQuad.NeedAtmosphere = false;
+
+      sun.LightEnergy = 3.5;
+      environment.BackgroundEnergy = 0.2;
+      environment.GlowBlendMode = 2;
+    }
+    // console.log('降雨');
+    // // 降雨
+    // // var FullScreenQuad = Gaea.WeatherManager.ConvertBy(Gaea.World.Instance.GetNode("Camera/FullScreenQuad"));
+    // var FullScreenQuad = Gaea.World.Instance.FullScreenQuad;
+    // // FullScreenQuad.Visible = false;
+    // FullScreenQuad.Visible = true;
+    // FullScreenQuad.NeedAtmosphere = false;
+
+    // var sun = Gaea.Sun.ConvertBy(Gaea.World.Instance.GetNode("Sun"));
+    // var environment = Gaea.Environment.ConvertBy(Gaea.GaeaResourceLoader.Instance.LoadLoaclResource("res://default_env.tres"));
+    // // sun.TimeString = "2022-09-15 00:00:00";
+    // // sun.LightColor = new Gaea.Color(255 / 255, 255 / 255, 255 / 255, 1);
+    // // if (WeatherManagerObj.LightEnergy) { sun.LightEnergy = WeatherManagerObj.LightEnergy; }
+    // // if (WeatherManagerObj.BackgroundEnergy) { environment.BackgroundEnergy = WeatherManagerObj.BackgroundEnergy; }
+    // // if (WeatherManagerObj.GlowBlendMode) { environment.GlowBlendMode = WeatherManagerObj.GlowBlendMode; }
+    // FullScreenQuad.Rainy = WeatherManagerObj.Rainy;
+    // if (FullScreenQuad.Rainy) {
+    //   sun.LightEnergy = 0.05;
+    //   environment.BackgroundEnergy = 0.11;
+    //   environment.GlowBlendMode = 1;
+    // } else {
+    //   sun.LightEnergy = 3.5;
+    //   environment.BackgroundEnergy = 0.2;
+    //   environment.GlowBlendMode = 2;
+    // }
+    // if (WeatherManagerObj.WindDirection) { FullScreenQuad.WindDirection = WeatherManagerObj.WindDirection; }
+    // if (WeatherManagerObj.Speed) { FullScreenQuad.Speed = WeatherManagerObj.Speed; }
+    // if (WeatherManagerObj.Count) { FullScreenQuad.Count = WeatherManagerObj.Count; }
+  };
+
+  // 画点
+  DrawPointFuc = async (params, callback = () => { }) => {
+    const {
+      latitude,
+      longitude,
+      airpressure,
+      issueDate,
+      moveSpeed,
+      wind,
+      iconUrl,
+      pointType,
+      typhoonCode,
+      typhoonName,
+      namePY,
+      DrawPointClick,
+      DrawLineClick,
+      removeDashedPoint,
+      removeDashedLine,
+      addScreenForTyphoon,
+      removeScreenForTyphoon,
+      setPointData,
+    } = params;
+    //请求点的贴图，参数为（请求地址，保存为文件（带后缀））
+    var PointElement;
+    var PointIconMarkSymbol;
+    // await request(iconUrl, "图标.png");
+    await LoadResourceAsync(iconUrl);
+    const iconName = getFlieName(iconUrl);
+    var id = Gaea.GaeaResourceLoader.Instance.GetResource(iconName);
+    var tex = new Gaea.Texture(false);
+    tex.InstanceID = id + "";
+
+    // 点数组,(纬度，经度，到球心距离)
+    var Position = [];
+    var pos = new Gaea.Vector3(latitude, longitude, 30);
+    var elv = Gaea.World.Instance.DefaultTerrainAccessor.GetElevationAt(
+      latitude,
+      longitude,
+      20
+    );
+    pos.z += pos.z + elv;
+    Position.push(pos);
+    // 根据坐标点创建几何对象，参数（几何形状类型，几何数据）
+    var geometry = Gaea.Geometry.Create1(Gaea.GeometryType.Point, Position);
+
+    // 创建PointGeometryElement对象
+    PointElement = new Gaea.PointGeometryElement();
+    // 赋值
+    PointElement.Shape = geometry;
+    //设置点图标的样式,系统自带样式，可以不用设置
+    PointIconMarkSymbol = new Gaea.IconMarkSymbol();
+    //图标大小
+    PointIconMarkSymbol.MarkSize = 24;
+    //图片
+    PointIconMarkSymbol.Icon = tex;
+    // 点的层级
+    PointIconMarkSymbol.Priority = 6;
+    //样式赋给element
+    PointElement.Symbol = PointIconMarkSymbol;
+    // 允许点击
+    PointElement.EnablePick = true;
+    // 允许编辑
+    PointElement.EnableEdit = false;
+
+    // 允许在3Dtiles、管线、挖方等位置编辑
+    PointElement.NeedIntersectWithMesh = false;
+    //选中的回调事件
+    PointElement.SelectedCallBack(async (a, b, c, d, e, f) => {
+      if (c) {
+        //获取选中element
+        const selectelement = new Gaea.LineGeometryElement(false);
+        selectelement.InstanceID = a + "";
+
+        // 返回数据
+        setPointData(params);
+      }
+    });
+    // PointElement.VisibleRange = new Gaea.Vector2(
+    //   0, 1000000
+    // );
+    // 将Element加入到场景中
+    Gaea.World.Instance.RenderableObjectList.AddLast(PointElement);
+    // elements.push(PointElement);
+    //定位
+    // Gaea.World.Instance.DefaultCamera.SetPosition2(LATITUDE, LONGITUDE, 0, 1500, 0, 0)
+    callback(PointElement);
+  };
+
+  // 画线
+  DrawLineFuc = async (id, list, color) => {
+    let Position = [];
+    list.forEach((item) => {
+      Position.push(new Gaea.Vector3(item.x, item.y, item.z));
+    });
+
+    // 根据坐标点创建几何对象，参数（几何形状类型，几何数据）
+    var geometry = Gaea.Geometry.Create1(Gaea.GeometryType.Polyline, Position);
+    // 创建PointGeometryElement对象
+    var LineElement = new Gaea.LineGeometryElement();
+    LineElement.id = id;
+    // 赋值
+    LineElement.Shape = geometry;
+    // 允许点击
+    LineElement.EnablePick = false;
+    // 允许编辑
+    LineElement.EnableEdit = false;
+    // 允许在3Dtiles、管线、挖方等位置编辑
+    LineElement.NeedIntersectWithMesh = true;
+    //开启虚拟点
+    LineElement.EnableVirtualPoint = true;
+    LineElement.InitialLineColor = new Gaea.Color(color[0] / 255, color[1] / 255, color[2] / 255, 1)
+    //选中的回调事件
+    LineElement.SelectedCallBack((a, b, c, d, e, f) => {
+      if (c) {
+        //获取选中element
+        selectelement = new Gaea.LineGeometryElement(false);
+        selectelement.InstanceID = a + "";
+      }
+      else {
+        selectelement = null;
+      }
+    });
+    // 将Element加入到场景中
+    Gaea.World.Instance.RenderableObjectList.AddLast(LineElement);
+    this.elements.push(LineElement);
+    return LineElement;
+  };
+
+  drawPoint = (item) => {
+    var pointelement = new Gaea.PointGeometryElement();//创建点element 
+    Gaea.World.Instance.RenderableObjectList.AddLast(pointelement);
+    pointelement.Visible = true;
+    var Position = [];
+    var pos = new Gaea.Vector3(item.x, item.y, 1);
+    var elv = Gaea.World.Instance.DefaultTerrainAccessor.GetElevationAt(
+      item.x,
+      item.y,
+      item.z
+    );
+    pos.z += pos.z + elv;
+    Position.push(pos);
+    var pointgeometry = Gaea.Geometry.Create1(Gaea.GeometryType.Point, Position);
+    pointelement.Shape = pointgeometry;
+    pointelement.NeedIntersectWithMesh = true;
+  }
+
+  // 移除点
+  removePoint = (list) => {
+    list.forEach((value) => {
+      Gaea.World.Instance.RenderableObjectList.Remove(value.PointElement);
+    });
+  };
+
+  // 移除线
+  removeLine = (list) => {
+    list.forEach((value) => {
+      Gaea.World.Instance.RenderableObjectList.Remove(value.LineElement);
+    });
+  };
+
+  // 画多边形
+  AddCircle = (params, callback = () => { }) => {
+    const { pointradius, latitude, longitude, colorList, positions } = params;
+    // const PointElements = []
+
+    //获取当前的点坐标
+    var latlon = new Gaea.Vector3(latitude, longitude, 0);
+    // var point = turf.point([latlon.y, latlon.x]);
+    // var buffered = turf.buffer(point, pointradius, { units: 'meters' });
+    // var positions = []
+    // for (var i = 0; i < buffered.geometry.coordinates[0].length; i++) {
+    //   var hei = Gaea.World.Instance.DefaultTerrainAccessor.GetElevationAt(buffered.geometry.coordinates[0][i][1], buffered.geometry.coordinates[0][i][0], 20);
+    //   var position = new Gaea.Vector3(buffered.geometry.coordinates[0][i][1], buffered.geometry.coordinates[0][i][0], hei);
+    //   positions.push(position);
+    // }
+    var geometry = Gaea.Geometry.Create1(Gaea.GeometryType.Polygon, positions);
+    // 创建PolygonGeometryElement对象
+    var Element = new Gaea.PolygonGeometryElement();
+    // 赋值
+    Element.Shape = geometry;
+    // 允许点击
+    Element.EnablePick = false;
+    // 允许编辑
+    Element.EnableEdit = false;
+    // 允许在3Dtiles、管线、挖方等位置编辑
+    Element.NeedIntersectWithMesh = false;
+
+    // 改变面的颜色
+    Element.InitialFillColor = new Gaea.Color(0, 0, 0, 0);
+    // 改变线的颜色
+    var ElementSymbol = Gaea.SimpleFillSymbol.ConvertBy(Element.Symbol);
+    ElementSymbol.OutLineSymbol.SymbolColor = new Gaea.Color(
+      colorList[0],
+      colorList[1],
+      colorList[2],
+      1
+    );
+    // 改变线的类型
+    ElementSymbol.OutLineSymbol.LineStyle = 1;
+    ElementSymbol.OutLineSymbol.RepeatTimes = 100;
+
+    //开启虚拟点
+    Element.EnableVirtualPoint = false;
+    // Element.Symbol = symbol;
+    // 将Element加入到场景中
+    Gaea.World.Instance.RenderableObjectList.AddLast(Element);
+    callback(Element);
+    // PointElements.push(Element);
+    // //调用画点工具
+    // var tool = new Gaea.DrawPointTool();
+    // //切换工具时，是否清除当前的element,默认为true
+    // tool.DeleteElementOnDispose = false;
+    // //绘制完成，是否创建Element,默认为true
+    // tool.CreateElementOnCompleted = true;
+    // //工具是否与gltf等实体交互，默认为true
+    // tool.NeedIntersectWithMesh = false;
+    // //将当前工具挂载在世界节点
+    // Gaea.World.Instance.SetCurrentTool(tool);
+    // tool.OverDraw = () => {
+    //   tool.Element.EnableEdit = false;
+    //   tool.Element.EnablePick = false;
+    //   // primitivepoints.push(tool.Element);
+
+    // }
+  };
+
+  // 移除圆形
+  removeCircle = (element) => {
+    Gaea.World.Instance.RenderableObjectList.Remove(element);
+  };
+  // 集雨区面
+  addPolygon = async (jyqJson) => {
+    const resData = await (await fetch(jyqJson)).json();
+    let pointList = resData.features;
+    console.log("-增加面数据json--", pointList);
+
+    var Position = [];
+    pointList.forEach((item) => {
+      item.geometry.coordinates[0].forEach((item1) => {
+        Position.push(new Gaea.Vector3(item1[1], item1[0], 10000));
+      });
+    });
+    // 根据坐标点创建几何对象，参数（几何形状类型，几何数据）
+    var geometry = Gaea.Geometry.Create1(Gaea.GeometryType.Polygon, Position);
+    // 创建PointGeometryElement对象
+    var Element = new Gaea.PolygonGeometryElement();
+    // 赋值
+    Element.Shape = geometry;
+    // 允许点击
+    Element.EnablePick = true;
+    // 允许编辑
+    Element.EnableEdit = false;
+    // 允许在3Dtiles、管线、挖方等位置编辑
+    Element.NeedIntersectWithMesh = false;
+    //开启虚拟点
+    Element.VirtualHelperIcon = false;
+
+    // if (styleThreeForm.orContrastColor) {
+    //   Element.InitialFillColor = new Gaea.Color(this.changeRgba(styleThreeForm.color)[0], this.changeRgba(styleThreeForm.color)[1], this.changeRgba(styleThreeForm.color)[2], styleThreeForm.transparency / 100);//填充颜色
+    // } else {
+    //   Element.InitialFillColor = new Gaea.Color(13 / 255, 64 / 255, 209 / 255, 0);//填充颜色
+
+    // }
+    // var PolygonSimpleFillSymbol = Gaea.SimpleFillSymbol.ConvertBy(Element.Symbol);
+    // PolygonSimpleFillSymbol.HasOutLine = styleThreeForm.orBorder //显示边框  true
+    // // 显示边框
+    // if (styleThreeForm.orBorder) {
+    //   Element.InitialLineColor = new Gaea.Color(this.changeRgba(styleThreeForm.borderColor)[0], this.changeRgba(styleThreeForm.borderColor)[1], this.changeRgba(styleThreeForm.borderColor)[2], styleThreeForm.borderTransparency / 100);//边框颜色
+    //   // PolygonSimpleFillSymbol.OutLineSymbol.LineWidth = styleThreeForm.borderWidth;
+
+    // }
+
+    // // 将Element加入到场景中
+    Gaea.World.Instance.RenderableObjectList.AddLast(Element);
+    // RiverEditTool.AddPolygonGeometryElement(Element);
+    // Element.SelectedCallBack((a, b, c, d, e, g) => {
+    //   if (c) {
+
+    //   }
+    // });
+
+    // jyqpolygonElement.push(Element)
+    const parts = jyqJson.split("/");
+    const lastItem = parts[parts.length - 1]; // 获取部分（深圳水库集雨区.geojson）
+    const jyqName = lastItem.split(".")[0];
+    jyqpolygonElement.push({
+      Element: Element,
+      jyq: jyqName,
+    });
+
+    // callback(Element)
+  };
+  // 移除集雨区面
+  removejyqPolygon() {
+    if (jyqpolygonElement.length) {
+      jyqpolygonElement.forEach((item) => {
+        Gaea.World.Instance.RenderableObjectList.Remove(item.Element);
+      });
+    }
+  }
+
+  changeJYQcolor(jyqArr) {
+    console.log("-----jyqArr", jyqArr);
+    console.log("-----jyqpolygonElement", jyqpolygonElement);
+    // jyqpolygonElement.forEach(item=>{
+    //   if()
+    // })
+  }
+  // 批量画点
+  addMorePoint = async (screenObj, callback) => {
+    const {
+      iconUrl,
+      selectIconUrl,
+      jsonUrl,
+      Field = "name",
+      IconSize = 30,
+      FontSize = 30,
+      fontColor,
+      fontOutLineColor,
+      min,
+      max,
+    } = screenObj;
+    //请求点的贴图，参数为（请求地址，保存为文件（带后缀））
+    var PointElement;
+    var PointIconMarkSymbol;
+    // await request(iconUrl, "图标.png");
+    await LoadResourceAsync(iconUrl);
+    const iconName = getFlieName(iconUrl);
+    var id = Gaea.GaeaResourceLoader.Instance.GetResource(iconName);
+    var tex = new Gaea.Texture(false);
+    tex.InstanceID = id + "";
+    const resData = await (await fetch(jsonUrl)).json();
+    let pointList = resData.features;
+
+    // 点数组,(纬度，经度，到球心距离)
+    var Position = [];
+    pointList.forEach((item) => {
+      var pos = new Gaea.Vector3(
+        item.geometry.coordinates[1],
+        item.geometry.coordinates[0],
+        30
+      );
+      var elv = Gaea.World.Instance.DefaultTerrainAccessor.GetElevationAt(
+        item.geometry.coordinates[1],
+        item.geometry.coordinates[0],
+        20
+      );
+      pos.z += pos.z + elv;
+      Position.push(pos);
+    });
+    // 根据坐标点创建几何对象，参数（几何形状类型，几何数据）
+    // var geometry = Gaea.Geometry.Create1(Gaea.GeometryType.Point, Position);
+    var geometry = Gaea.Geometry.Create1(
+      Gaea.GeometryType.MultiPoint,
+      Position
+    );
+
+    // 创建PointGeometryElement对象
+    PointElement = new Gaea.PointGeometryElement();
+    // 赋值
+    PointElement.Shape = geometry;
+    //设置点图标的样式,系统自带样式，可以不用设置
+    PointIconMarkSymbol = new Gaea.IconMarkSymbol();
+    //图标大小
+    PointIconMarkSymbol.MarkSize = IconSize || 24;
+    //图片
+    PointIconMarkSymbol.Icon = tex;
+    // 点的层级
+    PointIconMarkSymbol.Priority = 6;
+    //样式赋给element
+    PointElement.Symbol = PointIconMarkSymbol;
+    // 允许点击
+    PointElement.EnablePick = true;
+    // 允许编辑
+    PointElement.EnableEdit = false;
+
+    // 允许在3Dtiles、管线、挖方等位置编辑
+    PointElement.NeedIntersectWithMesh = false;
+    //选中的回调事件
+    PointElement.SelectedCallBack(async (a, b, c, d, e, f) => {
+      if (c) {
+        //获取选中element
+        const selectelement = new Gaea.LineGeometryElement(false);
+        selectelement.InstanceID = a + "";
+      }
+    });
+    PointElement.VisibleRange = new Gaea.Vector2(min || 0, max || 100000);
+    // 将Element加入到场景中
+    Gaea.World.Instance.RenderableObjectList.AddLast(PointElement);
+    // elements.push(PointElement);
+    //定位
+    // Gaea.World.Instance.DefaultCamera.SetPosition2(LATITUDE, LONGITUDE, 0, 1500, 0, 0)
+    callback(PointElement);
+  };
+
+  // 移除批量点
+  removeMorePoint = (flayer) => {
+    Gaea.World.Instance.RenderableObjectList.Remove(flayer);
+  };
+
+  // 定位
+  gaeaLocation = (obj) => {
+    const { lat, lon, altitude } = obj;
+    Gaea.World.Instance.DefaultCamera.SetPosition2(
+      lat,
+      lon,
+      0,
+      altitude || 1500,
+      0,
+      0
+    );
+  };
+
+  //添加公告牌
+  addScreenElement = async (screenparams, callback = () => { }) => {
+    // const { Name, lat, lon, width, height, left, top, anchorType, onClick = () => { }, divId, visibleRange, elevation } = screenparams
+    const {
+      Name,
+      lat,
+      lon,
+      width,
+      height,
+      left,
+      top,
+      anchorType,
+      divId,
+      min,
+      max,
+      elevation,
+    } = screenparams;
+    // const geojsonFileName = getFlieName(jsonUrl)
+    // console.log(geojsonFileName,'geojsonFileName');
+    const screen = new Gaea.ScreenGUIElement();
+    screen.Name = Name;
+    if (screenparams.divId) {
+      screen.DivID = divId;
+      const root = new Gaea.Control();
+      root.MouseFilter = 2;
+      root.RectSize = new Gaea.Vector2(width || 150, height || 100);
+      // root.RectSize = new Gaea.Vector2(width || 0, height || 0);
+      screen.Root = root;
+    } else {
+      screen.Root = this.InitUI(screenparams.ui);
+    }
+    // 标签的地理坐标
+    screen.GeographyPosition = new Gaea.Vector3(lat, lon, elevation || 0);
+    // 标签默认位置为左上角
+    screen.ScreenOffset = new Gaea.Vector2(left || 50, top || -100);
+    // screen.ScreenOffset = new Gaea.Vector2(left || 0, top || 0);
+    // screen.ScreenOffset = new Gaea.Vector2(-72, -130);
+    screen.ConnectAnchor = anchorType || 6;
+    screen.DrawLine = false;
+    // if (anchorType) {
+    //   screen.CnnectAnchor = Gaea.AnchorType[anchorType];
+    // } else {
+    //   screen.ConnectAnchor = Gaea.AnchorType.LeftDown;
+    // }
+    // 开启点击事件 默认为false
+    screen.EnablePick = true;
+    screen.VisibleRange = new Gaea.Vector2(min || 0, max || 10000);
+    // screen.Visible = true;
+    // screen.UseAutoVisible();
+    screen.OnHitElement = () => {
+      // onClick();
+    };
+    Gaea.World.Instance.RenderableObjectList.AddLast(screen);
+    // Gaea.World.Instance.DefaultCamera.SetPosition2(lat,lon,0,1500,0,0);
+    console.log("标签添加成功");
+    callback(screen, divId);
+  };
+
+  //移除广告牌标注
+  removeScreenElement = (screen, divId, holdDiv) => {
+    Gaea.World.Instance.RenderableObjectList.Remove(screen);
+
+    if (!holdDiv) {
+      // 通过ID获取DOM元素
+      var element = document.getElementById(divId);
+
+      // 如果该元素存在，则移除它
+      if (element) {
+        element.remove();
+      } else {
+        console.log("该盒子不存在");
+      }
+    }
+  };
+
+  /**
+   * 初始化容器
+   * @param {*} text
+   */
+  InitUI = (text = [], size, name) => {
+    // 边距容器 MouseFilter = 2 为不捕捉鼠标
+    const root = new Gaea.TextureRect(); //父容器
+    // root.Visible = show;
+    if (name) {
+      var tex = new Gaea.Texture(false);
+      tex.InstanceID =
+        Gaea.GaeaResourceLoader.Instance.GetResource(name).toString();
+      root.Texture = tex; // 图片名称
+
+      root.Expand = true; // 开启图片缩放
+      root.StretchMode = 6; // 缩放模式
+    }
+    // const root = new Gaea.Panel();
+    root.MouseFilter = 2; // 鼠标移到标记上可以转动视角
+    root.RectSize = new Gaea.Vector2(size[0], size[1]);
+    // 居中布局容器
+    const center = new Gaea.CenterContainer()
+    center.MouseFilter = 2
+    center.AnchorRight = 1
+    center.AnchorBottom = 1
+    center.MarginRight = 0
+    center.MarginBottom = 0
+    // 纵向排布容器
+    const vbox = new Gaea.VBoxContainer()
+    vbox.MouseFilter = 2
+    text.forEach(item => {
+      const label = new Gaea.Label()
+      label.Text = item;
+      vbox.AddChild(label, false)
+    });
+    center.AddChild(vbox, false)
+    root.AddChild(center, false)
+    return root
+  };
+
+  AddTD = () => {
+    //创建天地图影像对象
+    var store = new Gaea.TDTWMTSImageStore();
+    // 影像注记+PNG格式配置（经纬度投影）
+    store.ServerUri = "https://t{0}.tianditu.gov.cn/cia_c/wmts";
+    // 关键：FORMAT改为image/png（替换原有的tiles）
+    store.FormatString = "SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=cia&STYLE=default&TILEMATRIXSET=c&FORMAT=image/png&TILECOL={0}&TILEROW={1}&TILEMATRIX={2}&tk={3}";
+    // 同步修改ImageExtension为PNG
+    store.ImageExtension = Gaea.ImageExtensionEnum.PNG;
+    //天地图token
+    store.TK = "63201cfd7df1e1bff7d88bb8baa32151";
+    store.Name = "影像底图";
+    store.LevelRange = new Gaea.Vector2(9, 15); //设置可见层级
+    //添加到世界节点
+    Gaea.World.Instance.DefaultPyramidTileSet.AddImageStore(store);
+    // imgsoresTD.push(store);
+  }
+
+  /***
+   * 从获取的服务列表中添加图层
+   * @param {String} layerName 影像图层名称
+   */
+  addLayer = (layerObj, callback = () => { }) => {
+    const {
+      layerName,
+      max,
+      min,
+      transparency,
+      forMat = "image/vnd.jpeg-png",
+      inserIndex = null,
+    } = layerObj;
+
+    let forMatTypeList = [
+      "image/jpeg",
+      "image/png",
+      "image/tga",
+      "image/webp",
+      "image/bmp",
+      "application/json;type=geojson",
+      "image/vnd.jpeg-png",
+    ];
+    let forMatType = forMatTypeList.indexOf(forMat);
+    if (forMatType === -1) {
+      console.warn("暂无当前图层类型");
+    }
+    var ts_ibo_c;
+    var tileset = Gaea.World.Instance.DefaultPyramidTileSet;
+    if (this.layers == null) return;
+    //创建图层对象
+    ts_ibo_c = new Gaea.WMTSImageStore();
+    ts_ibo_c.ImageExtension = forMatType;
+    //拿出图层对象
+    var zcq = this.layers.filter((i) => i.Title == layerName)[0];
+    ts_ibo_c.CurrentCapabilitie = zcq;
+    //设置最大最小显示层级
+    if (max) {
+      ts_ibo_c.LevelRange = new Gaea.Vector2(min, max);
+    }
+    if (transparency) {
+      ts_ibo_c.ImageTransparency = transparency
+    }
+    //如果存在该对象，instanceID为空或者0
+    if (!ts_ibo_c.CurrentCapabilitie.InstanceID) {
+      console.error(`${layerName}图层加载异常`);
+    } else {
+      //设置影像图层的层级
+      if (inserIndex !== null) {
+        tileset.InsertImageStore(ts_ibo_c, inserIndex);
+      } else {
+        tileset.AddImageStore(ts_ibo_c);
+      }
+      console.log(`影像${layerName}添加成功`);
+      return ts_ibo_c;
+    }
+  };
+
+
+  /***
+   * 移除图层
+   * @param {String} layerName 影像图层名称
+   */
+  removeLayer = ({ layerName, layerElement }) => {
+    var tileset = Gaea.World.Instance.DefaultPyramidTileSet;
+    tileset.RemoveImageStore(layerElement);
+    console.log(`影像${layerName}移除成功`);
+  };
+  //添加VTS图层
+  addVts = (vtsObj, callback = () => { }) => {
+    let { vtsName, LineWidth, lineColor, height, max, min } = vtsObj;
+    var lineSymbol = new Gaea.LineSymbol(); //创建线符号
+    lineSymbol.DepthTestEnable = true; //深度检测
+    lineSymbol.LineWidth = LineWidth || 20; //设置宽度
+    // Symbol.LineColor = RgbcolorToGaeaColor(lineColor) || RgbcolorToGaeaColor("rgb(255,0,0)") //设置颜色
+    lineSymbol.LineColor =
+      RbgColorToVector3(lineColor) || RbgColorToVector3("rgb(255,92,0)");
+    lineSymbol.EmissionPower = 100;
+    // lineSymbol.EmissionPower = 1;
+    lineSymbol.HeightOffset = height || 0; //设置高度偏移
+    const cap = this.layers.find((i) => i.Title == vtsName); // 从服务列表layers中加载需要的矢量线服务
+    var store = new Gaea.WMTSVectorStore();
+    console.log(store);
+    store.Init(cap);
+    store.ImageExtension = Gaea.ImageExtensionEnum.GEOJSON;
+    if (max) {
+      store.LevelRange = new Gaea.Vector2(min, max); //设置可见层级
+    }
+    store.DefaultSymbol = lineSymbol; //设置符号样式
+    Gaea.World.Instance.DefaultVectorPyramidTileSet.AddImageStore(store);
+    Gaea.World.Instance.WorldEnvironment.Environment.GlowEnabled = false;
+    callback(store);
+  };
+
+  /***
+   * 贴地线加载
+   * @param {String} name 图层名称
+   * @param {Array} range 显示范围
+   * @param {Array} color 图层颜色
+   * @param {Number} index 图层层级
+   */
+  AddVTSLine = async ({ name, range, color, index }) => {
+    //贴地符号
+    var symbol = new Gaea.GroundPolylineSymbol();
+    symbol.Width = 2;
+    symbol.LineColor = new Gaea.Color(color[0] / 255, color[1] / 255, color[2] / 255, 1);
+    symbol.Priority = index;
+    var render = new Gaea.SimpleFeatureRenderer();
+    render.Symbol = symbol;
+    //服务名称,省界2
+    await this.CreateFeature(name, new Gaea.Vector2(range[0], range[1]), render);
+    return render;
+  }
+
+  //移除vts图层
+  RemoveVts = ({ vtsName, vtsData }) => {
+    Gaea.World.Instance.DefaultVectorPyramidTileSet.RemoveImageStore(Gaea.WMTSVectorStore.ConvertBy(Gaea.World.Instance.DefaultVectorPyramidTileSet.GetImageStore(vtsName)));
+    console.log(`vts影像${vtsName}移除成功`);
+
+    // 从数组中也将元素删除
+    const targetIndex = groundLineList.value.findIndex(item => item.name === vtsName);
+    if (targetIndex !== -1) {
+      groundLineList.value.splice(targetIndex, 1); // 删除当前索引的1个元素
+    }
+  };
+
+
+  AddVTSLineText = async ({ name, range, color, Field }) => {
+    // var symbol = new Gaea.LineSymbol()
+    // symbol.LineWidth = 1;
+    // symbol.LineColor = new Gaea.Color(color[0] / 255, color[1] / 255, color[2] / 255, 1);
+
+    // var render5 = new Gaea.SimpleFeatureRenderer();
+    // render5.Symbol = symbol;
+    // await this.CreateFeature(name, new Gaea.Vector2(range[0], range[1]), render5,);
+
+    var symbolText = new Gaea.TextMarkSymbol()
+    symbolText.MarkSize = 20;
+    symbolText.Field = Field;
+    symbolText.FontColor = new Gaea.Color(color[0] / 255, color[1] / 255, color[2] / 255, 1);
+
+    //沿线标注
+    var render = new Gaea.InstanceFeatureRenderer()
+    render.RenderType = Gaea.RenderTypeEnum.Along;
+    render.Symbol = symbolText
+    await this.CreateFeature(name, new Gaea.Vector2(range[0], range[1]), render);
+  }
+
+  CreateFeature = async (serviceName, levelRange, render, alias) => {
+    const cap = this.layers.find((i) => i.Title == serviceName); // 从服务列表layers中加载需要的矢量线服务
+    var store = new Gaea.WMTSVectorStore();
+    store.Name = alias == null ? serviceName : alias;
+    store.Init(cap);
+    store.ImageExtension = Gaea.ImageExtensionEnum.GEOJSON;
+    store.LevelRange = levelRange;
+    if (render != null) store.DefaultRenderer = render;
+    Gaea.World.Instance.DefaultVectorPyramidTileSet.AddImageStore(store);
+    this.vectorServiceList.push(store);
+  };
+
+  /***
+   * 添加图片标注
+   * @param {String} image bs64图片地址||图片路径
+   * @param {Array} extent 图片的位置
+   * @return {Number} 图片的id
+   */
+
+  // addImage = async (image, extent, callback) => {
+
+  //   const reg =
+  //     /^\s*data:(?:[a-z]+\/[a-z0-9-+.]+(?:;[a-z-]+=[a-z0-9-]+)?)?(?:;base64)?,([a-z0-9!$&',()*+;=\-._~:@/?%\s]*?)\s*$/i;
+  //   if (reg.test(image)) {
+  //     // ---------------------分割线---下面是base64图片导入-----------------
+  //     //加载base64图片
+  //     var base64 = image;
+  //     var img = base64.replace(/^data:image\/\w+;base64,/, "");
+  //     let flieName = uuid();
+  //     //base64加载图片至图片数据库
+  //     var id = Gaea.GaeaResourceLoader.Instance.LoadResourceFromBase64(
+  //       img,
+  //       flieName + ".png"
+  //     );
+  //     console.log(id);
+  //     var path = "user://resources/" + flieName + ".png";
+
+  //     // console.log(path);
+  //     var invalidColor = new Gaea.Color(0, 0, 0, 1);
+  //     //渲染图片
+  //     // var imageId = Gaea.DecalManager.Instance.CreateItem(
+  //     //   extent[3],
+  //     //   extent[1],
+  //     //   extent[0],
+  //     //   extent[2],
+  //     //   invalidColor,
+  //     //   path
+  //     // );
+  //     var imageId = Gaea.DecalManager.Instance.CreateItem(
+  //       extent[0],
+  //       extent[1],
+  //       extent[2],
+  //       extent[3],
+  //       invalidColor,
+  //       path
+  //     );
+  //     console.log(imageId);
+  //     return imageId;
+  //   } else {
+  //     // ---------------------分割线---下面是imgae图片导入-----------------
+  //     // 加载静态图片
+  //     var flieName = getFlieName(image);
+  //     console.log(flieName);
+  //     await this.LoadResourceFromUrl(image, flieName);
+  //     var path = "user://resources/" + flieName;
+
+  //     // console.log(path);
+  //     // console.log(path);
+  //     var invalidColor = new Gaea.Color(0, 0, 0, 1);
+  //     //渲染图片
+  //     // var imageId = Gaea.DecalManager.Instance.CreateItem(
+  //     //   extent[3],
+  //     //   extent[1],
+  //     //   extent[0],
+  //     //   extent[2],
+  //     //   invalidColor,
+  //     //   path
+  //     // );
+  //     var imageId = Gaea.DecalManager.Instance.CreateItem(
+  //       extent[0],
+  //       extent[1],
+  //       extent[2],
+  //       extent[3],
+  //       invalidColor,
+  //       path
+  //     );
+  //     console.log(imageId);
+  //     callback(imageId);
+  //   }
+  // };
+  /***
+   * 移除图片标注
+   * @param {Number} featureId 标注id
+   * @return {Number} 标注的id
+   */
+  removeImage = (imageId) => {
+    Gaea.DecalManager.Instance.RemoveItem(imageId);
+    return imageId;
+  };
+  //切换播放云图函数
+  addYtImage = async (imgList, extend, callback = () => { }) => {
+    const stepTime = 2000;
+    let i = 0;
+    var invalidColor = new Gaea.Color(0, 0, 0, 1);
+    const timerFn = async () => {
+      let element = imgList[i];
+      await this.LoadResourceFromUrl(element.url, element.name);
+      if (ytImageId) {
+        Gaea.DecalManager.Instance.RemoveItem(ytImageId);
+        ytImageId = null;
+      }
+      i++;
+      ytImageId = Gaea.DecalManager.Instance.CreateItem(
+        extend[0],
+        extend[1],
+        extend[2],
+        extend[3],
+        invalidColor,
+        "user://resources/" + element.name
+      );
+      callback(element.date);
+      if (i === imgList.length) {
+        i = 0;
+      }
+    };
+    timerFn();
+    ytTimer = setInterval(timerFn, stepTime);
+  };
+  //移除云图演变效果
+  removeYtImage = () => {
+    clearInterval(ytTimer);
+    if (ytImageId) {
+      Gaea.DecalManager.Instance.RemoveItem(ytImageId);
+      ytImageId = null;
+    }
+  };
+  //添加iconFont标注
+  addSymbol = async (SymbolObj, callback = () => { }) => {
+    let { jsonUrl, IconStyle, FontStyle, max, min } = SymbolObj;
+
+    var iconurl = IconStyle?.IconUrl;
+    let fileName = getFlieName(jsonUrl);
+    if (iconurl) {
+      await LoadResourceAsync(iconurl);
+    }
+    await LoadResourceAsync(jsonUrl);
+
+    var ws = Gaea.WorkspaceFactory.OpenFromFile(`user://resources/${fileName}`);
+    var fclass = ws.OpenFeatureClass(true, false);
+
+    var Symbol = new Gaea.CompositeSymbol();
+    Symbol.HeightOffset = 5000;
+    var Field = FontStyle?.Field;
+    //配置文字样式
+    if (Field) {
+      var textSymbol = new Gaea.TextMarkSymbol();
+      textSymbol.MarkSize = FontStyle?.FontSize || 20;
+      textSymbol.Field = FontStyle?.Field || "Name";
+      textSymbol.Fontgap = 0.5;
+      //["Left","Right","Up","Down"]
+      if (FontStyle?.FontColor?.length > 0) {
+        textSymbol.FontColor = RgbcolorToGaeaColor(FontStyle.FontColor);
+        textSymbol.OutLineColor = RgbcolorToGaeaColor(
+          FontStyle.FontoOutLineColor
+        );
+      }
+      textSymbol.Anchor = FontStyle?.FontAnchor
+        ? Gaea.AnchorType[FontStyle.FontAnchor]
+        : Gaea.AnchorType.Right;
+      Symbol.AddSymbol(textSymbol);
+    }
+
+    // //配置icon样式
+    if (iconurl) {
+      var iconSymbol = new Gaea.IconMarkSymbol();
+
+      iconSymbol.MarkSize = IconStyle?.IconSize || 20;
+      var tex_id = Gaea.GaeaResourceLoader.Instance.GetResource(
+        getFlieName(iconurl)
+      );
+      var tex = new Gaea.Texture(false);
+      var tex1 = Gaea.GaeaResourceLoader.Instance.LoadLoaclResource(
+        "res://assets/images/warningIcon/warningIcon.res"
+      );
+      tex.InstanceID = tex_id + "";
+      iconSymbol.Icon = tex1;
+
+      Symbol.AddSymbol(iconSymbol);
+    }
+
+    var flayer = new Gaea.FeatureLayer();
+    var FeatureRenderer = new Gaea.SimpleFeatureRenderer();
+    FeatureRenderer.Symbol = Symbol;
+    flayer.VisibleRange = new Gaea.Vector2(min, max);
+    flayer.FeatureClass = fclass;
+    flayer.FeatureRenderer = FeatureRenderer;
+    // flayer.Priority = 100
+
+    callback(flayer);
+    Gaea.World.Instance.RenderableObjectList.AddLast(flayer);
+  };
+  //移除iconFont标注
+  removeSymbol = (flayer) => {
+    Gaea.World.Instance.RenderableObjectList.Remove(flayer);
+  };
+  //添加自定义图标
+  addSetPoint = async (pointObj, callback = () => { }) => {
+    const {
+      poitnData,
+      iconUrl = `${serveLocal}/icon/当前位置.png`,
+      FontColor,
+      FontSize = 20,
+      IconSize = 20,
+    } = pointObj;
+    const PointTextSymbol = new Gaea.TextMarkSymbol(); //创建字体符号
+    const PointIconSymbol = new Gaea.IconMarkSymbol(); //创建图标
+    // const iconUrl = `${serveLocal}/icon/当前位置.png`
+    await LoadResourceAsync(iconUrl);
+    const iconName = getFlieName(iconUrl);
+    var id = Gaea.GaeaResourceLoader.Instance.GetResource(iconName);
+    var tex = new Gaea.Texture(false);
+    tex.InstanceID = id + "";
+
+    // var points = [
+    //   new Gaea.Vector3(34.5694745790576, 105.962108201382, 100), //社棠镇
+    //   new Gaea.Vector3(34.708176474057, 105.396793259202, 100),  //六峰镇
+    //   new Gaea.Vector3(34.8066648907865, 105.454541877039, 100),  //金山乡
+    //   new Gaea.Vector3(34.589829786221, 105.207673919421, 100),
+    //   new Gaea.Vector3(34.6822687130929, 105.31284238242, 100)
+    // ];
+    // var names = [
+    //   "社棠镇",
+    //   "六峰镇",
+    //   "金山乡",
+    //   "古坡乡",
+    //   "白家湾乡"
+    // ]
+    const points = poitnData.map((item) => {
+      return new Gaea.Vector3(item.position.x, item.position.y, 100);
+    });
+    const names = poitnData.map((item) => {
+      return item.name;
+    });
+    //创建组合符号
+    var Symbol = new Gaea.CompositeSymbol();
+    PointTextSymbol.MarkSize = FontSize; //设置大小
+    PointTextSymbol.FontColor = new Gaea.Color(
+      FontColor[0],
+      FontColor[1],
+      FontColor[2],
+      FontColor[3]
+    ); //设置颜色
+    PointTextSymbol.Field = "name"; //显示字段名
+    PointTextSymbol.HeightOffset = 0; //设置高度偏移
+    PointTextSymbol.Anchor = Gaea.AnchorType.Up; //字体停靠方向
+    PointTextSymbol.Fontgap = 0.5; //字体间距
+    Symbol.AddSymbol(PointTextSymbol);
+
+    PointIconSymbol.HeightOffset = 0;
+    PointIconSymbol.Icon = tex;
+    PointIconSymbol.MarkSize = IconSize;
+    Symbol.AddSymbol(PointIconSymbol);
+
+    const pointElements = [];
+    for (var i = 0; i < points.length; i++) {
+      var element = new Gaea.Element();
+
+      var pos = [points[i]];
+      var Shape = Gaea.Geometry.Create1(Gaea.GeometryType.Point, pos);
+      var Feature = new Gaea.Feature();
+      var fields = new Gaea.Fields();
+      var field = new Gaea.Field();
+      field.Name = "name";
+      fields.AddField(field);
+      Feature.SetFields(fields);
+      Feature.SetStringValue("name", names[i]);
+      Feature.SetShape(Shape);
+      var element = new Gaea.PointGeometryElement();
+      element.Feature = Feature;
+      element.Symbol = Symbol;
+      Gaea.World.Instance.RenderableObjectList.AddLast(element);
+      pointElements.push({
+        name: names[i],
+        element,
+      });
+    }
+    callback(pointElements);
+  };
+  //移除自定义图标
+  removeSetPoint = (pointElements) => {
+    pointElements.forEach((item) => {
+      Gaea.World.Instance.RenderableObjectList.Remove(item.element);
+    });
+  };
+
+  async addGeoJson(obj, cb = () => { }, cb1 = () => { }) {
+    console.log(obj, obj.params.Field, "************");
+    let names = obj.params.Field;
+    // console.log(url, name, fieldName, minHeight, maxHeight, img, "************");
+    // const layer = Gaea.World.Instance.RenderableObjectList.GetByName(layerName);
+    // if (layer._InstanceID) {
+    //   layer.Visible = true;
+    //   layer.UseAutoVisible();
+    //   return;
+    // }
+    let imgName;
+    Gaea.QueryServer.Instance.Enable = false;
+    if (obj.labelImg) {
+      imgName = obj.label;
+    } else {
+      imgName = "当前点位";
+    }
+    const iconUrl = obj.labelImg;
+    const iconName = getFlieName(iconUrl);
+    var id = Gaea.GaeaResourceLoader.Instance.GetResource(iconName);
+    console.log("id:", id);
+    if (id === 0) {
+      // 说明第一次加载
+      console.log("第一次加载资源");
+      await LoadResourceAsync(iconUrl);
+      // 再次获取一次
+      id = Gaea.GaeaResourceLoader.Instance.GetResource(iconName);
+    }
+    // var id = Gaea.GaeaResourceLoader.Instance.GetResource("雨量1.png");
+    let tex = new Gaea.ImageTexture(false);
+    tex.InstanceID = id + "";
+    const img1 = tex.GetData();
+    img1.SrgbToLinear();
+    tex.CreateFromImage(img1, 7);
+    var res = "user://resources/";
+    Gaea.GaeaResourceLoader.Instance.LoadResourceFromUrl1(
+      `${serveLocal}/json/图层树/测试数据/${obj.params.jsonUrl}`,
+      obj.params.jsonUrl,
+      (code, msg) => {
+        var ws = Gaea.WorkspaceFactory.OpenFromFile(res + obj.params.jsonUrl);
+        var fclass = ws.OpenFeatureClass(true, false);
+        var flayer = new Gaea.FeatureLayer();
+        flayer.Name = obj.params.jsonUrl.split(".")[0];
+        flayer.FeatureClass = fclass;
+        // if (maxHeight) {
+        //   // flayer.VisibleRange = new Gaea.Vector2(Number(minHeight), Number(maxHeight));
+        // } else {
+        flayer.VisibleRange = new Gaea.Vector2(0, 100000000000);
+        // }
+        var icomSymbol = new Gaea.IconMarkSymbol();
+        icomSymbol.MarkSize = 24;
+        icomSymbol.Field = names;
+        icomSymbol.Priority = 127;
+        icomSymbol.UseMergedTextures = false;
+        icomSymbol.AddIcon("default", tex);
+        icomSymbol.Icon = tex;
+        var textSymbol = new Gaea.TextMarkSymbol();
+        textSymbol.TextOffset = 24;
+        textSymbol.FontColor = new Gaea.Color(0.7, 0.8, 0.9, 1); // 字体颜色
+        textSymbol.HoverColor = new Gaea.Color(0.7, 0.8, 0.9, 1); // 字体颜色
+        textSymbol.Priority = 127;
+        textSymbol.MarkSize = 24;
+        textSymbol.Field = names;
+        textSymbol.Anchor = Gaea.AnchorType.Up;
+        var Symbol = new Gaea.CompositeSymbol();
+        Symbol.AddSymbol(icomSymbol);
+        Symbol.AddSymbol(textSymbol);
+        const flayerArr = [];
+        var FeatureRenderer = new Gaea.InstanceFeatureRenderer();
+        FeatureRenderer.RenderType = Gaea.RenderTypeEnum.Collision;
+        FeatureRenderer.Symbol = Symbol;
+        window.flayer = flayer;
+        FeatureRenderer.EnablePick = true;
+        // FeatureRenderer.SelectedCallBack((fid) =>
+        //   {
+        //       console.log(fid,'----111222333');
+
+        //   let node = fclass.GetFeature(fid);
+        //   let name = node.GetStringValue(names);
+        //   if (name && window.viewPoint) {
+        //     // try {
+        //     //   setTimeout(() => {
+        //     //     window.open(`/datas/pdf/${name}.pdf`)
+        //     //   }, 100);
+        //     // } catch (error) {
+        //     //   console.log(error);
+        //     // }
+        //     // cb(name);
+        //   }
+        // });
+        var compositeSymbol = new Gaea.CompositeSymbol(); // 组合符号
+        compositeSymbol.AddSymbol(icomSymbol); // 加入图标符号
+        compositeSymbol.AddSymbol(textSymbol); // 加入文字符号
+        // HeightOffset = 100000,
+        FeatureRenderer.Symbol = compositeSymbol; //设置渲染器的符号
+        flayer.FeatureRenderer = FeatureRenderer; //设置图层中的渲染器， 即FeatureRenderer
+        flayer.EnableCollision = true;
+        flayer.EnablePick = true;
+        FeatureRenderer.SelectedCallBackMessage((message, pos, name) => {
+          cb1(name);
+          console.log(message, pos, name, "---1111111");
+        });
+        console.log("---22222");
+
+        flayer.FeatureRenderer = FeatureRenderer;
+        // flayer.FeatureRenderer = FeatureRenderer;
+        // flayer.EnablePick = true
+        // Gaea.World.Instance.CollisionManager.AddFeatureLayer(flayer);
+        // flayer.EnableCollision = true;
+        Gaea.World.Instance.RenderableObjectList.AddLast(flayer);
+        flayerArr.push(flayer);
+        cb(flayerArr);
+        console.log("------添加geojson----完成", flayerArr);
+        // });
+      }
+    );
+  }
+  removeGeoJson(symbolElement) {
+    // debugger
+    Gaea.World.Instance.RenderableObjectList.Remove(symbolElement);
+  }
+
+  /**
+ * 仅转换数组中第三个、第五个、第六个值（索引2、4、5）为角度
+ * @param {number[]} values - 输入的数值数组，长度需至少为6
+ * @returns {number[]} 转换后的数组（原数组不会被修改）
+ */
+  convertSpecificValues(values) {
+    // 检查输入是否为数组且长度足够
+    if (!Array.isArray(values) || values.length < 6) {
+      throw new Error("输入必须是长度至少为6的数组");
+    }
+
+    // 复制原数组，避免修改原数据
+    const result = [...values];
+    // 弧度转角度的换算系数（180/π）
+    const radToDeg = 180 / Math.PI;
+
+    // 转换第三个值（索引2）
+    result[2] = values[2] * radToDeg;
+    // 转换第五个值（索引4）
+    result[4] = values[4] * radToDeg;
+    // 转换第六个值（索引5）
+    result[5] = values[5] * radToDeg;
+
+    return result;
+  }
+
+  /**
+   * 高级定位
+   * @param {Number} numStr 定位字符串
+   * @return {void}
+   **/
+  SetPosition = (numStr) => {
+    // 转换为纯数字数组
+    const numArray = numStr
+      .split(',') // 按逗号分割为字符串数组 → ["27.3436...", " 120.4490...", ...]
+      .map(item => item.trim()) // 去除每个元素的前后空格 → ["27.3436...", "120.4490...", ...]
+      .map(Number); // 转为数值类型 → [27.3436..., 120.4490..., ...]
+    const camera = Gaea.World.Instance.DefaultCamera;
+    // let posList = this.convertSpecificValues(numArray)
+    camera.SetPosition2(numArray[0], numArray[1], numArray[2], numArray[3], numArray[4], numArray[5]);
+  };
+
+  //记录当前坐标
+  favorite = (cb = () => { }) => {
+    var uri = Gaea.GaeaCamera.ConvertBy(Gaea.World.Instance.DefaultCamera).Favorite();
+    cb(uri);
+    return uri;
+  };
+  //定位到uri位置
+  favoritePosition = (uri) => {
+    var camera = Gaea.World.Instance.DefaultCamera;
+    camera.GotoFavorite(uri);
+  };
+  //同步加载地形
+  promiseTerrain = (url) => {
+    return new Promise((resolve, reject) => {
+      Gaea.World.Instance.InitTerrainServer2(url, () => {
+        resolve();
+      });
+    });
+  };
+  /**
+   * 加载地形
+   * @param {String} url
+   * @return {void}
+   */
+  addInitTerrainServer = () => {
+    return new Promise(async (res, rej) => {
+      let tarrainKeys = Object.keys(TerrainList);
+      if (tarrainKeys.length === 0) {
+        res();
+      } else {
+        for (let i = 0; i < tarrainKeys.length; i++) {
+          const item = tarrainKeys[i];
+          console.log(item);
+          const urlItem = TerrainList[item];
+          console.log(urlItem);
+          await this.promiseTerrain(urlItem);
+          if (i === tarrainKeys.length - 1) {
+            res();
+          }
+        }
+      }
+    });
+  };
+  //使用三角网生成云图
+  addDtsjw = async (params, callback = () => { }) => {
+    const { imgList, res } = params;
+    console.log("三角网url", imgList, res);
+
+    //设置三角网范围
+    // var url = "http://localhost:9878/txt/output(1).json"
+    vt = new Gaea.VertextGeometryElement();
+    vt.DisplayType = Gaea.VertextGeometryElementDisplayType.Triangles; // 展示模式[Line(线模式),Triangles(面模式)]
+    vt.NeedNormal = true; // 是否需要计算法线
+    vt.VertextCoordinates = Gaea.VertextType.LatLon;
+    vt.ParseJsonToObject(res);
+    let i = 1;
+    vt.Visible = false;
+    Gaea.World.Instance.RenderableObjectList.AddLast(vt);
+    vt.Commit();
+
+    vt.OnModelInit(async () => {
+      let id1;
+      let id2;
+      let tex1;
+      let tex2;
+      //设置抬升高度
+      vt.TranslateObjectLocal(new Gaea.Vector3(0, 5000, 0));
+      // vt.GeographyPosition = new Gaea.Vector3(35, 127, 2000); // 修改模型位置
+      const isometricRendering = new Gaea.EquivocalRenderingMaterial();
+      isometricRendering.TrianglesInterpolationValue = 0; //插值系数
+      isometricRendering.Transparency = 0.6;
+      isometricRendering.RenderingType =
+        Gaea.EquivocalRenderingType.PictureTrianglesInterpolation; // 渲染模式[Line(线渲染),ValueTriangles(值渲染),ValueTrianglesInterpolation(值插值渲染)]
+      isometricRendering.UseUV = true;
+      // isometricRendering.LinesColor = new Gaea.Color(1, 0.5, 0, 1); // 线渲染模式下的线颜色
+      var spatial = Gaea.Spatial.ConvertBy(vt.GetChild(0));
+      var meshInstance = Gaea.MeshInstance.ConvertBy(spatial.GetChild(0));
+      meshInstance.CastShadow = 0; // 取消阴影
+      meshInstance.MaterialOverride = isometricRendering;
+
+      //改变图片的逻辑
+      const changeImg = async () => {
+        if (i % 2 === 1) {
+          await this.LoadResourceFromUrl(
+            imageUrlApi + imgList[i - 1].baseUrl,
+            imgList[i - 1].fileName
+          );
+          await this.LoadResourceFromUrl(
+            imageUrlApi + imgList[i].baseUrl,
+            imgList[i].fileName
+          );
+          vt.Visible = true;
+          id1 = Gaea.GaeaResourceLoader.Instance.GetResource(
+            imgList[i - 1].fileName
+          );
+          tex1 = new Gaea.Texture(false);
+          tex1.InstanceID = id1 + "";
+          // tex1.Flags = 0;
+          id2 = Gaea.GaeaResourceLoader.Instance.GetResource(
+            imgList[i].fileName
+          );
+          tex2 = new Gaea.Texture(false);
+          tex2.InstanceID = id2 + "";
+          // tex2.Flags = 0;
+        }
+
+        if (i % 2 === 0) {
+          await this.LoadResourceFromUrl(
+            imageUrlApi + imgList[i - 1].baseUrl,
+            imgList[i - 1].fileName
+          );
+          await this.LoadResourceFromUrl(
+            imageUrlApi + imgList[i].baseUrl,
+            imgList[i].fileName
+          );
+          id1 = Gaea.GaeaResourceLoader.Instance.GetResource(
+            imgList[i - 1].fileName
+          );
+          tex1 = new Gaea.Texture(false);
+          tex1.InstanceID = id2 + "";
+          // tex1.Flags = 0;
+          id2 = Gaea.GaeaResourceLoader.Instance.GetResource(
+            imgList[i].fileName
+          );
+          tex2 = new Gaea.Texture(false);
+          tex2.InstanceID = id1 + "";
+          // tex2.Flags = 0;
+        }
+
+        // meshInstance.RotateObjectLocal(Gaea.Vector3.Left, Gaea.Mathf.Deg2Rad(180)); // 旋转模型
+        isometricRendering.DeduceValueTexture(tex1, tex2);
+
+        if (isometricRendering.TrianglesInterpolationValue === 0) {
+          isometricRendering.TrianglesInterpolationValue === 1;
+        } else if (isometricRendering.TrianglesInterpolationValue === 1) {
+          isometricRendering.TrianglesInterpolationValue === 0;
+        }
+        callback(imgList[i].collectTime);
+
+        if (i >= imgList.length - 1) {
+          i = 1;
+        } else {
+          i++;
+        }
+      };
+
+      // const changeImg = async () => {
+      //   if (i % 2 === 1) {
+      //     await this.LoadResourceFromUrl(
+      //       imgList[i - 1].imageUrl,
+      //       imgList[i - 1].fileName
+      //     );
+      //     await this.LoadResourceFromUrl(
+      //       imgList[i].imageUrl,
+      //       imgList[i].fileName
+      //     );
+      //     vt.Visible = true
+      //     id1 = Gaea.GaeaResourceLoader.Instance.GetResource(
+      //       imgList[i - 1].fileName
+      //     );
+      //     tex1 = new Gaea.Texture(false);
+      //     tex1.InstanceID = id1 + "";
+      //     // tex1.Flags = 0;
+      //     id2 = Gaea.GaeaResourceLoader.Instance.GetResource(
+      //       imgList[i].name
+      //     );
+      //     tex2 = new Gaea.Texture(false);
+      //     tex2.InstanceID = id2 + "";
+      //     // tex2.Flags = 0;
+      //   }
+
+      //   if (i % 2 === 0) {
+      //     await this.LoadResourceFromUrl(
+      //       imgList[i - 1].imageUrl,
+      //       imgList[i - 1].fileName
+      //     );
+      //     await this.LoadResourceFromUrl(
+      //       imgList[i].imageUrl,
+      //       imgList[i].fileName
+      //     );
+      //     id1 = Gaea.GaeaResourceLoader.Instance.GetResource(
+      //       imgList[i - 1].fileName
+      //     );
+      //     tex1 = new Gaea.Texture(false);
+      //     tex1.InstanceID = id2 + "";
+      //     // tex1.Flags = 0;
+      //     id2 = Gaea.GaeaResourceLoader.Instance.GetResource(
+      //       imgList[i].fileName
+      //     );
+      //     tex2 = new Gaea.Texture(false);
+      //     tex2.InstanceID = id1 + "";
+      //     // tex2.Flags = 0;
+      //   }
+
+      //   // meshInstance.RotateObjectLocal(Gaea.Vector3.Left, Gaea.Mathf.Deg2Rad(180)); // 旋转模型
+      //   isometricRendering.DeduceValueTexture(tex1, tex2);
+
+      //   if (isometricRendering.TrianglesInterpolationValue === 0) {
+      //     isometricRendering.TrianglesInterpolationValue === 1
+      //   } else if (isometricRendering.TrianglesInterpolationValue === 1) {
+      //     isometricRendering.TrianglesInterpolationValue === 0
+      //   }
+      //   callback(imgList[i].date)
+
+      //   if (i >= imgList.length - 1) {
+      //     i = 1
+      //   } else {
+      //     i++
+      //   }
+      // }
+      changeImg();
+      ytTimer = setInterval(changeImg, 2000);
+    });
+  };
+  //移除三角网
+  removeDtsjw = () => {
+    Gaea.World.Instance.RenderableObjectList.Remove(vt);
+    if (ytTimer) {
+      clearInterval(ytTimer);
+    }
+  };
+
+  // //监听鼠标点击事件
+  // addMouseUp = (cb = null) => {
+  //   this.mouserUp = Gaea.World.Instance.OnMouseUp((p, b) => {
+  //     if (b == 1) {
+  //       console.log(b);
+  //       var camera = Gaea.World.Instance.DefaultCamera;
+  //       var screenpos = new Gaea.Vector2(p.x, p.y);
+  //       var spacepos = Gaea.GaeaMath.ProjectPosition(screenpos);
+  //       var latlonalt = Gaea.GaeaMath.CartesianToSphericalDeg(spacepos);
+  //       var spacepos2 = Gaea.GaeaMath.SphericalToCartesianDeg(latlonalt);
+  //       var screenpos2 = Gaea.GaeaMath.UnProjectPosition(spacepos2);
+
+  //       //屏幕坐标
+  //       console.log("屏幕坐标--------", screenpos.instance);
+  //       //屏幕空间转笛卡尔坐标
+  //       console.log("屏幕空间转笛卡尔坐标------", spacepos.instance);
+  //       //经纬度坐标
+  //       console.log("经纬度坐标------", latlonalt.instance);
+  //       //还原笛卡尔坐标
+  //       console.log("还原笛卡尔坐标------", spacepos2.instance);
+  //       //还原为屏幕坐标
+  //       console.log("还原为屏幕坐标------", screenpos2.instance);
+  //       // 鼠标高度
+  //       console.log("鼠标高度------", camera.Altitude);
+
+  //       cb(latlonalt.instance, screenpos.instance, camera.Altitude);
+  //     }
+  //   });
+  // };
+  // //移除鼠标点击事件
+  // removeMouseUp = () => {
+  //   if (this.mouserUp) {
+  //     Gaea.World.Instance.ClearEvent(this.mouserUp);
+  //     this.mouserUp = null;
+  //   }
+  // };
+  // //监听滚动事件
+  // addMouseWhill = (cb = null) => {
+  //   this.mouserWheel = Gaea.World.Instance.OnMouseWheel((p, b) => {
+  //     // console.log(b, p);
+  //     if (p == 1 || p == -1) {
+  //       var zHeight = Gaea.World.Instance.DefaultCamera.Altitude;
+  //       // console.log('高度变化-------', zHeight,);
+  //       cb(zHeight);
+  //     }
+  //   });
+  // };
+  // //移除监听滚动事件
+  // removeMouserWheel = () => {
+  //   if (this.mouserWheel) {
+  //     Gaea.World.Instance.ClearEvent(this.mouserWheel);
+  //     this.mouserWheel = null;
+  //   }
+  // };
+  // //添加鼠标移动事件
+  // addMouseMove = (cb = null) => {
+  //   this.mouseMove = Gaea.World.Instance.OnMouseMove((p, b) => {
+  //     if (b == 1) {
+  //       var screenpos = new Gaea.Vector2(p.x, p.y);
+  //       var spacepos = Gaea.GaeaMath.ProjectPosition(screenpos);
+  //       var latlonalt = Gaea.GaeaMath.CartesianToSphericalDeg(spacepos);
+  //       var spacepos2 = Gaea.GaeaMath.SphericalToCartesianDeg(latlonalt);
+  //       var screenpos2 = Gaea.GaeaMath.UnProjectPosition(spacepos2);
+
+  //       //屏幕坐标
+  //       console.log(screenpos.instance);
+  //       //屏幕空间转笛卡尔坐标
+  //       console.log(spacepos.instance);
+  //       //经纬度坐标
+  //       console.log(latlonalt.instance);
+  //       //还原笛卡尔坐标
+  //       console.log(spacepos2.instance);
+  //       //还原为屏幕坐标
+  //       console.log(screenpos2.instance);
+  //       // Gaea.World.Instance.ClearEvent(move)
+  //       // Gaea.World.Instance.ClearEvent(up)
+
+  //       cb(latlonalt.instance, screenpos.instance);
+  //       // this.point = latlonalt.instance
+  //       // console.log(this.point);
+  //     }
+  //   });
+  // };
+  // //移除鼠标移动事件
+  // removeMouseMove = () => {
+  //   if (this.mouseMove) {
+  //     Gaea.World.Instance.ClearEvent(this.mouseMove);
+  //     this.mouseMove = null;
+  //   }
+  // };
+
+  // 模型发光
+  setRiverGltfElementEmission = (
+    elementArr,
+    { floor, color, emissionEnergy, emissionOperator, waterLevel }
+  ) => {
+    const root = elementArr[0].Root.GetChild(floor);
+
+    const rootInstance = Gaea.MeshInstance.ConvertBy(root),
+      activeMaterial = rootInstance.GetActiveMaterial(0),
+      SpatialMaterial = Gaea.SpatialMaterial.ConvertBy(activeMaterial);
+
+    SpatialMaterial.EmissionEnabled = true;
+
+    SpatialMaterial.Emission = new Gaea.Color(
+      color[0] / 255,
+      color[1] / 255,
+      color[2] / 255,
+      color[3]
+    );
+
+    SpatialMaterial.EmissionEnergy = emissionEnergy;
+
+    SpatialMaterial.EmissionOperator = emissionOperator;
+
+    // elementArr.forEach((item) => {
+    //   var v = new Gaea.Vector3(0, waterLevel, 0);
+    //   item.Root.TranslateObjectLocal(v);
+    // });
+  };
+
+  /**
+   * @param {String} name 模型的名称
+   * @param {String} url 模型的请求位置
+   * @param {Object} position 模型的位置
+   * @param {Object} size 模型的大小
+   * @param {Boolean} show 是否展示当前模型
+   * @param {Boolean} enablePick 当前模型是否触发点击事件
+   * @param {Boolean} useAbsoluteHeight 是否使用绝对定位
+   * @param {Array} children 主模型下的子模型
+   * @param {Array} billboard 主模型下某层的面片
+   * @param {Function} clickCallBack 模型点击事件回调
+   */
+  AddGltf = ({
+    name,
+    url,
+    position,
+    rotate,
+    size,
+
+    show = true,
+    childBillboard,
+    enablePick,
+    useAbsoluteHeight = true,
+    children,
+    billboard,
+    clickChilrenNameArray,
+    emissionConfig = [],
+    initFun = () => { },
+    clickCallBack = () => { },
+    clickChilrenCallBack = () => { },
+  }) => {
+    return new Promise(async (res, rej) => {
+      const element = new Gaea.GLTFElement();
+
+      // 是否使用绝对定位
+      element.UseAbsoluteHeight = useAbsoluteHeight;
+
+      // 模型请求地址
+      element.ResourceName = url;
+
+      console.log("模型开始加载：" + name);
+      console.log(new Date().Format("yyyy-MM-dd HH:mm:ss"));
+
+      element.OnModelInit(async () => {
+        var n = element.Root.GetChildCount();
+        if (name.includes('YPDP0')) {
+          for (var i = 0; i < n; i++) {
+            var meshinstance = Gaea.MeshInstance.ConvertBy(element.Root.GetChild(i))
+            var count = meshinstance.Mesh.GetSurfaceCount();
+            for (var j = 0; j < count; j++) {
+              var meshInstance_mtl = Gaea.SpatialMaterial.ConvertBy(meshinstance.Mesh.SurfaceGetMaterial(j));
+              meshInstance_mtl.FlagsUnshaded = true;
+            }
+          }
+        }
+        console.log(new Date().Format("yyyy-MM-dd HH:mm:ss"));
+        console.log("模型加载完毕：" + name);
+        // 模型初始化方法
+        if (initFun) {
+          initFun();
+        }
+        // 模型点击
+        element.EnablePick = enablePick;
+        Gaea.QueryServer.Instance.Enable = enablePick;
+
+        // 模型定位
+        element.GeographyPosition = new Gaea.Vector3(
+          position.x,
+          position.y,
+          position.z
+        );
+
+        // 模型旋转
+        element.TiltHeadingBank = new Gaea.Vector3(
+          rotate[0],
+          rotate[1],
+          rotate[2]
+        );
+
+        // 模型缩放
+        element.Root.Scale = new Gaea.Vector3(size[0], size[1], size[2]);
+
+        // 模型命名 
+        element.Root.Name = name;
+
+        // 在当前模型下添加子模型
+        if (children && children.length != 0) {
+          let childrenElement = [];
+          children.forEach(async (item) => {
+            console.log(name);
+
+            switch (item.type) {
+              case "gltf":
+                childrenElement.push(await this.addChildrenGltf(element, item));
+                element.childrenElement = childrenElement;
+                break;
+              case "Billboard":
+                this.addChildrenBillboard(element, item);
+                break;
+            }
+          });
+        }
+
+        // 在当前模型下某层添加面片
+        if (billboard && billboard.length != 0) {
+          billboard.forEach((item) => {
+            this.addBillBoardByGltfFloor(element, item);
+          });
+        }
+
+        // 添加当前模型需要点击的子元素名称
+        if (clickChilrenNameArray && clickChilrenNameArray.length != 0) {
+          clickChilrenNameArray.forEach((item) => {
+            var ins = Gaea.MeshInstance.ConvertBy(
+              element.GetMeshInstanceByName(item)
+            );
+
+            Gaea.QueryServer.Instance.AddHitMeshInstance(element, ins);
+          });
+        }
+
+        element.OnHitElement((childName, pos) => {
+          clickCallBack(childName, pos);
+        });
+
+        element.OnHitChildElement((childName, pos) => {
+          console.log(childName);
+          clickChilrenCallBack(childName);
+        });
+
+        if (childBillboard && childBillboard.length) {
+          let childBillboardList = [];
+          childBillboard.forEach(async (item) => {
+            childBillboardList.push(await this.test(element, item));
+          });
+
+          element.ChildrenBillboardArr = childBillboardList;
+        }
+        // 模型是否展示
+        element.Root.Visible = show;
+        await res(element);
+      });
+
+      Gaea.World.Instance.RenderableObjectList.AddLast(element);
+
+      setTimeout(() => {
+        res(element);
+      }, 20 * 1000);
+    });
+  };
+  /**
+   * 本地资源加载（tscn）
+   * @param {string} resourcePath - 资源路径，如 "res://assets/gltf/box.tscn"
+   * @param {Gaea.Vector3} position - 模型位置的经纬度和高度，格式为 Vector3(lat, lon, height)
+   * @param {Gaea.Vector3} scale - 模型缩放比例，格式为 Vector3(x, y, z)
+   * @param {string} [name] - 模型名称（可选）
+   * @returns {Promise<void>} - 无返回值
+   * @example
+   * // 加载一个 box 模型到指定位置
+   * const position = new Gaea.Vector3(27.200503, 120.465629, 25.6);
+   * const scale = new Gaea.Vector3(1, 1, 1);
+   * await AddLocalResource("res://assets/gltf/box.tscn", position, scale, "MyBox");
+   */
+  AddLocalResource = async (resourcePath, position, scale, name) => {
+    const scene = Gaea.GaeaResourceLoader.Instance.LoadLoaclResource(resourcePath)
+    const node = Gaea.PackedScene.ConvertBy(scene)
+    var inst = Gaea.Spatial.ConvertBy(node.Instance(0));
+    var pos = new Gaea.Vector3(position.x, position.y, position.z); // 模型位置
+    var spacepos2 = Gaea.GaeaMath.SphericalToCartesianDeg(pos);
+    var deg = Gaea.GaeaMath.SphericalToGlobeRoationYZX(pos);
+    inst.Translate(spacepos2);
+    // inst.Rotation = Gaea.GaeaMath.RotationFromCartesianToSpherical(x, y).GetEuler();
+    inst.Scale = new Gaea.Vector3(scale[0], scale[1], scale[2]);
+    inst.RotationDegrees = deg;
+    console.log(spacepos2, resourcePath, name, 'namename');
+    console.log(deg);
+    console.log(scale);
+    // inst.Name = iconUrl;
+    Gaea.World.Instance.AddChild(inst, false);
+  }
+
+  /**
+   * 修改tscn模型参数
+   * @param {string} name - 节点名称
+   * @param {number} rotateX - X轴旋转角度（度数）
+   * @param {number} rotateY - Y轴旋转角度（度数）
+   * @param {number} rotateZ - Z轴旋转角度（度数）
+   * @param {number} translateX - X轴位移
+   * @param {number} translateY - Y轴位移
+   * @param {number} translateZ - Z轴位移
+   */
+  updateTSCNPamars = ({ name, rotateX = 0, rotateY = 0, rotateZ = 0, translateX = 0, translateY = 0, translateZ = 0 }) => {
+    const node = Gaea.World.Instance.GetNode(name);
+    console.log(node, 'node');
+    var inst = Gaea.MeshInstance.ConvertBy(node);
+
+    // 转换角度为弧度
+    const radX = rotateX / 180 * 3.14;
+    const radY = rotateY / 180 * 3.14;
+    const radZ = rotateZ / 180 * 3.14;
+
+    // 应用旋转（按XYZ顺序）
+    if (rotateX !== 0) inst.RotateObjectLocal(new Gaea.Vector3(1, 0, 0), radX);
+    if (rotateY !== 0) inst.RotateObjectLocal(new Gaea.Vector3(0, 1, 0), radY);
+    if (rotateZ !== 0) inst.RotateObjectLocal(new Gaea.Vector3(0, 0, 1), radZ);
+
+    // 应用位移
+    if (translateX !== 0 || translateY !== 0 || translateZ !== 0) {
+      inst.TranslateObjectLocal(new Gaea.Vector3(translateX, translateY, translateZ));
+    }
+
+    console.log(inst);
+    return inst;
+  }
+
+  /**
+   * 修改模型配置
+   * @param {*} element 模型
+   * @param {*} position 坐标
+   * @param {*} rotate 旋转
+   * @param {*} size 大小
+   */
+  updateElementPosition = ({ element, position, rotate, size }) => {
+    element.GeographyPosition = new Gaea.Vector3(
+      position.x,
+      position.y,
+      position.z
+    );
+
+    if (rotate?.length > 0) {
+      element.TiltHeadingBank = new Gaea.Vector3(
+        rotate[0],
+        rotate[1],
+        rotate[2]
+      );
+    }
+
+    // element.Root.Scale = new Gaea.Vector3(size[0], size[1], size[2]);
+  };
+
+  /**
+ * 修改标记配置
+ * @param {*} element 模型
+ * @param {*} position 坐标
+ */
+  updateScreenPosition = ({ element, position }) => {
+    element.GeographyPosition = new Gaea.Vector3(position.x, position.y, position.z);
+
+  };
+
+  /**
+   * @description: 缓动动画
+   * @param {Object} element  模型或者面片
+   * @param {Object} Scale  需要变化的大小
+   * @param {Object} Position  需要变化的位置
+   * @param {Object} translation 模型相对位置的变化
+   * @param {number} time  需要变化的时间
+   * @param {Object} Door  开门关门
+   * @param {Object} floor  门的层级
+   */
+  Tweentest = (
+    element,
+    Scale = {},
+    Position = {},
+    translation = {},
+    time,
+    Door = {},
+    floor = 0
+  ) => {
+    if (Object.values(Scale).length) {
+      const scale = {
+        x: element.Scale.x,
+        y: element.Scale.y,
+        z: element.Scale.z,
+      };
+      const tweenScale = new Tween(scale)
+        .to(Scale, time)
+        .easing(Easing.Quadratic.InOut) // 改用直接导入的 Easing
+        .onUpdate(() => {
+          element.Scale = new Gaea.Vector3(scale.x, scale.y, scale.z);
+        })
+        .start()
+        .onStart(() => {
+          if (Scale.x !== 0.1) {
+            element.Visible = true;
+          }
+        })
+        .onComplete(() => {
+          if (Scale.x === 0.1) {
+            element.Visible = false;
+          }
+          this.tweenGroup.remove(tweenScale);
+        });
+      this.tweenGroup.add(tweenScale);
+    }
+
+    if (Object.values(Position).length) {
+      const GeographyPosition = {
+        x: element.GeographyPosition.x,
+        y: element.GeographyPosition.y,
+        z: element.GeographyPosition.z,
+      };
+      const tweenPosition = new Tween(GeographyPosition)
+        .to(Position, time)
+        .easing(Easing.Quadratic.InOut) // 改用 Easing
+        .onUpdate(() => {
+          element.GeographyPosition = new Gaea.Vector3(
+            GeographyPosition.x,
+            GeographyPosition.y,
+            GeographyPosition.z
+          );
+        })
+        .start()
+        .onComplete(() => {
+          this.tweenGroup.remove(tweenPosition);
+        });
+      this.tweenGroup.add(tweenPosition);
+    }
+
+    if (Object.values(Door).length) {
+      const doorMesh = element.Root.GetChild(floor),
+        meshInstance = new Gaea.MeshInstance();
+      meshInstance.InstanceID = doorMesh.InstanceID;
+      const DoorAngle = {
+        x: meshInstance.RotationDegrees.x,
+        y: meshInstance.RotationDegrees.y,
+        z: meshInstance.RotationDegrees.z,
+      };
+
+      const tweenDoor = new Tween(DoorAngle)
+        .to(Door, time)
+        .easing(Easing.Quadratic.InOut) // 改用 Easing
+        .onUpdate(() => {
+          meshInstance.RotationDegrees = new Gaea.Vector3(
+            DoorAngle.x,
+            DoorAngle.y,
+            DoorAngle.z
+          );
+        })
+        .start()
+        .onComplete(() => {
+          this.tweenGroup.remove(tweenDoor);
+        });
+      this.tweenGroup.add(tweenDoor);
+    }
+
+    if (Object.values(translation).length) {
+      let Translation;
+      if (element.Root) {
+        Translation = {
+          x: element.Root.Translation.x,
+          y: element.Root.Translation.y,
+          z: element.Root.Translation.z,
+        };
+      } else {
+        Translation = {
+          x: element.Translation.x,
+          y: element.Translation.y,
+          z: element.Translation.z,
+        };
+      }
+
+      const tweenTranslation = new Tween(Translation)
+        .to(translation, time)
+        .easing(Easing.Quadratic.InOut) // 改用 Easing
+        .onUpdate(() => {
+          if (element.Root) {
+            element.Root.Translation = new Gaea.Vector3(
+              Translation.x,
+              Translation.y,
+              Translation.z
+            );
+          } else {
+            element.Translation = new Gaea.Vector3(
+              Translation.x,
+              Translation.y,
+              Translation.z
+            );
+          }
+        })
+        .start()
+        .onComplete(() => {
+          this.tweenGroup.remove(tweenTranslation);
+        });
+      this.tweenGroup.add(tweenTranslation);
+    }
+  };
+
+  //创建vt3对象
+  createGaeaVt3 = ({ x, y, z }) => {
+    return new Gaea.Vector3(x, y, z);
+  };
+  //移除模型
+  removeGltf = (gltfElement) => {
+    Gaea.World.Instance.RenderableObjectList.Remove(gltfElement);
+  };
+  //添加可点击的点
+  addFeaturePoint = async (featureObj, callback = () => { }) => {
+    const {
+      pointData,
+      iconUrl,
+      fieldText,
+      HeightOffset,
+      VisibleRange,
+      onClick,
+    } = featureObj;
+    if (iconUrl) {
+      let name = getFlieName(iconUrl);
+      await LoadResourceAsync(iconUrl);
+      var id = Gaea.GaeaResourceLoader.Instance.GetResource(name);
+      var tex = new Gaea.Texture(false);
+      tex.InstanceID = id + "";
+    }
+    var pos = pointData["geometry"]["coordinates"];
+    console.log(pointData);
+    var Position = new Gaea.Vector3(pos[1], pos[0], 0);
+    var posArray = [Position];
+    var geometry = Gaea.Geometry.Create1(Gaea.GeometryType.Point, posArray);
+    var Element = new Gaea.PointGeometryElement();
+    var IconMarkSymbol = new Gaea.IconMarkSymbol();
+    IconMarkSymbol.MarkSize = 40;
+    IconMarkSymbol.Icon = tex;
+    var TextSymbol = new Gaea.TextMarkSymbol();
+    TextSymbol.MarkSize = 22;
+    TextSymbol.Field = fieldText;
+    TextSymbol.Anchor = Gaea.AnchorType.Down;
+
+    var CompositeSymbol = new Gaea.CompositeSymbol();
+    CompositeSymbol.AddSymbol(TextSymbol);
+    CompositeSymbol.AddSymbol(IconMarkSymbol);
+
+    Element.Symbol = CompositeSymbol;
+    Element.Shape = geometry;
+
+    var fields = new Gaea.Fields();
+    var field = new Gaea.Field();
+    field.Name = fieldText;
+    fields.AddField(field);
+    Element.Feature.SetFields(fields);
+    var value = pointData["properties"][fieldText];
+    Element.Feature.SetStringValue(fieldText, value);
+    if (VisibleRange) {
+      Element.VisibleRange = new Gaea.Vector2(VisibleRange[0], VisibleRange[1]);
+    }
+    Element.EnableEdit = false; //不允许编辑
+    Element.EnablePick = true; //不允许点击
+    Element.NeedIntersectWithMesh = false;
+    Element.SelectedCallBack((ro, ins, selected, pos, startId, surfaceid) => {
+      if (selected) {
+        onClick(pointData.properties);
+      }
+    });
+    Gaea.World.Instance.RenderableObjectList.AddLast(Element);
+    callback(Element);
+  };
+
+  /**
+   *  加载水面
+   */
+  async addWaterHandle({ gltfUrl, Position }) {
+    var water_mtl = Gaea.GaeaResourceLoader.Instance.LoadLoaclResource("res://assets/material/river2.tres")
+    var material = Gaea.ShaderMaterial.ConvertBy(water_mtl)
+
+    var element = new Gaea.GLTFElement();
+    //模型名称
+    element.ResourceName = gltfUrl;
+    var elv = Gaea.World.Instance.DefaultTerrainAccessor.GetElevationByCurrentViewRangeAt(Position.x, Position.y); //根据经纬度获取高程
+    var pos = new Gaea.Vector3(Position.x, Position.y, Position.z); //模型位置
+    console.log(Gaea.GaeaMath.SphericalToCartesianDeg(pos), 'Gaea.GaeaMath.SphericalToCartesianDeg1(pos);');
+
+    element.GeographyPosition = pos;
+    element.OnModelInit(() => {
+      var n = element.GetChildCount();
+      for (var i = 0; i < n; i++) {
+        var meshinstance = Gaea.MeshInstance.ConvertBy(element.Root.GetChild(i))
+        var count = meshinstance.Mesh.GetSurfaceCount();
+        for (var j = 0; j < count; j++) {
+          meshinstance.Mesh.SurfaceSetMaterial(j, material)
+        }
+      }
+      element.Scale = new Gaea.Vector3(0.05, 0.05, 0.05);  //模型放大
+
+      Gaea.World.Instance.SetMtlVector3(material, "uv_scale", new Gaea.Vector3(-0.3, -0.3, 1));
+      Gaea.World.Instance.SetMtlFloat(material, "flow_speed", 0.4);
+      // Gaea.World.Instance.SetMtlColor(material, "color_shallow", new Gaea.Color(127 / 255, 111 / 255, 75 / 255, 1));
+      // Gaea.World.Instance.SetMtlColor(material, "color_deep", new Gaea.Color(127 / 255, 111 / 255, 75 / 255, 1)); 
+      // Gaea.World.Instance.SetMtlFloat(material, "normal_scale", 0);
+      // Gaea.World.Instance.SetMtlFloat(material, "roughness", 0);
+      Gaea.World.Instance.SetMtlFloat(material, "transparency_clarity", 0);
+    });
+    Gaea.World.Instance.RenderableObjectList.AddLast(element);
+
+    // return riverData;
+  }
+  //坐标转换
+  GaeaMath = (x, y, z) => {
+    var space = Gaea.GaeaMath.SphericalToCartesianDeg1(
+      x,
+      y,
+      Gaea.World.Instance.WorldRadius + 20 + z
+    ); //设置xyz
+    return space;
+  };
+  //添加3dtils
+  add3dtils = (tilesObj) => {
+    let { tilName, jsonUrl, height } = tilesObj;
+    const tdtile = new Gaea.Gaea3DTileset();
+    tdtile.IsZUp = true;
+    if (height) {
+      tdtile.LocalOffset = new Gaea.Vector3(0, height, 0);
+    }
+    tdtile.InitTileSet(tilName, jsonUrl);
+    // tdtile.CameraWidthRatio = 0
+    // tdtile.UseLight = false;
+    tdtile.UseLight = false;
+    tdtile.RecalculateNormals = false;
+    // 是否计算法线
+    tdtile.RecalculateNormals = true;
+    // 是否开启光照
+    tdtile.UseLight = false;
+    // // tdtile.Layers = 3
+    // // else
+    // // tdtile.UseLight = true
+    // // // tdtile.CameraWidthRatio = 1.3
+    // // // tdtile.CameraWidthRatio = window.configData.pipeViewValue
+    // // tdtile.CameraWidthRatio = 1
+    // // tdtile.AutoCutTileChildrenMode = true
+    // // tdtile.AutoCutTileChildrenPerLength = 1000
+    // // tdtile.ShowWithClipBox = false
+
+    // // tdtile.CameraWidthRatio = 1.3
+    // // tdtile.EnablePick = false
+    // // Gaea.QueryServer.Instance.Enable = true
+    // 开启裁剪
+    // tdtile.EnablePick = true;
+    Gaea.World.Instance.RenderableObjectList.AddLast(tdtile);
+    //倾斜跳层关闭
+    tdtile.SkipLevelOfDetail = false;
+    console.log(`倾斜${tilName}加载成功`);
+    return tdtile;
+  };
+  //移除3dtils
+  remove3dtils = ({ tilName, tilData }) => {
+    // tilData.Delete();
+    Gaea.World.Instance.RenderableObjectList.Remove(tilData);
+    console.log("tilData" + tilData);
+    console.log(`倾斜${tilName}移除成功`);
+  };
+  //加载默认资源
+  InitFontTexture = (params) => {
+    return new Promise((res, rej) => {
+      var over = Gaea.TextTextureManager.Instance.OnInitFontTexture((ok) => {
+        if (ok) {
+          res();
+        } else {
+          rej();
+        }
+        Gaea.TextTextureManager.Instance.ClearEvent(over);
+      });
+      Gaea.TextTextureManager.Instance.InitFontTexture();
+    });
+  };
+
+  //添加流动的线
+  addFlowLine = async (flowLineObj, callback = () => { }) => {
+    const {
+      iconUrl,
+      lineData,
+      LineWidth,
+      EeightOffset,
+      EnablePick = false,
+      LineColor = [1, 0, 0, 1],
+      EnableEdit = false,
+    } = flowLineObj;
+    const flieName = getFlieName(iconUrl);
+    const ok = await this.LoadResourceFromUrl(iconUrl, flieName);
+    if (!ok) return console.error("图标加载失败");
+    const id = Gaea.GaeaResourceLoader.Instance.GetResource(flieName);
+    const tex = new Gaea.Texture(false);
+    tex.InstanceID = id + "";
+    tex.Flags = 0;
+    const line = lineData.map((item) => {
+      return new Gaea.Vector3(item[0], item[1], 30);
+    });
+    const geomety = Gaea.Geometry.Create1(Gaea.GeometryType.Polyline, line);
+    const lineElement = new Gaea.LineGeometryElement();
+
+    const lineSymbol = new Gaea.LineSymbol();
+    lineSymbol.LineColor = new Gaea.Color(
+      LineColor[0],
+      LineColor[1],
+      LineColor[2],
+      LineColor[3]
+    );
+    //流动速度
+    lineSymbol.FlowVelocity = 0.5;
+    //箭头个数
+    lineSymbol.RepeatTimes = 100;
+    lineSymbol.LineWidth = 15;
+    lineSymbol.HeightOffset = 0;
+    lineSymbol.IsFlowing = true;
+    //深度检测
+    lineSymbol.DepthTestEnable = false;
+    lineSymbol.LineTexture = tex;
+    lineSymbol.EmissionPower = 1.0;
+
+    lineElement.NeedIntersectWithMesh = false;
+    lineElement.Symbol = lineSymbol;
+    lineElement.Shape = geomety;
+    lineElement.EnableEdit = false;
+    lineElement.EnablePick = false;
+    lineElement.VisibleRange = new Gaea.Vector2(0, 100000);
+    Gaea.World.Instance.RenderableObjectList.AddLast(lineElement);
+    callback(lineElement);
+  };
+  removeFlowLine = (lineElement) => {
+    Gaea.World.Instance.RenderableObjectList.Remove(lineElement);
+  };
+  //画要素线
+  addFeatureLine = (featureObj, callback = () => { }, onClick = () => { }) => {
+    const {
+      lineData,
+      EnablePick,
+      EnableEdit,
+      NeedIntersectWithMesh,
+      LineWidth,
+      IsFlowing,
+      LineStyle,
+      Priority,
+      HeightOffset,
+      InitialLineColor,
+      SelectedLineColor,
+      VisibleMinHeight,
+      VisibleMaxHeight,
+    } = featureObj;
+    //线数据
+    const lineList = [];
+
+    for (let index = 0; index < lineData.length; index++) {
+      const element = lineData[index];
+      let p = null;
+      if (HeightOffset) {
+        p = new Gaea.Vector3(
+          element[1],
+          element[0],
+          Gaea.World.Instance.WorldRadius + HeightOffset
+        );
+      } else {
+        let height = Gaea.World.Instance.DefaultTerrainAccessor.GetElevationAt(
+          element[1],
+          element[0],
+          20
+        );
+        p = new Gaea.Vector3(
+          element[1],
+          element[0],
+          Gaea.World.Instance.WorldRadius + height
+        );
+      }
+      lineList.push(p);
+    }
+
+    var Space = lineList; // 构成线的数据，数据形式为经纬度加地形高度
+    var geometry = Gaea.Geometry.Create1(Gaea.GeometryType.Polyline, Space); // 创建 GeometryLine 对象
+    var Element = new Gaea.LineGeometryElement(); // 创建 LineGeometryElement 对象
+    Element.Shape = geometry; // 赋值，该赋值操作需要最先被执行
+    // Element.EnablePick = true;
+    Element.EnablePick = EnablePick ? EnablePick : false; // 允许点击
+    Element.EnableEdit = EnableEdit ? EnableEdit : false; // 允许编辑
+    Element.NeedIntersectWithMesh = NeedIntersectWithMesh
+      ? NeedIntersectWithMesh
+      : false; // 允许在3Dtiles、管线、挖方等位置编辑
+    Element.InitialLineColor = InitialLineColor
+      ? parseColorString(InitialLineColor)
+      : parseColorString("rgba(255,0,0,1)");
+    // //************ 样式设置 ***************//
+    var OUL = Gaea.LineSymbol.ConvertBy(Element.Symbol); // 线的样式设置
+    OUL.LineWidth = LineWidth ? LineWidth : 1; // 线宽
+    OUL.IsFlowing = IsFlowing ? IsFlowing : false; // 是否流动
+    OUL.LineStyle = LineStyle ? LineStyle : 0; // 实线，这里有两种形式，0实线和1虚线
+    OUL.Priority = Priority ? Priority : 3; // 线的优先级
+    OUL.EmissionPower = 100;
+    Element.SelectedCallBack((a, b, c, d, e, f) => {
+      // debugger
+      if (c) {
+        //获取选中element
+        const selectelement = new Gaea.LineGeometryElement(false);
+        selectelement.InstanceID = a + "";
+        console.log(123);
+        const lineData = selectelement.GetLineData();
+        onClick(lineData);
+      }
+    });
+    // Element.InitialLineColor = parseColorString(InitialLineColor) || parseColorString('Red'); // 初始线的颜色以及透明度
+    // Element.SelectedLineColor = parseColorString(SelectedLineColor) || parseColorString('Green'); // 选中线后的颜色以及透明度
+    Element.Visible = true;
+    // Element.VisibleRange = new Gaea.Vector2(VisibleMinHeight || 0, VisibleMaxHeight || 99999999); // 可视范围
+    Gaea.World.Instance.RenderableObjectList.AddLast(Element); // 加入到场景
+    callback(Element);
+  };
+  //移除线
+  removeFeatureLine = (lineElement) => {
+    Gaea.World.Instance.RenderableObjectList.Remove(lineElement);
+  };
+  //读取geojson绘制线
+  addGeoJsonFetureLine = async (url, lineStyle = {}, callback = () => { }) => {
+    const { StartColor, EndColor, HeightOffset, LineWidth } = lineStyle;
+    var Symbol = new Gaea.LineSymbol(); //创建线符号
+    Symbol.LineWidth = LineWidth ? LineWidth : 1.5; //设置宽度
+    Symbol.HeightOffset = 100; //设置高度偏移
+    Symbol.EmissionPower = 100;
+    // var geojsonFile = "等值线.geojson"; //设置保存时的文件名,要带拓展名
+    let geojsonFile = getFlieName(url);
+    var res = "user://resources/"; //设置保存目录
+    await this.LoadResourceFromUrl(url, geojsonFile);
+    var ws = Gaea.WorkspaceFactory.OpenFromFile(res + geojsonFile);
+    var fclass = ws.OpenFeatureClass(true, false); //读取文件，构建FeatureClass
+    var flayer = new Gaea.FeatureLayer(); //创建一个FeatureLayer图层
+    var FeatureRenderer = new Gaea.GradedRenderer(); //创建一个渲染器
+    FeatureRenderer.GradedField = "OBJECTID";
+    // FeatureRenderer.StartColor = new Gaea.Color(1, 0, 0, 1);
+    FeatureRenderer.StartColor = StartColor
+      ? parseColorString(StartColor)
+      : parseColorString("rgba(255,0,0,1)");
+    // FeatureRenderer.EndColor = new Gaea.Color(1, 0, 0, 1);
+    FeatureRenderer.EndColor = EndColor
+      ? parseColorString(EndColor)
+      : parseColorString("rgba(255,0,0,1)");
+    FeatureRenderer.GradedNumber = 5;
+    FeatureRenderer.Symbol = Symbol; //设置渲染器的符号
+    // flayer.VisibleRange = new Gaea.Vector2(0, 1000000); //设置可见高度范围
+    flayer.FeatureClass = fclass; //设置图层中的数据，即fclass
+    flayer.FeatureRenderer = FeatureRenderer; //设置图层中的渲染器， 即FeatureRenderer
+    Gaea.World.Instance.RenderableObjectList.AddLast(flayer); //将图层添加到可渲染对象列表
+    callback(flayer);
+  };
+  //读取geojson线数据
+  addSymbolLine = async () => {
+    const Symbol = new Gaea.LineSymbol();
+    Symbol.LineWidth = 1.5; //设置宽度
+    Symbol.LineColor = new Gaea.Color(1, 0, 0, 0.5);
+    Symbol.HeightOffset = 110;
+    Symbol.EmissionPower = 100;
+    const geojsonFile = "保护范围线.geojson";
+    const res = "user://resources/";
+    Gaea.GaeaResourceLoader.Instance.LoadResourceFromUrl1(
+      "http://localhost:9878/geojson/保护范围线.geojson",
+      geojsonFile,
+      (code, msg) => {
+        const ws = Gaea.WorkspaceFactory.OpenFromFile(res + geojsonFile);
+        const fclass = ws.OpenFeatureClass(true, false);
+        const flayer = new Gaea.FeatureLayer();
+        const featureRenderer = new Gaea.SimpleFeatureRenderer();
+        featureRenderer.Symbol = Symbol;
+        flayer.VisibleRange = new Gaea.Vector2(0, 10000000);
+        flayer.FeatureClass = fclass;
+        flayer.FeatureRenderer = featureRenderer;
+        Gaea.World.Instance.RenderableObjectList.AddLast(flayer);
+      }
+    );
+  };
+
+  /**
+   * @description: 屏幕标记
+   * @param {String} name  标记名称
+   * @param {Boolean} show  标记是否可见
+   * @param {String} url  标记背景图
+   * @param {Object} position  标记位置
+   * @param {Array} size  标记大小[宽,高]
+   * @param {Array} offset  标记偏移[左,上]
+   * @param {Array} text  标记内容文本
+   * @param {Number} anchorType  点方位(详情见index.js => AnchorType)
+   * @param {Array} visibleRange  标记可见范围[min,max]
+   * @param {Boolean} DrawLine  是否带线
+   * @param {Boolean} EnablePick  是否点击
+   * @param {Function} clickCallBack  标记点击方法
+   */
+  addScreenIcon = async ({
+    name,
+    show = true,
+    url = "",
+    position,
+    size = [100, 50],
+    offset = [0, 0],
+    text = [],
+    anchorType = Gaea.AnchorType.LeftDown,
+    visibleRange = [10, 50000],
+    CameraAltitudeRange = [],
+    DrawLine = false,
+    LineStyle = {
+      lineWidth: 3,
+      lineColor: [255, 76, 76],
+      pointWidth: 3,
+      pointColor: [255, 76, 76],
+
+    },
+    EnablePick = true,
+    divId = "",
+    clickCallBack = () => { },
+    elementName = "",
+    elementChildrenIndex = 0
+  }) => {
+    if (url) {
+      await this.LoadResourceFromUrl(`${serveLocal}/icon/labelImg/${url}`, url);
+    }
+    const screen = new Gaea.ScreenGUIElement();
+    screen.Name = name;
+    screen.Visible = show;
+    screen.UseAutoVisible();
+    if (divId) {
+      screen.DivID = divId;
+      const dom = document.getElementById(screen.DivID);
+      const root = new Gaea.Control();
+      root.MouseFilter = 2;
+      root.RectSize = new Gaea.Vector2(dom.clientWidth, dom.clientHeight);
+      screen.Root = root;
+    } else {
+      screen.Root = this.InitUI(text, size, url);
+    }
+
+    // 标签默认位置为左上角
+    if (offset.length) {
+      screen.ScreenOffset = new Gaea.Vector2(offset[0], offset[1]); // 偏移位置
+    }
+
+    screen.ConnectAnchor = anchorType; // 点方位
+    // 是否点击
+    screen.EnablePick = true;
+    screen.LineWidth = screen.AnchorPointSize = LineStyle.lineWidth; // 线条和圆点粗细
+    screen.LineColor = new Gaea.Color(LineStyle.lineColor[0] / 255, LineStyle.lineColor[1] / 255, LineStyle.lineColor[2] / 255, 1); // 线条颜色
+    screen.AnchorPointColor = new Gaea.Color(LineStyle.pointColor[0] / 255, LineStyle.pointColor[1] / 255, LineStyle.pointColor[2] / 255, 1); // 圆点颜色
+    // 是否带线
+    screen.DrawLine = DrawLine;
+
+    // 可见范围
+    if (visibleRange.length) {
+      screen.VisibleRange = new Gaea.Vector2(visibleRange[0], visibleRange[1]);
+    }
+
+    // 可见范围
+    if (CameraAltitudeRange.length) {
+      screen.CameraAltitudeRange = new Gaea.Vector2(CameraAltitudeRange[0], CameraAltitudeRange[1]);
+    }
+
+    screen.OnHitElement = () => {
+      clickCallBack();
+    };
+
+    // 标签的地理坐标
+    if (!elementName) {
+      screen.GeographyPosition = new Gaea.Vector3(
+        position.x,
+        position.y,
+        position.z
+      );
+      Gaea.World.Instance.RenderableObjectList.AddLast(screen);
+    } else {
+      let elementObj;
+      const { element } = gltfList.value.find(
+        (item) => item.name === elementName
+      );
+      elementObj = element.Root.GetChild(elementChildrenIndex);
+      elementObj.AddChild(screen, false);
+    }
+    return screen;
+  };
+
+  clearScreen = (screen) => {
+    Gaea.World.Instance.RenderableObjectList.Remove(screen);
+  }
+
+  /**
+   * 通过URL加载资源,并存储为Name
+   * @param {string} url
+   * @param {string} name
+   * @returns {number} 资源ID
+   */
+  LoadResourceFromUrl = (url, name) => {
+    return new Promise((res, rej) => {
+      Gaea.GaeaResourceLoader.Instance.LoadResourceFromUrl1(
+        url,
+        name,
+        (code, msg) => {
+          if (code == 200) {
+            res(true);
+          } else {
+            console.log(msg);
+            rej(false);
+          }
+        }
+      );
+      // var rfid = Gaea.GaeaResourceLoader.Instance.OnLoadResourceFromUrl((code, id) => {
+      //     if (code == 200) {
+      //         res(id)
+      //     } else {
+      //         rej(id)
+      //     }
+      //     Gaea.GaeaResourceLoader.Instance.ClearEvent(rfid)
+      // })
+      // console.log("资源保存成功!");
+    });
+  };
+
+  /***
+   * 添加图片标注
+   * @param {String} image bs64图片地址||图片路径
+   * @param {Array} extent 图片的位置
+   * @return {Number} 图片的id
+   */
+  addImage = async ({ terrainList, extent }) => {
+    Gaea.DecalManager.Instance.PixelToHeightMode =
+      Gaea.PixelToHeightModeEnum.Proportion;
+    Gaea.World.Instance.VerticalExaggeration = 1;
+
+    const terrainName = `${uuid()}地形图.png`;
+    await this.LoadResourceFromUrl(terrainList[0], terrainName);
+    var item = new Gaea.DecalItem();
+    item.ChangeRange(extent[0], extent[1], extent[2], extent[3]);
+
+    item.BaseMapType = 1;
+
+    item.BaseMapPath = `user://resources/${terrainName}`;
+
+    Gaea.DecalManager.Instance.AddItem(item);
+
+    this.dxyb_Arr.push(item);
+  };
+
+  /**
+   * @description: 地形演变
+   * @param {Array<String>} terrainArr  地形图
+   * @param {Number} time 演变速度
+   * @param {Number} verticalExaggeration 夸张倍数
+   */
+  addImageYb = async ({
+    terrainList,
+    extent,
+    verticalExaggeration = 1,
+    minMax,
+    baseMapType,
+  }) => {
+    let item = new Gaea.DecalItem();
+    let item2 = new Gaea.DecalItem();
+    for (var i = 0; i < terrainList.length; i++) {
+      const arr = terrainList[i].split("/");
+      var name = arr[arr.length - 1];
+      await this.LoadResourceFromUrl(terrainList[i], name);
+    }
+    await this.LoadResourceFromUrl(`${serveLocal}/image/色带.png`, `色带.png`);
+    Gaea.DecalManager.Instance.PixelToHeightMode =
+      Gaea.PixelToHeightModeEnum.Absolute;
+    Gaea.DecalManager.Instance.TerrainMapInterpolationValue = 1;
+    Gaea.World.Instance.VerticalExaggeration = verticalExaggeration;
+    item.ChangeRange(extent[0], extent[1], extent[2], extent[3]);
+    item.BaseMapPath = "user://resources/色带.png";
+    let itemArr = terrainList[0].split("/");
+    item.TerrainMapPath = `user://resources/${itemArr[itemArr.length - 1]}`;
+    item.TerrainMinMaxValue = new Gaea.Vector2(0, 232);
+    item.TerrainInvalidValue = 0;
+    item.BaseMapType = 2;
+    Gaea.DecalManager.Instance.AddItem(item);
+
+    item2.ChangeRange(extent[0], extent[1], extent[2], extent[3]);
+    let item2Arr = terrainList[1].split("/");
+    item2.TerrainMapPath = `user://resources/${item2Arr[item2Arr.length - 1]}`;
+    item2.TerrainMinMaxValue = new Gaea.Vector2(0.06, 47);
+    item2.TerrainInvalidValue = 0;
+    item2.BaseMapType = 2;
+    Gaea.DecalManager.Instance.AddItem(item2);
+    // this.changeHeight(0, item, item2, terrainList);
+
+    this.dxyb_Arr.push(item, item2);
+
+    return this.dxyb_Arr;
+  };
+  terrainInterpolationValueChange = (value) => {
+    Gaea.DecalManager.Instance.TerrainMapInterpolationValue = value;
+  };
+  //移除地形演变数据
+  removeTerrainItem = () => {
+    if (this.dxyb_Interval) {
+      clearInterval(this.dxyb_Interval);
+      this.dxyb_Interval = null;
+    }
+
+    this.dxyb_Arr.forEach((element) => {
+      Gaea.DecalManager.Instance.RemoveItem(element);
+    });
+
+    this.dxyb_Arr = [];
+  };
+
+  /**
+   * @description: 视角锁定模式切换
+   * @param {Boolean} mode 锁定模式是否开启
+   * @param {Object} element 需要锁定的模型
+   * @param {Array} Offset3D 从当前点视角看向模型中心点
+   * @return {*}
+   */
+  lockedModesSwitch = (
+    mode,
+    element,
+    Offset3D = [0, 1.1, 0],
+    MinMaxZoom3D = [1.1, 1.1],
+    LockEye = false,
+    GaeaCameraNearFar = [0.1, 1000000000000000],
+  ) => {
+    if (mode) {
+      const ev = new Gaea.EntityView();
+      // const sp = Gaea.Spatial.ConvertBy(element.Root.GetChild(0));
+      ev.Offset3D = new Gaea.Vector3(Offset3D[0], Offset3D[1], Offset3D[2]);
+      ev.LockEye = LockEye;
+      ev.MinMaxZoom3D = new Gaea.Vector2(MinMaxZoom3D[0], MinMaxZoom3D[1]);
+      // ev.GaeaCameraNearFar = new Gaea.Vector2(GaeaCameraNearFar[0], GaeaCameraNearFar[1]);
+      ev.Init(element);
+      if (element) {
+        Gaea.World.Instance.CameraController.LockedEntity = ev;
+      }
+      iconLayerVisible.value = false;
+      return ev
+    } else {
+      Gaea.World.Instance.CameraController.LockedEntity = null;
+      ScreenIconList.value.forEach(item => {
+        if (!item.type) {
+          item.element.UseAutoVisible();
+          item.element.EnablePick = true;
+        }
+      })
+    }
+  };
+
+  // FlyOver = () => {
+  //   return new Promise((res, rej) => {
+  //     Gaea.World.Instance.DefaultCamera.OnFlyOver = () => {
+  //       Gaea.World.Instance.DefaultCamera.OnFlyOver = null;
+  //       res();
+  //     };
+  //   });
+  // };
+
+  FlyOver(callback) {
+    const camera = Gaea.World.Instance.DefaultCamera;
+    camera.OnFlyOverCallBack(() => {
+      console.log("飞行结束");
+      if (callback) {
+        callback();
+      }
+    });
+  }
+
+  /**
+   * @description: gltf模型轨迹动画
+   * @param {Array} trackList 动画轨迹坐标
+   * @param {Object} animationConfig 动画配置
+   * @param {String} animationConfig.animationName 动画名称
+   * @param {String} animationConfig.animationType 动画类型(时间 time & 速度 speed)
+   * @param {Number} animationConfig.animationPlaySpeed 动画时长/动画速度
+   * @param {Boolean} animationConfig.animationLoop 动画循环
+   * @param {Object} element 设置动画的gltf对象
+   * @return {*}
+   */
+  gtlfAnimationPlayer = (trackList, animationConfig, element) => {
+    console.log(animationConfig);
+    // 更新当前模型位置坐标
+    element.GeographyPosition = new Gaea.Vector3(
+      trackList[0].x,
+      trackList[0].y,
+      trackList[0].z
+    );
+    let animationPlayer;
+    // 设置动画参数
+    const { animationName, animationType, animationPlaySpeed, animationLoop } =
+      animationConfig;
+
+    // 创建动画轨迹
+    const line = trackList.map(
+      (item) => new Gaea.Vector3(item.x, item.y, item.z)
+    );
+    let bezierCurve = new Gaea.LineCurve();
+    for (let i = 0; i < line.length; i++) {
+      let control = Gaea.GaeaMath.SphericalToCartesianDeg1(
+        line[i].x,
+        line[i].y,
+        line[i].z
+      );
+      bezierCurve.AddValue(i, control);
+    }
+    // 插值动画配置
+    bezierCurve.Step = 20;
+    bezierCurve.Interpolate(true);
+    bezierCurve.CalculateLengthAfterInterpolation();
+
+    let animation;
+
+    // 动画以速度播放还是时间播放
+    if (animationType === "speed") {
+      animation = bezierCurve.ToAnimationBySpeed(
+        animationName,
+        animationPlaySpeed,
+        element.Scale
+      );
+    } else if (animationType === "time") {
+      animation = bezierCurve.ToAnimationByTime(
+        animationName,
+        true,
+        animationPlaySpeed,
+        element.Scale
+      );
+    }
+
+    // 设置动画是否循环
+    // if (animationLoop) {
+    //   animation.Loop = true;
+    // }
+    // console.log(element.Root.GetPath());
+    animation.TrackSetPath(0, element.GetPath());
+    animationPlayer = new Gaea.AnimationPlayer();
+    animationPlayer.AddAnimation(animationName, animation);
+    element.AddChild(animationPlayer, false);
+
+    // if (true) {
+
+    // } else {
+    //   animationPlayer = Gaea.AnimationPlayer.ConvertBy(element.GetChild(1));
+    // }
+    Gaea.World.Instance.PlayAnimation(animationPlayer, animationName);
+    return animationPlayer;
+  };
+
+  // 模型平移动画
+  gltfPlayer = (element, targetPos, time = 5) => {
+    // 返回一个 Promise 对象
+    return new Promise((resolve, reject) => {
+      // 先做参数校验，避免无效执行
+      if (!element || !element.TranslateObjectLocal) {
+        reject(new Error('无效的元素对象：缺少 TranslateObjectLocal 方法'));
+        return;
+      }
+      if (!targetPos || typeof targetPos.x !== 'number' || typeof targetPos.y !== 'number' || typeof targetPos.z !== 'number') {
+        reject(new Error('无效的目标位置：必须包含数字类型的 x/y/z 属性'));
+        return;
+      }
+
+      const frameRate = 60; // 帧率（可替换为引擎实际帧率，如 Gaea.Engine.frameRate）
+      const totalFrames = time * frameRate; // 总帧数 = 时长 × 帧率
+      let currentFrame = 0;
+
+      // 总相对位移：从 (0,0,0) 到目标位置的总距离（直接等于目标位置）
+      const totalRelativeOffset = { ...targetPos };
+
+      // 记录已累加的总位移（关键：避免相对位移叠加混乱）
+      let currentCumulativeOffset = { x: 0, y: 0, z: 0 };
+
+      try {
+        // 第一步：纯相对位移重置到 (0,0,0)（抵消之前可能的位移）
+        element.TranslateObjectLocal(new Gaea.Vector3(-currentCumulativeOffset.x, -currentCumulativeOffset.y, -currentCumulativeOffset.z));
+        currentCumulativeOffset = { x: 0, y: 0, z: 0 }; // 重置累计记录
+
+        // 每帧固定小步位移（总位移 ÷ 总帧数，匀速核心）
+        const fixedStep = {
+          x: totalRelativeOffset.x / totalFrames,
+          y: totalRelativeOffset.y / totalFrames,
+          z: totalRelativeOffset.z / totalFrames,
+        };
+
+        // 帧循环：逐帧累加相对位移
+        const moveStep = () => {
+          // 动画结束：补差确保精准到达目标
+          if (currentFrame >= totalFrames) {
+            const finalCompensate = {
+              x: totalRelativeOffset.x - currentCumulativeOffset.x,
+              y: totalRelativeOffset.y - currentCumulativeOffset.y,
+              z: totalRelativeOffset.z - currentCumulativeOffset.z,
+            };
+            element.TranslateObjectLocal(new Gaea.Vector3(finalCompensate.x, finalCompensate.y, finalCompensate.z));
+            currentCumulativeOffset = { ...totalRelativeOffset };
+            const result = {
+              success: true,
+              targetPos,
+              actualPos: currentCumulativeOffset,
+              message: `匀速动画完成，已到达目标位置：${JSON.stringify(targetPos)}`
+            };
+            console.log(result.message);
+            // 动画完成，resolve Promise
+            resolve(result);
+            return;
+          }
+
+          // 执行当前帧相对位移（累加小步）
+          element.TranslateObjectLocal(new Gaea.Vector3(fixedStep.x, fixedStep.y, fixedStep.z));
+
+          // 更新累计位移（确保下次计算补差准确）
+          currentCumulativeOffset.x += fixedStep.x;
+          currentCumulativeOffset.y += fixedStep.y;
+          currentCumulativeOffset.z += fixedStep.z;
+
+          currentFrame++;
+          // 继续下一帧（优先用引擎自带帧循环，如 Gaea.Engine.onUpdate(moveStep)）
+          requestAnimationFrame(moveStep);
+        };
+
+        // 启动动画
+        moveStep();
+      } catch (error) {
+        // 捕获执行过程中的异常，reject Promise
+        reject(new Error(`动画执行出错：${error.message}`));
+      }
+    });
+  };
+
+  // 旋转动画
+  FlyAroundPoint = (element, targetAngle, time, callbacks = {}) => {
+    const {
+      onStart = () => { },
+      onUpdate = () => { },
+      onComplete = () => { }
+    } = callbacks;
+
+    if (!targetAngle || !element) {
+      console.warn("参数无效");
+      onComplete(null);
+      return;
+    }
+
+    // 用来记录上一帧角度，计算差值
+    let lastAngle = 0;
+    let currentAngle = 0;
+
+    // TWEEN 动画
+    const tween = new Tween({ angle: 0 })
+      .to({ angle: targetAngle }, time)
+      .easing(Easing.Quadratic.InOut)
+      .onStart(() => {
+        console.log("动画开始");
+        onStart();
+      })
+      .onUpdate((obj) => {
+        // 拿到当前插值角度
+        currentAngle = obj.angle;
+
+        // 只传【差值】，不是传总角度！
+        const delta = currentAngle - lastAngle;
+
+        element.RotateObjectLocal(new Gaea.Vector3(0, 1, 0), delta);
+
+        lastAngle = currentAngle;
+        onUpdate(currentAngle);
+      })
+      .onComplete(() => {
+        console.log("动画完成");
+        onComplete(targetAngle);
+        this.tweenGroup.remove(tween);
+      });
+
+    this.tweenGroup.add(tween);
+    tween.start();
+  };
+
+  /**
+   * 测量工具
+   * @param {string} type 绘制的类型, 支持地表距离,空间距离,高度,面积
+   * @param {boolean} isNeedTilePipe 是否选择3Dtiles,管线,默认为false
+   * @param {boolean} isNeedAutoClearToop 是否切换工具时自动清除element
+   * @param {Gaea.Color} outlinecolor 字体外边框颜色
+   * @param {number} outlinesize 外边框大小
+   * @param {number} size 字体大小
+   * @param {Gaea.Vector2} GUIVisibleRange  gui可见高度范围
+   * @param {function} cb 回调函数
+   */
+  MeasureToolsWithoutVolume = async (
+    type,
+    isNeedTilePipe = false,
+    isNeedAutoClearToop = true,
+    outlinecolor = new Gaea.Color(1, 0, 0, 1),
+    outlinesize = 1,
+    size = 13,
+    GUIVisibleRange = new Gaea.Vector2(0, 350000),
+    cb = () => { }
+  ) => {
+    try {
+      //声明地表距离测量工具
+      console.log("MyMethod:", type);
+      const tool = new types[type]();
+      // 是否可以选中3Dtiles、管线，默认为false
+      tool.NeedIntersectWithMesh = isNeedTilePipe;
+      // 是否在切换工具时自动清除Element，默认为true
+      tool.DeleteElementOnDispose = isNeedAutoClearToop;
+      // 外边框大小
+      tool.MeasureFont.OutlineSize = outlinesize;
+      //字体外边框颜色
+      tool.MeasureFont.OutlineColor = outlinecolor;
+      //字体大小
+      tool.MeasureFont.Size = size;
+      // GUI可见高度范围设置
+      tool.GUIVisibleRange = GUIVisibleRange;
+      Gaea.World.Instance.SetCurrentTool(tool);
+      // 回调函数
+      const items = {
+        tool: tool,
+        isVolume: false,
+      };
+      // debugger
+      cb(items);
+    } catch (error) {
+      console.error("出错了：", error.message);
+    }
+  };
+
+  /**
+   * 清除球工具对象
+   */
+  ClearToolsWithoutVolume = async () => {
+    Gaea.World.Instance.SetCurrentTool(null);
+  };
+
+  /**
+   *
+   * @param {string} type 绘制的类型, 支持地表距离,空间距离,高度,面积
+   * @param {number} height 深度
+   * @param {boolean} isNeedTilePipe 是否选择3Dtiles,管线,默认为false
+   * @param {boolean} isNeedAutoClearToop 是否切换工具时自动清除element
+   * @param {Gaea.Color} outlinecolor 字体外边框颜色
+   * @param {number} outlinesize 外边框大小
+   * @param {number} size 字体大小
+   * @param {Gaea.Vector2} GUIVisibleRange  gui可见高度范围
+   * @param {function} cb 回调函数
+   */
+  MeasureToolsVolume = async (
+    type,
+    height,
+    isNeedTilePipe = false,
+    isNeedAutoClearToop = true,
+    outlinecolor = new Gaea.Color(1, 0, 0, 1),
+    outlinesize = 1,
+    size = 13,
+    GUIVisibleRange = new Gaea.Vector2(0, 350000),
+    cb = () => { }
+  ) => {
+    try {
+      //画面工具
+      const tool = new types[type]();
+      // 是否可以选中3Dtiles、管线，默认为false
+      tool.NeedIntersectWithMesh = isNeedTilePipe;
+      // 是否在切换工具时自动清除Element，默认为true
+      tool.DeleteElementOnDispose = isNeedAutoClearToop;
+      // 外边框大小
+      tool.MeasureFont.OutlineSize = outlinesize;
+      //字体外边框颜色
+      tool.MeasureFont.OutlineColor = outlinecolor;
+      //字体大小
+      tool.MeasureFont.Size = size;
+      // GUI可见高度范围设置
+      tool.GUIVisibleRange = GUIVisibleRange;
+      if (height != null) {
+        tool.holeDepth = height;
+      }
+      //工具挂载在世界节点
+      Gaea.World.Instance.SetCurrentTool(tool);
+      let elements = [];
+      let holeitem = null;
+      tool.OverDrawCallback = () => {
+        holeitem = tool._Holeitem;
+        // CurrentElement = tool.Element;
+        // elements.push(CurrentElement);
+        elements.push(tool.Element);
+        // 回调函数
+        const items = {
+          elements: elements,
+          holeitem: holeitem,
+          isVolume: true,
+        };
+        console.log("Volume OverDrawCallBack:", items);
+        // debugger;
+        cb(items);
+      };
+    } catch (error) {
+      console.error("出错了：", error.message);
+    }
+  };
+
+  /**
+   *
+   * @param {array} eles 元素列表
+   * @param {*} holeitem 空洞
+   */
+  ClearVolume = async (eles, holeitem) => {
+    //清除所有对象
+    Gaea.World.Instance.SetCurrentTool(null);
+    console.log("长度:", eles.length);
+    //清除前端获取到的Element对象
+    eles.forEach((element) => {
+      Gaea.World.Instance.RenderableObjectList.Remove(element);
+    });
+    if (holeitem != null) {
+      Gaea.ExcavationManager.Instance.RemoveItem(holeitem);
+    }
+    Gaea.ExcavationManager.Instance.Clear();
+    if (Gaea.QueryServer.Instance != null) {
+      if (Gaea.QueryServer.Instance.ClipBox.InstanceID != null) {
+        Gaea.QueryServer.Instance.ClipBox.QueueFree();
+        Gaea.QueryServer.Instance.ClipBox = null;
+      }
+    }
+  };
+
+  /**
+   * 测量工具
+   * @param {string} type 绘制的类型, 支持地表距离,空间距离,高度,面积
+   * @param {boolean} isNeedTilePipe 是否选择3Dtiles,管线,默认为false
+   * @param {boolean} isNeedAutoClearToop 是否切换工具时自动清除element
+   * @param {Gaea.Color} outlinecolor 字体外边框颜色
+   * @param {number} outlinesize 外边框大小
+   * @param {number} size 字体大小
+   * @param {Gaea.Vector2} GUIVisibleRange  gui可见高度范围
+   * @param {function} cb 回调函数
+   */
+  MeasureTools = async (
+    type,
+    isVolume = false,
+    height = 13,
+    isNeedTilePipe = false,
+    isNeedAutoClearToop = true,
+    outlinecolor = new Gaea.Color(1, 0, 0, 1),
+    outlinesize = 1,
+    size = 13,
+    GUIVisibleRange = new Gaea.Vector2(0, 350000),
+    cb = () => { }
+  ) => {
+    if (isVolume) {
+      this.MeasureToolsVolume(
+        type,
+        height,
+        isNeedTilePipe,
+        isNeedAutoClearToop,
+        outlinecolor,
+        outlinesize,
+        size,
+        GUIVisibleRange,
+        (items) => {
+          cb(items);
+        }
+      );
+    } else {
+      this.MeasureToolsWithoutVolume(
+        type,
+        isNeedTilePipe,
+        isNeedAutoClearToop,
+        outlinecolor,
+        outlinesize,
+        size,
+        GUIVisibleRange,
+        (items) => {
+          cb(items);
+        }
+      );
+    }
+  };
+  /**
+   *
+   * @param {boolean} isVolume 是否清理体积工具
+   * @param {Gaea.Element} eles  element对象
+   * @param {*} holeitem 空洞对象
+   */
+  ClearMeasure = (isVolume, items = null) => {
+    if (isVolume) {
+      this.ClearVolume(items.elements, items.holeitem);
+    } else {
+      this.ClearToolsWithoutVolume();
+    }
+  };
+  Dig = async (depth = 5, cb = () => { }) => {
+    const tool = new Gaea.DigTool();
+    Gaea.World.Instance.SetCurrentTool(tool);
+    let box = null;
+    let _Holeitem = null;
+    tool.OverDraw = () => {
+      if (box) {
+        Gaea.World.Instance.RemoveChild(box);
+      }
+      if (_Holeitem) {
+        Gaea.ExcavationManager.Instance.RemoveItem(_Holeitem);
+      }
+      var poly = tool.GetPolygon();
+      Gaea.ExcavationManager.Instance.ExposureLength = 0;
+      // 创建挖方对象，参数为（坐标点，地形插值点之间的距离，深度，UV缩放值，是否需要法线材质）
+      _Holeitem = Gaea.ExcavationManager.Instance.CreateItem(
+        poly,
+        100,
+        depth,
+        100,
+        true,
+        true
+      );
+      Gaea.ExcavationManager.Instance.AddItem(_Holeitem);
+      Gaea.ExcavationManager.Instance.NeedFence = true;
+
+      if (Gaea.QueryServer.Instance != null) {
+        var mtl = Gaea.GaeaResourceLoader.Instance.LoadLoaclResource(
+          "res://assets/material/mtl1.material"
+        );
+        var spmtl = Gaea.SpatialMaterial.ConvertBy(mtl);
+        spmtl.FlagsUnshaded = false;
+        spmtl.FlagsDisableAmbientLight = false;
+        Gaea.ExcavationManager.Instance.FenceHeight = 10;
+        box = Gaea.World.Instance.SimplePolygonGenerater(
+          poly,
+          false,
+          false,
+          false,
+          false,
+          Gaea.ExcavationManager.Instance.FenceHeight,
+          0,
+          2,
+          Gaea.ExcavationManager.Instance.FenceHeight
+        );
+        Gaea.World.Instance.AddChild(box, false);
+        Gaea.QueryServer.Instance.ClipBoxMaterial = spmtl;
+        Gaea.QueryServer.Instance.ClipBox = box;
+      }
+      const item = {
+        holeitem: _Holeitem,
+      };
+      cb(item);
+    };
+  };
+  // 清理挖方
+  Clear = async (item) => {
+    if (item.holeitem) {
+      Gaea.ExcavationManager.Instance.RemoveItem(item._Holeitem);
+    }
+    Gaea.ExcavationManager.Instance.Clear();
+    if (Gaea.QueryServer.Instance != null) {
+      if (Gaea.QueryServer.Instance.ClipBox.InstanceID != null) {
+        Gaea.QueryServer.Instance.ClipBox.QueueFree();
+        Gaea.QueryServer.Instance.ClipBox = null;
+      }
+    }
+  };
+  // 添加3dtiles
+  // 用于添加3dtiles
+  Add3Dtiles = async (tilesObj, isClip, callback = () => { }) => {
+    console.log('Add3Dtiles');
+    let {
+      tilsName,
+      jsonUrl,
+      height
+    } = tilesObj;
+    const tdtile = new Gaea.Gaea3DTileset();
+    // 对象名
+    tdtile.Name = tilsName;
+    // 地址
+    tdtile.TilesetUrl = jsonUrl;
+    // 能否点击
+    tdtile.EnablePick = true;
+    tdtile.UseLight = false;
+    tdtile.SkipLevelOfDetail = false;
+    // NOTE: 告诉球 模型是不是Z朝上的。 让系统知道怎么去加载才能让你的模型是垂直于地表的
+    tdtile.IsZUp = true;
+    tdtile.BaseUrl = jsonUrl.slice(0, jsonUrl.lastIndexOf("/") + 1);
+    //初始化
+    tdtile.InitTileSet(tilsName, jsonUrl);
+    tdtile.EnabledClip = isClip;
+    tdtile.MaximumMemoryUsage = 512;
+    tdtile.MaximumScreenSpaceError = 16;
+    //高度偏移，Vector3的x,y,z表示在三个方向的偏移值
+    // NOTE: LocalOffset的x，y，z的轴向是由加载的模型自己决定朝向的
+    tdtile.LocalOffset = new Gaea.Vector3(0, 0, 0);
+    // tdtile.LocalOffset = new Gaea.Vector3(0, -5, 0);
+    //添加到世界节点
+    Gaea.World.Instance.RenderableObjectList.AddLast(tdtile);
+    callback(tdtile);
+    console.log(`倾斜${tilsName}加载成功`);
+  };
+
+
+  /**
+   *画面方法(有高度，不贴地)
+   *
+   * @param {*} pointList 坐标数组
+   * @param {*} EnablePick 是否点击
+   * @param {*} EnableEdit 是否编辑
+   * @param {*} NeedIntersectWithMesh 允许在3Dtiles、管线、挖方等位置编辑
+   * @param {*} InitialFillColor 画面的颜色
+   * @param {*} HasOutLine 是否存在边线
+   * @param {*} PolygonLineColor 边线的颜色
+   * @memberof App
+   */
+  drawPolygon(pointList, EnablePick, EnableEdit, NeedIntersectWithMesh, InitialFillColor, HasOutLine, PolygonLineColor) {
+    let PolygonElement;
+    // 点数组,(纬度，经度，到球心距离)
+    let Position = pointList.map(item => {
+      return new Gaea.Vector3(item[0], item[1], 50)
+    })
+    // 根据坐标点创建几何对象，参数（几何形状类型，几何数据）
+    var geometry = Gaea.Geometry.Create1(Gaea.GeometryType.Polygon, Position);
+    // 创建PointGeometryElement对象
+    PolygonElement = new Gaea.PolygonGeometryElement();
+    // 赋值
+    PolygonElement.Shape = geometry;
+    // 允许点击
+    PolygonElement.EnablePick = EnablePick;
+    // 允许编辑
+    PolygonElement.EnableEdit = EnableEdit;
+    // 允许在3Dtiles、管线、挖方等位置编辑
+    PolygonElement.NeedIntersectWithMesh = NeedIntersectWithMesh;
+    //开启虚拟点
+    PolygonElement.EnableVirtualPoint = true;
+    PolygonElement.InitialFillColor = new Gaea.Color(InitialFillColor[0], InitialFillColor[1], InitialFillColor[2], 1)
+
+    var PolygonSimpleFillSymbol = Gaea.SimpleFillSymbol.ConvertBy(PolygonElement.Symbol);
+    PolygonSimpleFillSymbol.HasOutLine = HasOutLine;
+    PolygonSimpleFillSymbol.OutLineSymbol.SymbolColor = new Gaea.Color(PolygonLineColor[0], PolygonLineColor[1], PolygonLineColor[2], 1);
+
+    //选中的回调事件
+    PolygonElement.SelectedCallBack((a, b, c, d, e, f) => {
+      if (c) {
+        //获取选中element
+        selectelement = new Gaea.PolygonGeometryElement(false);
+        selectelement.InstanceID = a + "";
+      }
+    });
+    // 将Element加入到场景中
+    Gaea.World.Instance.RenderableObjectList.AddLast(PolygonElement);
+    this.elements.push(PolygonElement);
+    return PolygonElement;
+  }
+
+  /**
+   * 修改面颜色
+   *
+   * @param {*} PolygonElement 面对象
+   * @param {*} PolygonColor 面颜色
+   * @memberof App
+   */
+  updatePolygonColor(PolygonElement, PolygonColor) {
+    PolygonElement.InitialFillColor = new Gaea.Color(PolygonColor[0], PolygonColor[1], PolygonColor[2], 1)
+  }
+
+  /**
+   * 画贴地面
+   *
+   * @param {*} list 贴地面数据数组
+   * @param {*} color 贴地面颜色
+   * @memberof App
+   */
+  AddGroundPolygonByGeojson(list, color) {
+    list.forEach((item) => {
+      var geojsonFile = `${item}.geojson`; //设置保存时的文件名,要带拓展名
+      var geojson_res = "user://resources/"; //设置保存目录
+      //请求geojson文件并保存，加载
+      Gaea.GaeaResourceLoader.Instance.LoadResourceFromUrl1(`${window.location.origin}/geojson/海塘边界/${item}.geojson`, geojsonFile, (code, msg) => {
+        if (code == 200) {
+          var ws = Gaea.WorkspaceFactory.OpenFromFile(geojson_res + geojsonFile); //打开文件
+          var fclass = ws.OpenFeatureClass(true, false); //读取文件，构建FeatureClass
+          var flayer = new Gaea.FeatureLayer(); //创建一个FeatureLayer图层
+          // 贴地面
+          var res = Gaea.GaeaResourceLoader.Instance.LoadLoaclResource("res://assets/shaders/polygonClampGround.shader");
+          var shader = Gaea.Shader.ConvertBy(res);
+          var material = new Gaea.ShaderMaterial();
+          material.Shader = shader;
+          Gaea.World.Instance.SetMtlColor(material, "albedo", new Gaea.Color(color[0] / 255, color[1] / 255, color[2] / 255, 0.5)); //设置颜色
+          var Symbol = new Gaea.GroundPolygonSymbol();
+          Symbol.PrismHeight = 9999;
+          Symbol.GroundPolygonMtl = material;
+          var FeatureRenderer = new Gaea.SimpleFeatureRenderer(); //创建一个渲染器
+          FeatureRenderer.Symbol = Symbol; //设置渲染器的符号
+          flayer.VisibleRange = new Gaea.Vector2(0, 1000000); //设置可见高度范围
+          flayer.FeatureClass = fclass; //设置图层中的数据，即fclass
+          flayer.FeatureRenderer = FeatureRenderer; //设置图层中的渲染器， 即FeatureRenderer
+          flayer.Name = item; //设置图层名称
+          this.groundPolygon.push(item);
+          Gaea.World.Instance.RenderableObjectList.AddLast(flayer); //将图层添加到可渲染对象列表
+        }
+      });
+    });
+  }
+  // 清除贴地面
+  ClearPolygon(name) {
+    var node = Gaea.World.Instance.RenderableObjectList.GetByName(name);
+    if (node != null) {
+      Gaea.World.Instance.RenderableObjectList.Remove(node);
+      this.groundPolygon = [];
+    }
+  }
+
+  AddGroundLineByGeojson = (list, color) => {
+    let that = this;
+
+    list.forEach((item) => {
+      var geojsonFile = `${item}.geojson`; //设置保存时的文件名,要带拓展名
+      var res = "user://resources/"; //设置保存目录
+      //请求geojson文件并保存，加载
+      let existingIndex = this.groundWire.findIndex((item) => item.name == item);
+      if (existingIndex > -1) {
+        console.warn(item, "贴地线已经存在！！");
+        return;
+      }
+      Gaea.GaeaResourceLoader.Instance.LoadResourceFromUrl1(`${window.location.origin}/static/geojson/${item}.geojson`, geojsonFile, (code, msg) => {
+        if (code == 200) {
+          // var geojsonWorkspace = new Gaea.GeojsonWorkspace();
+          // var fclass = geojsonWorkspace.OpenFeatureClassWithGeoJsonStr(res + geojsonFile, true);
+          var ws = Gaea.WorkspaceFactory.OpenFromFile(res + geojsonFile); //打开文件
+          var fclass = ws.OpenFeatureClass(true, false); //读取文件，构建FeatureClass
+          var flayer = new Gaea.FeatureLayer(); //创建一个FeatureLayer图层
+          var Symbol = new Gaea.GroundPolylineSymbol();
+          Symbol.Width = 3;
+          Symbol.LineColor = new Gaea.Color(color[0] / 255, color[1] / 255, color[2] / 255, 1);
+          var FeatureRenderer = new Gaea.SimpleFeatureRenderer(); //创建一个渲染器
+          FeatureRenderer.Symbol = Symbol; //设置渲染器的符号
+          flayer.VisibleRange = new Gaea.Vector2(0, 1000000); //设置可见高度范围
+          flayer.FeatureClass = fclass; //设置图层中的数据，即fclass
+          flayer.FeatureRenderer = FeatureRenderer; //设置图层中的渲染器， 即FeatureRenderer
+          flayer.Name = item; //设置图层名称
+          Gaea.World.Instance.RenderableObjectList.AddLast(flayer); //将图层添加到可渲染对象列表
+          that.groundWire.push({
+            name: item,
+            flayer,
+          });
+        }
+      });
+    });
+  };
+
+  /**
+ * 根据画出的多边形裁剪出地形工具
+ * @param {*} pointList 坐标点数组
+ * @param {*} height 裁剪高度
+ * @param {*} callback 回调函数
+ * @returns
+ */
+  editTerrainTool = (pointList, height, callback) => {
+    // var tool = new Gaea.DigTool();
+    // tool.CutInside = false;
+    // Gaea.World.Instance.SetCurrentTool(tool);
+    var Position = [];
+    if (pointList.length > 0) {
+      pointList.forEach((point) => {
+        Position.push(new Gaea.Vector3(point.x, point.y, point.z));
+      });
+    } else {
+      return false;
+    }
+    var OriginPoint = [];
+    Position.forEach((element) => {
+      OriginPoint.push(Gaea.GaeaMath.SphericalToCartesianDeg(element));
+    });
+    var _Holeitem = Gaea.ExcavationManager.Instance.CreateItem(OriginPoint, 100, height, 1, true, false);
+    if (Gaea.QueryServer.Instance != null) {
+      var box = Gaea.World.Instance.SimplePolygonGenerater(Position, false, false, false, false, Gaea.ExcavationManager.Instance.FenceHeight, 0, 2, 1000);
+      Gaea.World.Instance.AddChild(box, false);
+      Gaea.QueryServer.Instance.ClipBox = box;
+    }
+    Gaea.QueryServer.Instance.ClipInside = true;
+    Gaea.ExcavationManager.Instance.ClipInside3dtiles = false;
+    Gaea.ExcavationManager.Instance.ClipInsideVector = true;
+    Gaea.ExcavationManager.Instance.AddItem(_Holeitem);
+    // var camera = Gaea.World.Instance.DefaultCamera;
+    // camera.SetPosition2(30, 112, 0, 3000, 0, 0);
+    setTimeout(function () {
+      // 调用回调函数
+      if (typeof callback === "function") {
+        callback(_Holeitem);
+      }
+    }, 1000); // 设置延迟为1000毫秒
+  };
+
+  /**
+   * 裁剪还原
+   */
+  restoreTerrain = () => {
+    Gaea.World.Instance.SetCurrentTool(null);
+    if (Gaea.QueryServer.Instance.ClipBox != null) {
+      // Gaea.QueryServer.Instance.ClipBox.QueueFree();
+      Gaea.QueryServer.Instance.ClipBox = null;
+      Gaea.ExcavationManager.Instance.Clear();
+    }
+  };
+
+  Dig() {
+    var mtl = Gaea.GaeaResourceLoader.Instance.LoadLoaclResource(
+      "res://assets/material/围挡.material"
+    );
+    var spmtl = Gaea.SpatialMaterial.ConvertBy(mtl);
+    spmtl.FlagsUnshaded = false;
+    spmtl.FlagsDisableAmbientLight = false;
+    Gaea.ExcavationManager.Instance.FenceHeight = 10;
+    Gaea.QueryServer.Instance.ClipBoxMaterial = spmtl;
+    var digTool = new Gaea.DigTool();
+    digTool.CutInside = false;
+    Gaea.World.Instance.SetCurrentTool(null);
+    Gaea.World.Instance.SetCurrentTool(digTool);
+    Gaea.QueryServer.Instance.ClipInside = true;
+    Gaea.ExcavationManager.Instance.FenceHeight = 50;
+    Gaea.ExcavationManager.Instance.NeedFence = false;
+    Gaea.ExcavationManager.Instance.ExposureLength = 0;
+  }
+
+  AddSea() {
+    var sea = null;
+    const sunObj = Gaea.World.Instance.GetNode("Sun");
+    const sun = Gaea.Sun.ConvertBy(sunObj);
+    sun.TimeScale = 0.0;
+    sun.TimeString = "2022-09-15 12:00:00"
+    var mtl = Gaea.World.Instance.FullScreenQuad.GetWeatherShader();
+    Gaea.World.Instance.SetMtlFloat(mtl, "caustics_scale", 0.158);
+    Gaea.World.Instance.SetMtlFloat(mtl, "caustics_mix", 0.522);
+    Gaea.World.Instance.SetMtlColor(mtl, "fog_color", new Gaea.Color(0.043, 0.17, 0.235, 1.0));
+
+    if (!sea) {
+      sea = new Gaea.DrawOcean()
+      sea.OceanType = 0;
+      sea.FogColor = new Gaea.Color(0.26, 0.39, 0.44, 1.0);
+      sea.FogDepthBegin = 0.0;
+      sea.FogDepthEnd = 1000.0;
+      sea.UnderWaterColor = new Gaea.Color(0.26, 0.39, 0.44, 0.73);
+      sea.MeanHeight = 50.0;
+      sea.SeaBase = new Gaea.Color(0.027, 0.098, 0.173, 1.0);
+      sea.SeaHeight = 0.7;
+      sea.SeaChoppy = 6;
+      sea.SeaFreq = 0.16;
+      // seacolor = new Gaea.Color(0.027, 0.098, 0.173, 1.0);
+      Gaea.World.Instance.AddChild(sea, false);
+      Gaea.World.Instance.HasWater = true;
+      sea.SeaWaterColor = new Gaea.Color(0, 0, 0, 0.78);
+      // seas.push(sea)
+      var f = Gaea.WeatherManager.ConvertBy(Gaea.World.Instance.FullScreenQuad);
+      var mtl = Gaea.ShaderMaterial.ConvertBy(f.GetWeatherShader());
+      mtl.RenderPriority = 120;
+    }
+    //Gaea.World.Instance.DefaultCamera.SetPosition(24.1558538968461, 120.39105397970);
+    // LoadGLTF1();
+  }
+
+  /**
+   * 沿线飞行 - 相机沿路径自动飞行
+   * @param {Array} lineData - 路径点数组，每个点格式 {x: 纬度, y: 经度}
+   * @param {Object} options - 飞行配置选项
+   * @param {number} options.height - 飞行高度（米），默认 150
+   * @param {number} options.step - 插值步数，默认 1000
+   * @param {number} options.duration - 飞行时长（秒），默认 20
+   * @param {number} options.xrotation - X轴旋转角度（俯仰角），默认 -30
+   * @param {boolean} options.lockEye - 是否锁定相机视角，默认 true
+   * @param {number} options.minZoom - 最小缩放距离，默认 0
+   * @param {number} options.maxZoom - 最大缩放距离，默认 400
+   * @returns {Promise} - 飞行完成后 resolve
+   */
+  flyAlongPath = async (lineData, options = {}) => {
+    const opts = {
+      height: 200,
+      step: 1000,
+      duration: 20.0,
+      xrotation: 30,
+      lockEye: false,
+      minZoom: 200,
+      maxZoom: 1000,
+      ...options
+    };
+
+    if (!lineData || lineData.length < 2) {
+      console.error('flyAlongPath: 至少需要2个路径点');
+      return Promise.reject(new Error('至少需要2个路径点'));
+    }
+
+    try {
+      this._cleanupFlyResources();
+
+      const bezierCurve = new Gaea.UniformCubicSpline();
+      for (let i = 0; i < lineData.length; i++) {
+        const control = Gaea.GaeaMath.SphericalToCartesianDeg(
+          new Gaea.Vector3(lineData[i].x, lineData[i].y, opts.height)
+        );
+        bezierCurve.AddValue(i, control);
+      }
+      bezierCurve.Step = opts.step;
+      bezierCurve.Interpolate(true);
+      bezierCurve.CalculateLengthAfterInterpolation();
+
+      const startPos = Gaea.GaeaMath.SphericalToCartesianDeg(
+        new Gaea.Vector3(lineData[0].x, lineData[0].y, opts.height)
+      );
+
+      const mesh = new Gaea.CubeMesh();
+      mesh.Size = new Gaea.Vector3(1, 1, 1);
+
+      const mtl = new Gaea.SpatialMaterial();
+      mtl.AlbedoColor = new Gaea.Color(1, 0, 0, 1);
+      mesh.SurfaceSetMaterial(0, mtl);
+
+      this._flyModelInstance = new Gaea.MeshInstance();
+      this._flyModelInstance.Name = 'flyPathModel';
+      this._flyModelInstance.Visible = false;
+      this._flyModelInstance.Translation = startPos;
+      Gaea.World.Instance.AddChild(this._flyModelInstance, false);
+
+      this._flyEntityView = new Gaea.EntityView();
+      this._flyEntityView.Offset3D = new Gaea.Vector3(
+        -1,
+        0,
+        Math.tan(opts.xrotation / 180 * Math.PI)
+      );
+      this._flyEntityView.LockEye = opts.lockEye;
+      this._flyEntityView.MinMaxZoom3D = new Gaea.Vector2(opts.minZoom, opts.maxZoom);
+      this._flyEntityView.Init(this._flyModelInstance);
+      Gaea.World.Instance.CameraController.LockedEntity = this._flyEntityView;
+
+      this._flyAnimation = bezierCurve.ToAnimationByTime(
+        'flyPathAnimation',
+        true,
+        opts.duration,
+        new Gaea.Vector3(1, 1, 1)
+      );
+      this._flyAnimation.TrackSetPath(0, '/root/World/flyPathModel');
+
+      this._flyAnimationPlayer = new Gaea.GaeaAnimationPlayer();
+      this._flyAnimationPlayer.AddAnimation('flyPathAnimation', this._flyAnimation);
+      Gaea.World.Instance.AddChild(this._flyAnimationPlayer, false);
+
+      return new Promise((resolve) => {
+        this._flyAnimationPlayer.PlayWithCallback(
+          'flyPathAnimation',
+          Gaea.CallbackType.AnimatioFinished,
+          () => {
+            console.log('动画播放完成');
+            resolve();
+          }
+        );
+      });
+    } catch (error) {
+      console.error('flyAlongPath 启动失败:', error);
+      this._cleanupFlyResources();
+      return Promise.reject(error);
+    }
+  };
+
+  /**
+   * 停止沿线飞行
+   */
+  stopFlyAlongPath = () => {
+    try {
+      if (this._flyAnimationPlayer) {
+        this._flyAnimationPlayer.Stop('flyPathAnimation');
+      }
+    } catch (error) {
+      console.error('停止飞行失败:', error);
+    }
+    this._cleanupFlyResources();
+  };
+
+  /**
+   * 清理飞行相关资源
+   * @private
+   */
+  _cleanupFlyResources = () => {
+    try {
+      if (this._flyAnimationPlayer) {
+        Gaea.World.Instance.RemoveChild(this._flyAnimationPlayer);
+        this._flyAnimationPlayer = null;
+      }
+      if (this._flyEntityView) {
+        this._flyEntityView = null;
+      }
+      if (this._flyModelInstance) {
+        Gaea.World.Instance.RemoveChild(this._flyModelInstance);
+        this._flyModelInstance = null;
+      }
+      Gaea.World.Instance.CameraController.LockedEntity = null;
+      this._flyAnimation = null;
+    } catch (error) {
+      console.error('清理飞行资源失败:', error);
+    }
+  };
+
+  /**
+   * 根据经纬度坐标在指定位置放置图标标记（仅图标，无文字）
+   * @param {Object} options - 配置选项
+   * @param {number} options.lat - 纬度
+   * @param {number} options.lng - 经度
+   * @param {number} options.alt - 高度（米），默认 0
+   * @param {number} options.iconSize - 图标大小，默认 150
+   * @param {boolean} options.enablePick - 是否可点击，默认 true
+   * @returns {Promise<Object>} - 返回创建的 element
+   */
+  addPointIcon = async (options = {}) => {
+    const {
+      lat = '27.158573',
+      lng = '120.4972157',
+      alt = 0,
+      iconSize = 500,
+      enablePick = true
+    } = options;
+
+    if (lat == null || lng == null) {
+      console.error('addPointIcon: lat 和 lng 不能为空');
+      return null;
+    }
+
+    // 加载 .res 图标文件（仅首次）
+    const resName = 'pointIcon.res';
+    if (!this._pointIconLoaded) {
+      const resUrl = `${serveLocal}/static/1111.res`;
+      const loaded = await LoadResourceFromUrl(resUrl, resName);
+      if (!loaded) {
+        console.error('addPointIcon: 加载 .res 图标文件失败');
+        return null;
+      }
+      this._pointIconLoaded = true;
+    }
+
+    const texId = Gaea.GaeaResourceLoader.Instance.GetResource(resName);
+    const tex = new Gaea.Texture(false);
+    tex.InstanceID = texId + '';
+
+    // 构建坐标
+    const pos = new Gaea.Vector3(lat, lng, alt);
+    const shape = Gaea.Geometry.Create1(Gaea.GeometryType.Point, [pos]);
+
+    const element = new Gaea.PointGeometryElement();
+    element.Shape = shape;
+
+    // 仅图标符号（无文字）
+    const iconMarkSymbol = new Gaea.IconMarkSymbol();
+    iconMarkSymbol.MarkSize = iconSize;
+    iconMarkSymbol.Icon = tex;
+    element.Symbol = iconMarkSymbol;
+
+    element.EnablePick = enablePick;
+    element.EnableEdit = false;
+
+    Gaea.World.Instance.RenderableObjectList.AddLast(element);
+
+    // 托管存储
+    if (!this._pointIconElements) {
+      this._pointIconElements = [];
+    }
+    this._pointIconElements.push(element);
+
+    console.log(element,'elementelementelementelement');
+    
+    return element;
+  };
+
+  /**
+   * 批量添加图标标记
+   * @param {Array} pointList - 坐标数组 [{lat, lng, alt?, iconSize?}]
+   * @returns {Promise<Array>} - 返回所有 element 数组
+   */
+  addPointIcons = async (pointList = []) => {
+    const elements = [];
+    for (const point of pointList) {
+      const el = await this.addPointIcon(point);
+      if (el) elements.push(el);
+    }
+    return elements;
+  };
+
+  /**
+   * 清除所有图标标记
+   */
+  clearPointIcons = () => {
+    if (this._pointIconElements && this._pointIconElements.length > 0) {
+      this._pointIconElements.forEach((element) => {
+        Gaea.World.Instance.RenderableObjectList.Remove(element);
+      });
+      this._pointIconElements = [];
+    }
+  };
+
+  /**
+   * 移除指定图标标记
+   * @param {string|number} instanceId - element实例ID
+   */
+  removePointIcon = (instanceId) => {
+    if (!this._pointIconElements || this._pointIconElements.length === 0) return;
+    const idx = this._pointIconElements.findIndex(
+      (ele) => ele.InstanceID === instanceId
+    );
+    if (idx >= 0) {
+      const element = this._pointIconElements[idx];
+      Gaea.World.Instance.RenderableObjectList.Remove(element);
+      this._pointIconElements.splice(idx, 1);
+    }
+  };
+
+  /**
+   * 加载台风路线 - 从逗号分隔的坐标文本批量放置图标
+   * @param {string} routeText - 路线文本，每行格式 "经度,纬度"
+   * @param {number} iconSize - 图标大小，默认 150
+   */
+  addTyphoonRoute = async (routeText, iconSize = 150) => {
+    if (!routeText || !routeText.trim()) {
+      console.warn('addTyphoonRoute: 路线文本为空');
+      return;
+    }
+
+    // 清除旧标注
+    this.clearPointIcons();
+
+    // 解析路线文本，每行格式: 经度,纬度
+    const lines = routeText.trim().split('\n');
+    const points = [];
+    for (const line of lines) {
+      const parts = line.trim().split(/[,，\s]+/);
+      if (parts.length >= 2) {
+        const lng = parseFloat(parts[0]);
+        const lat = parseFloat(parts[1]);
+        if (!isNaN(lat) && !isNaN(lng)) {
+          points.push({ lat, lng, iconSize });
+        }
+      }
+    }
+
+    if (points.length === 0) {
+      console.warn('addTyphoonRoute: 未解析到有效坐标');
+      return;
+    }
+
+    await this.addPointIcons(points);
+  };
+
+}