iflow-engine-base 4.0.15 → 4.0.16

package/dist/chunks/engine-720-OdgX2p-d.js

@@ -0,0 +1,1565 @@
+import { s as S, av as R, j as E, F as x, M as A, t as b, U as k, Q as F, x as I, W as y, v, d as f, S as P, a2 as m, V as p, e as D } from "./three-vendor-Ds9cgGKb.js";
+import { C as L, W as w, E as T, c as z, r as _ } from "./sdk-runtime-KslKRuwI.js";
+class V {
+  scene;
+  panoramaSphere = null;
+  sphereRadius;
+  constructor(e = 500) {
+    this.sphereRadius = e, this.scene = new S(), this.init();
+  }
+  /**
+   * 初始化场景
+   */
+  init() {
+    this.panoramaSphere = this.createPanoramaSphere(this.sphereRadius), this.scene.add(this.panoramaSphere);
+  }
+  /**
+   * 创建全景球体
+   * @param radius 球体半径（建议 500-1000）
+   * @param segments 分段数（建议 64）
+   * @returns 球体网格对象
+   */
+  createPanoramaSphere(e = 500, t = 64) {
+    const n = new R(
+      e,
+      // 半径
+      t,
+      // 水平分段
+      t / 2
+      // 垂直分段
+    );
+    n.scale(-1, 1, 1);
+    const o = new E({
+      map: null,
+      // 纹理后续加载
+      side: x,
+      // Render inner surface; geometry is flipped via scale(-1,1,1)
+      transparent: !0
+    }), a = new A(n, o);
+    return a.name = "panorama-sphere", a;
+  }
+  /**
+   * 更新全景图纹理
+   * @param texture Three.js 纹理对象
+   */
+  updatePanoramaTexture(e) {
+    if (!this.panoramaSphere) {
+      console.warn("SceneModule720: Panorama sphere not initialized");
+      return;
+    }
+    const t = this.panoramaSphere.material;
+    t.map && t.map.dispose(), t.map = e, t.needsUpdate = !0;
+  }
+  /**
+   * 清除当前全景纹理
+   */
+  clearPanoramaTexture() {
+    if (!this.panoramaSphere)
+      return;
+    const e = this.panoramaSphere.material;
+    e.map && (e.map.dispose(), e.map = null, e.needsUpdate = !0);
+  }
+  /**
+   * 获取场景对象
+   */
+  getScene() {
+    return this.scene;
+  }
+  /**
+   * 获取全景球体对象
+   */
+  getPanoramaSphere() {
+    return this.panoramaSphere;
+  }
+  /**
+   * 设置球体半径（需要重新创建球体）
+   * @param radius 新的半径
+   */
+  setSphereRadius(e) {
+    if (this.sphereRadius !== e) {
+      if (this.sphereRadius = e, this.panoramaSphere) {
+        const t = this.panoramaSphere.material, n = t.map;
+        this.scene.remove(this.panoramaSphere), this.panoramaSphere.geometry.dispose(), t.dispose(), n && n.dispose();
+      }
+      this.panoramaSphere = this.createPanoramaSphere(e), this.scene.add(this.panoramaSphere);
+    }
+  }
+  /**
+   * 获取球体半径
+   */
+  getSphereRadius() {
+    return this.sphereRadius;
+  }
+  /**
+   * 销毁模块
+   */
+  dispose() {
+    if (this.panoramaSphere) {
+      const e = this.panoramaSphere.material;
+      e.map && e.map.dispose(), e.dispose(), this.panoramaSphere.geometry.dispose(), this.scene.remove(this.panoramaSphere), this.panoramaSphere = null;
+    }
+    this.scene.clear();
+  }
+}
+class K {
+  camera;
+  minFov;
+  maxFov;
+  container;
+  /**
+   * 当前相机姿态（球面坐标）
+   */
+  currentPose;
+  constructor(e, t = 75, n = 30, o = 90) {
+    this.container = e, this.minFov = n, this.maxFov = o, this.currentPose = {
+      theta: 0,
+      // 水平角度
+      phi: 0
+      // 垂直角度
+    }, this.camera = this.createCamera(t), this.init();
+  }
+  /**
+   * 创建透视相机
+   */
+  createCamera(e) {
+    const t = this.container.clientWidth / this.container.clientHeight, n = new b(e, t, 0.1, 2e3);
+    return n.position.set(0, 0, 0), n;
+  }
+  /**
+   * 初始化相机
+   */
+  init() {
+    this.updateCameraRotation();
+  }
+  /**
+   * 更新相机旋转（基于当前姿态）
+   */
+  updateCameraRotation() {
+    const { theta: e, phi: t } = this.currentPose, n = new k(t, e, 0, "YXZ"), o = new F();
+    o.setFromEuler(n), this.camera.quaternion.copy(o);
+  }
+  /**
+   * 设置 FOV（视野角度）
+   * @param fov 视野角度（度）
+   */
+  setFov(e) {
+    const t = Math.max(this.minFov, Math.min(this.maxFov, e));
+    this.camera.fov = t, this.camera.updateProjectionMatrix();
+  }
+  /**
+   * 获取当前 FOV
+   */
+  getFov() {
+    return this.camera.fov;
+  }
+  /**
+   * 获取相机姿态
+   */
+  getCameraPose() {
+    return { ...this.currentPose };
+  }
+  /**
+   * 设置相机姿态（球面坐标）
+   * @param theta 水平角度（弧度）
+   * @param phi 垂直角度（弧度）
+   */
+  setCameraPose(e, t) {
+    this.currentPose.theta = e, this.currentPose.phi = t, this.updateCameraRotation();
+  }
+  /**
+   * 更新相机姿态（增量更新）
+   * @param deltaTheta 水平角度增量（弧度）
+   * @param deltaPhi 垂直角度增量（弧度）
+   */
+  updatePose(e, t) {
+    this.currentPose.theta += e, this.currentPose.phi += t, this.currentPose.theta < 0 ? this.currentPose.theta += 2 * Math.PI : this.currentPose.theta >= 2 * Math.PI && (this.currentPose.theta -= 2 * Math.PI), this.currentPose.phi = Math.max(
+      -Math.PI / 2 + 0.01,
+      Math.min(Math.PI / 2 - 0.01, this.currentPose.phi)
+    ), this.updateCameraRotation();
+  }
+  /**
+   * 获取相机对象
+   */
+  getCamera() {
+    return this.camera;
+  }
+  /**
+   * 调整相机宽高比
+   * @param width 容器宽度
+   * @param height 容器高度
+   */
+  updateAspectRatio(e, t) {
+    const n = e / t;
+    this.camera.aspect = n, this.camera.updateProjectionMatrix();
+  }
+  /**
+   * 销毁相机
+   */
+  dispose() {
+    this.camera = null;
+  }
+}
+class O {
+  renderer;
+  container;
+  animationId = null;
+  isRenderingPaused = !1;
+  watermark;
+  // FPS 监控
+  fpsFrameCount = 0;
+  fpsLastTime = performance.now();
+  currentFps = 60;
+  // 渲染回调
+  onBeforeRenderCallback;
+  onAfterRenderCallback;
+  constructor(e, t = !0) {
+    this.container = e, this.renderer = this.createRenderer(t), this.watermark = new L(I), this.init();
+  }
+  /**
+   * 创建 WebGL 渲染器
+   */
+  createRenderer(e) {
+    const t = new y({
+      antialias: e,
+      alpha: !0,
+      preserveDrawingBuffer: !1
+    }), n = this.container.clientWidth, o = this.container.clientHeight;
+    return t.setSize(n, o), t.setPixelRatio(Math.min(window.devicePixelRatio, 2)), this.container.appendChild(t.domElement), t;
+  }
+  /**
+   * 初始化渲染器
+   */
+  init() {
+  }
+  /**
+   * 设置渲染前回调
+   */
+  setOnBeforeRender(e) {
+    this.onBeforeRenderCallback = e;
+  }
+  /**
+   * 设置渲染后回调
+   */
+  setOnAfterRender(e) {
+    this.onAfterRenderCallback = e;
+  }
+  /**
+   * 渲染场景
+   */
+  render(e, t) {
+    this.onBeforeRenderCallback && this.onBeforeRenderCallback(), this.renderer.render(e, t), this.watermark.render(this.renderer), this.onAfterRenderCallback && this.onAfterRenderCallback(), this.updateFps();
+  }
+  /**
+   * 启动渲染循环
+   * @param scene Three.js 场景
+   * @param camera Three.js 相机
+   */
+  startRenderLoop(e, t) {
+    if (this.animationId !== null) {
+      console.warn("RenderModule720: Render loop already running");
+      return;
+    }
+    this.isRenderingPaused = !1, this.animate(e, t);
+  }
+  /**
+   * 动画循环
+   */
+  animate(e, t) {
+    this.isRenderingPaused || (this.animationId = requestAnimationFrame(() => {
+      this.animate(e, t);
+    }), this.render(e, t));
+  }
+  /**
+   * 暂停渲染
+   */
+  pauseRendering() {
+    this.isRenderingPaused = !0, this.animationId !== null && (cancelAnimationFrame(this.animationId), this.animationId = null);
+  }
+  /**
+   * 恢复渲染
+   */
+  resumeRendering(e, t) {
+    this.isRenderingPaused && (this.isRenderingPaused = !1, this.startRenderLoop(e, t));
+  }
+  /**
+   * 检查渲染是否暂停
+   */
+  isRenderingPausedState() {
+    return this.isRenderingPaused;
+  }
+  /**
+   * 更新 FPS
+   */
+  updateFps() {
+    this.fpsFrameCount++;
+    const e = performance.now();
+    e >= this.fpsLastTime + 1e3 && (this.currentFps = Math.round(this.fpsFrameCount * 1e3 / (e - this.fpsLastTime)), this.fpsFrameCount = 0, this.fpsLastTime = e, this.currentFps < 30 && console.warn("RenderModule720: Low FPS detected:", this.currentFps));
+  }
+  /**
+   * 获取当前 FPS
+   */
+  getCurrentFps() {
+    return this.currentFps;
+  }
+  /**
+   * 调整渲染器大小
+   * @param width 容器宽度
+   * @param height 容器高度
+   */
+  resize(e, t) {
+    this.renderer.setSize(e, t), this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+  }
+  /**
+   * 获取渲染器 DOM 元素
+   */
+  getDomElement() {
+    return this.renderer.domElement;
+  }
+  /**
+   * 获取渲染器对象
+   */
+  getRenderer() {
+    return this.renderer;
+  }
+  /**
+   * 销毁渲染器
+   */
+  dispose() {
+    this.pauseRendering(), this.container.contains(this.renderer.domElement) && this.container.removeChild(this.renderer.domElement), this.watermark.dispose(), this.renderer.dispose(), this.renderer.forceContextLoss(), this.onBeforeRenderCallback = void 0, this.onAfterRenderCallback = void 0;
+  }
+}
+class H {
+  camera;
+  domElement;
+  cameraModule;
+  // CameraModule720 引用
+  // 配置参数
+  enableZoom = !0;
+  enableRotate = !0;
+  minFov = 30;
+  // 最小 FOV (最大缩放)
+  maxFov = 90;
+  // 最大 FOV (最小缩放)
+  rotateSpeed = 0.5;
+  zoomSpeed = 1;
+  enableDamping = !0;
+  dampingFactor = 0.05;
+  // 内部状态
+  isDragging = !1;
+  startX = 0;
+  startY = 0;
+  // 旋转增量
+  thetaDelta = 0;
+  phiDelta = 0;
+  isPinching = !1;
+  pinchStartDistance = null;
+  pinchStartFov = 75;
+  // 事件监听器绑定
+  _onMouseDown;
+  _onMouseMove;
+  _onMouseUp;
+  _onWheel;
+  _onTouchStart;
+  _onTouchMove;
+  _onTouchEnd;
+  // 视角变化回调
+  onViewAngleChange;
+  constructor(e, t) {
+    this.cameraModule = e, this.camera = e.getCamera(), this.pinchStartFov = this.camera.fov, this.domElement = t, this._onMouseDown = this.onMouseDown.bind(this), this._onMouseMove = this.onMouseMove.bind(this), this._onMouseUp = this.onMouseUp.bind(this), this._onWheel = this.onWheel.bind(this), this._onTouchStart = this.onTouchStart.bind(this), this._onTouchMove = this.onTouchMove.bind(this), this._onTouchEnd = this.onTouchEnd.bind(this), this.init();
+  }
+  /**
+   * 初始化控制器
+   */
+  init() {
+    this.domElement.addEventListener("mousedown", this._onMouseDown), this.domElement.addEventListener("mousemove", this._onMouseMove), this.domElement.addEventListener("mouseup", this._onMouseUp), this.domElement.addEventListener("mouseleave", this._onMouseUp), this.domElement.addEventListener("wheel", this._onWheel, { passive: !1 }), this.domElement.addEventListener("touchstart", this._onTouchStart, { passive: !1 }), this.domElement.addEventListener("touchmove", this._onTouchMove, { passive: !1 }), this.domElement.addEventListener("touchend", this._onTouchEnd);
+  }
+  /**
+   * 鼠标按下
+   */
+  onMouseDown(e) {
+    e.button === 0 && (this.isDragging = !0, this.startX = e.clientX, this.startY = e.clientY);
+  }
+  /**
+   * 鼠标移动
+   */
+  onMouseMove(e) {
+    if (!this.isDragging || !this.enableRotate) return;
+    const t = e.clientX - this.startX, n = e.clientY - this.startY, { horizontal: o, vertical: a } = this.getRotationFactors();
+    this.thetaDelta += t * o * this.rotateSpeed * 0.06, this.phiDelta += n * a * this.rotateSpeed * 0.06, this.startX = e.clientX, this.startY = e.clientY, this.applyRotation();
+  }
+  /**
+   * 鼠标弹起
+   */
+  onMouseUp() {
+    this.isDragging = !1;
+  }
+  /**
+   * 鼠标滚轮
+   */
+  onWheel(e) {
+    if (!this.enableZoom) return;
+    e.preventDefault();
+    const n = (e.deltaY > 0 ? 1 : -1) * this.zoomSpeed * 2;
+    this.applyZoom(n);
+  }
+  /**
+   * 触摸开始
+   */
+  onTouchStart(e) {
+    e.touches.length === 1 ? (this.isDragging = !0, this.isPinching = !1, this.startX = e.touches[0].clientX, this.startY = e.touches[0].clientY) : e.touches.length === 2 && (e.preventDefault(), this.isDragging = !1, this.isPinching = !0, this.pinchStartDistance = this.getTouchDistance(e.touches), this.pinchStartFov = this.cameraModule.getFov());
+  }
+  /**
+   * 触摸移动
+   */
+  onTouchMove(e) {
+    if (e.touches.length === 1 && this.isDragging && this.enableRotate) {
+      const t = e.touches[0].clientX - this.startX, n = e.touches[0].clientY - this.startY, { horizontal: o, vertical: a } = this.getRotationFactors();
+      this.thetaDelta -= t * o * this.rotateSpeed, this.phiDelta -= n * a * this.rotateSpeed, this.startX = e.touches[0].clientX, this.startY = e.touches[0].clientY, this.applyRotation();
+    } else if (e.touches.length === 2 && this.enableZoom) {
+      e.preventDefault(), this.isPinching || (this.isPinching = !0, this.pinchStartDistance = this.getTouchDistance(e.touches), this.pinchStartFov = this.cameraModule.getFov());
+      const t = this.getTouchDistance(e.touches);
+      if (this.pinchStartDistance && t > 0) {
+        const n = this.pinchStartDistance / t, o = v.clamp(
+          this.pinchStartFov * n,
+          this.minFov,
+          this.maxFov
+        );
+        this.cameraModule.setFov(o);
+      }
+    }
+  }
+  /**
+   * 触摸结束
+   */
+  onTouchEnd(e) {
+    e.touches && e.touches.length > 0 ? this.isDragging = e.touches.length === 1 : this.isDragging = !1, e.touches.length < 2 && (this.isPinching = !1, this.pinchStartDistance = null);
+  }
+  /**
+   * 应用旋转
+   */
+  applyRotation() {
+    if (this.cameraModule.updatePose(this.thetaDelta, this.phiDelta), this.enableDamping ? (this.thetaDelta *= 1 - this.dampingFactor, this.phiDelta *= 1 - this.dampingFactor) : (this.thetaDelta = 0, this.phiDelta = 0), this.onViewAngleChange) {
+      const e = this.cameraModule.getCameraPose();
+      this.onViewAngleChange(e.theta, e.phi);
+    }
+  }
+  /**
+   * 根据容器尺寸计算旋转灵敏度
+   */
+  getRotationFactors() {
+    const e = Math.max(1, this.domElement.clientWidth), t = Math.max(1, this.domElement.clientHeight);
+    return {
+      horizontal: Math.PI * 2 / e,
+      vertical: Math.PI / t
+    };
+  }
+  /**
+   * 统一缩放逻辑
+   */
+  applyZoom(e) {
+    const t = this.cameraModule.getFov(), n = v.clamp(
+      t + e,
+      this.minFov,
+      this.maxFov
+    );
+    this.cameraModule.setFov(n);
+  }
+  /**
+   * 计算多指距离
+   */
+  getTouchDistance(e) {
+    if (e.length < 2)
+      return 0;
+    const t = e[0].clientX - e[1].clientX, n = e[0].clientY - e[1].clientY;
+    return Math.sqrt(t * t + n * n);
+  }
+  /**
+   * 每帧更新（用于阻尼效果）
+   */
+  update() {
+    this.enableDamping && (Math.abs(this.thetaDelta) > 1e-4 || Math.abs(this.phiDelta) > 1e-4) && this.applyRotation();
+  }
+  /**
+   * 设置相机朝向（通过经纬度）
+   * @param theta 水平角度（弧度）
+   * @param phi 垂直角度（弧度）
+   */
+  lookAt(e, t) {
+    this.thetaDelta = e, this.phiDelta = Math.max(
+      -Math.PI / 2 + 0.01,
+      Math.min(Math.PI / 2 - 0.01, t)
+    ), this.cameraModule.setCameraPose(e, t), this.thetaDelta = 0, this.phiDelta = 0;
+  }
+  /**
+   * 获取当前视角
+   */
+  getViewAngle() {
+    return this.cameraModule.getCameraPose();
+  }
+  /**
+   * 设置视角变化回调
+   */
+  setOnViewAngleChange(e) {
+    this.onViewAngleChange = e;
+  }
+  /**
+   * 重置控制器
+   */
+  reset() {
+    this.thetaDelta = 0, this.phiDelta = 0, this.lookAt(0, 0);
+  }
+  /**
+   * 更新旋转灵敏度
+   */
+  setRotateSpeed(e) {
+    this.rotateSpeed = Math.max(0.05, e);
+  }
+  /**
+   * 更新缩放灵敏度
+   */
+  setZoomSpeed(e) {
+    this.zoomSpeed = Math.max(0.1, e);
+  }
+  /**
+   * 更新阻尼配置
+   */
+  setEnableDamping(e) {
+    this.enableDamping = e;
+  }
+  setDampingFactor(e) {
+    this.dampingFactor = Math.max(0, Math.min(1, e));
+  }
+  /**
+   * 更新 FOV 限制
+   */
+  setZoomLimits(e, t) {
+    this.minFov = e, this.maxFov = t;
+  }
+  /**
+   * 销毁控制器
+   */
+  dispose() {
+    this.domElement.removeEventListener("mousedown", this._onMouseDown), this.domElement.removeEventListener("mousemove", this._onMouseMove), this.domElement.removeEventListener("mouseup", this._onMouseUp), this.domElement.removeEventListener("mouseleave", this._onMouseUp), this.domElement.removeEventListener("wheel", this._onWheel), this.domElement.removeEventListener("touchstart", this._onTouchStart), this.domElement.removeEventListener("touchmove", this._onTouchMove), this.domElement.removeEventListener("touchend", this._onTouchEnd), this.onViewAngleChange = void 0;
+  }
+}
+class U {
+  controls;
+  domElement;
+  cameraModule;
+  constructor(e, t) {
+    this.cameraModule = e, this.domElement = t, this.controls = new H(e, t);
+  }
+  /**
+   * 初始化控制模块
+   */
+  init() {
+  }
+  /**
+   * 激活控制器
+   */
+  active() {
+  }
+  /**
+   * 禁用控制器
+   */
+  disActive() {
+    this.controls.enableRotate = !1, this.controls.enableZoom = !1;
+  }
+  /**
+   * 重新启用控制器
+   */
+  enable() {
+    this.controls.enableRotate = !0, this.controls.enableZoom = !0;
+  }
+  /**
+   * 更新控制器（每帧调用）
+   */
+  update() {
+    this.controls.update();
+  }
+  /**
+   * 设置视角
+   */
+  lookAt(e, t) {
+    this.controls.lookAt(e, t);
+  }
+  /**
+   * 获取当前视角
+   */
+  getViewAngle() {
+    return this.controls.getViewAngle();
+  }
+  /**
+   * 设置视角变化回调
+   */
+  setOnViewAngleChange(e) {
+    this.controls.setOnViewAngleChange(e);
+  }
+  /**
+   * 重置控制器
+   */
+  reset() {
+    this.controls.reset();
+  }
+  /**
+   * 获取控制器对象
+   */
+  getControls() {
+    return this.controls;
+  }
+  /**
+   * 动态更新交互参数
+   */
+  updateInteractionOptions(e) {
+    if (e.rotateSpeed !== void 0 && this.controls.setRotateSpeed(e.rotateSpeed), e.zoomSpeed !== void 0 && this.controls.setZoomSpeed(e.zoomSpeed), e.enableDamping !== void 0 && this.controls.setEnableDamping(e.enableDamping), e.dampingFactor !== void 0 && this.controls.setDampingFactor(e.dampingFactor), e.enableRotate !== void 0 && (this.controls.enableRotate = e.enableRotate), e.enableZoom !== void 0 && (this.controls.enableZoom = e.enableZoom), e.minFov !== void 0 || e.maxFov !== void 0) {
+      const t = e.minFov ?? this.controls.minFov, n = e.maxFov ?? this.controls.maxFov;
+      this.controls.setZoomLimits(t, n);
+    }
+  }
+  /**
+   * 销毁控制模块
+   */
+  dispose() {
+    this.controls.dispose();
+  }
+}
+class X {
+  cache = /* @__PURE__ */ new Map();
+  loadingPromises = /* @__PURE__ */ new Map();
+  /**
+   * 加载纹理（带缓存）
+   * @param url 纹理 URL
+   * @returns 纹理对象 Promise
+   */
+  loadTexture(e) {
+    if (this.cache.has(e))
+      return Promise.resolve(this.cache.get(e));
+    if (this.loadingPromises.has(e))
+      return this.loadingPromises.get(e);
+    const t = new Promise((n, o) => {
+      new f().load(
+        e,
+        (s) => {
+          s.colorSpace = P, s.minFilter = m, s.magFilter = m, this.cache.set(e, s), this.loadingPromises.delete(e), n(s);
+        },
+        void 0,
+        (s) => {
+          this.loadingPromises.delete(e), o(s);
+        }
+      );
+    });
+    return this.loadingPromises.set(e, t), t;
+  }
+  /**
+   * 预加载多个纹理
+   * @param urls 纹理 URL 数组
+   * @returns Promise，所有纹理加载完成后 resolve
+   */
+  async preloadTextures(e) {
+    const t = e.map((n) => this.loadTexture(n));
+    return Promise.all(t);
+  }
+  /**
+   * 检查纹理是否已缓存
+   * @param url 纹理 URL
+   */
+  has(e) {
+    return this.cache.has(e);
+  }
+  /**
+   * 获取缓存的纹理
+   * @param url 纹理 URL
+   * @returns 纹理对象，如果不存在则返回 undefined
+   */
+  get(e) {
+    return this.cache.get(e);
+  }
+  /**
+   * 清除特定纹理的缓存
+   * @param url 纹理 URL
+   */
+  remove(e) {
+    const t = this.cache.get(e);
+    t && (t.dispose(), this.cache.delete(e));
+  }
+  /**
+   * 清空所有缓存
+   */
+  clear() {
+    this.cache.forEach((e) => e.dispose()), this.cache.clear(), this.loadingPromises.clear();
+  }
+  /**
+   * 获取缓存大小
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * 销毁缓存
+   */
+  dispose() {
+    this.clear();
+  }
+}
+class Z {
+  textureCache;
+  currentUrl = null;
+  loadProgress = 0;
+  onProgressCallback;
+  constructor() {
+    this.textureCache = new X();
+  }
+  /**
+   * 加载全景图纹理
+   * @param url 全景图 URL
+   * @returns 纹理对象 Promise
+   */
+  async loadTexture(e) {
+    this.currentUrl = e, this.loadProgress = 0, this.onProgressCallback && this.onProgressCallback(0);
+    try {
+      const t = await this.loadTextureInternal(e);
+      return this.loadProgress = 100, this.onProgressCallback && this.onProgressCallback(100), t;
+    } catch (t) {
+      throw console.error("PanoramaLoader: Failed to load texture:", t), t;
+    }
+  }
+  /**
+   * 内部加载方法（支持进度）
+   */
+  loadTextureInternal(e) {
+    return new Promise((t, n) => {
+      if (this.textureCache.has(e)) {
+        const a = this.textureCache.get(e);
+        if (a) {
+          t(a);
+          return;
+        }
+      }
+      new f().load(
+        e,
+        (a) => {
+          a.colorSpace = P, a.minFilter = m, a.magFilter = m, this.textureCache.cache.set(e, a), t(a);
+        },
+        (a) => {
+          a.total > 0 && (this.loadProgress = a.loaded / a.total * 100, this.onProgressCallback && this.onProgressCallback(this.loadProgress));
+        },
+        (a) => {
+          n(a);
+        }
+      );
+    });
+  }
+  /**
+   * 预加载多个全景图
+   * @param urls 全景图 URL 数组
+   * @returns Promise，所有纹理加载完成后 resolve
+   */
+  async preloadPanoramas(e) {
+    try {
+      await this.textureCache.preloadTextures(e);
+    } catch (t) {
+      throw console.error("PanoramaLoader: Failed to preload panoramas:", t), t;
+    }
+  }
+  /**
+   * 获取当前加载进度
+   * @returns 进度百分比（0-100）
+   */
+  getLoadProgress() {
+    return this.loadProgress;
+  }
+  /**
+   * 设置进度回调
+   * @param callback 进度回调函数
+   */
+  setOnProgress(e) {
+    this.onProgressCallback = e;
+  }
+  /**
+   * 获取当前加载的 URL
+   */
+  getCurrentUrl() {
+    return this.currentUrl;
+  }
+  /**
+   * 检查纹理是否已缓存
+   * @param url 纹理 URL
+   */
+  isCached(e) {
+    return this.textureCache.has(e);
+  }
+  /**
+   * 获取缓存的纹理
+   * @param url 纹理 URL
+   */
+  getCachedTexture(e) {
+    return this.textureCache.get(e);
+  }
+  /**
+   * 清除纹理缓存
+   */
+  clearCache() {
+    this.textureCache.clear();
+  }
+  /**
+   * 移除特定纹理缓存
+   * @param url 纹理 URL
+   */
+  removeCachedTexture(e) {
+    this.textureCache.remove(e);
+  }
+  /**
+   * 销毁加载器
+   */
+  dispose() {
+    this.textureCache.dispose(), this.onProgressCallback = void 0, this.currentUrl = null;
+  }
+}
+class C {
+  /**
+   * 球面坐标转笛卡尔坐标
+   * @param position 球面坐标 { theta, phi, radius }
+   * @returns 笛卡尔坐标 { x, y, z }
+   */
+  static sphericalToCartesian(e) {
+    const t = e.radius || 500, { theta: n, phi: o } = e, a = t * Math.cos(o) * Math.cos(n), s = t * Math.sin(o), h = t * Math.cos(o) * Math.sin(n);
+    return { x: a, y: s, z: h };
+  }
+  /**
+   * 笛卡尔坐标转球面坐标
+   * @param x X 坐标
+   * @param y Y 坐标
+   * @param z Z 坐标
+   * @returns 球面坐标 { theta, phi, radius }
+   */
+  static cartesianToSpherical(e, t, n) {
+    const o = Math.sqrt(e * e + t * t + n * n), a = Math.asin(t / o);
+    let s = Math.atan2(n, e);
+    return s < 0 && (s += 2 * Math.PI), { theta: s, phi: a, radius: o };
+  }
+  /**
+   * 规范化角度到指定范围
+   * @param angle 角度（弧度）
+   * @param min 最小值（默认 -π）
+   * @param max 最大值（默认 π）
+   * @returns 规范化后的角度
+   */
+  static normalizeAngle(e, t = -Math.PI, n = Math.PI) {
+    const o = n - t;
+    let a = e;
+    for (; a < t; )
+      a += o;
+    for (; a > n; )
+      a -= o;
+    return a;
+  }
+  /**
+   * 限制 phi 角度在有效范围内（避免翻转）
+   * @param phi 垂直角度（弧度）
+   * @param minPhi 最小值（默认 -π/2 + 0.01）
+   * @param maxPhi 最大值（默认 π/2 - 0.01）
+   * @returns 限制后的角度
+   */
+  static clampPhi(e, t = -Math.PI / 2 + 0.01, n = Math.PI / 2 - 0.01) {
+    return Math.max(t, Math.min(n, e));
+  }
+  /**
+   * 计算两个球面坐标之间的角度距离
+   * @param pos1 第一个球面坐标
+   * @param pos2 第二个球面坐标
+   * @returns 角度距离（弧度）
+   */
+  static sphericalDistance(e, t) {
+    const n = Math.sin(e.phi) * Math.sin(t.phi) + Math.cos(e.phi) * Math.cos(t.phi) * Math.cos(e.theta - t.theta);
+    return Math.acos(Math.max(-1, Math.min(1, n)));
+  }
+  /**
+   * 线性插值两个球面坐标
+   * @param pos1 起始球面坐标
+   * @param pos2 目标球面坐标
+   * @param t 插值因子（0-1）
+   * @returns 插值后的球面坐标
+   */
+  static lerpSpherical(e, t, n) {
+    let o = t.theta - e.theta;
+    o > Math.PI ? o -= 2 * Math.PI : o < -Math.PI && (o += 2 * Math.PI);
+    const a = e.theta + o * n, s = e.phi + (t.phi - e.phi) * n, h = e.radius || 500, l = t.radius || 500, c = h + (l - h) * n;
+    return { theta: a, phi: s, radius: c };
+  }
+}
+var d = /* @__PURE__ */ ((i) => (i.ICON = "icon", i.TEXT = "text", i.LINK = "link", i))(d || {});
+class W {
+  annotations = /* @__PURE__ */ new Map();
+  container;
+  annotationContainer;
+  worldToScreen;
+  sphereRadius;
+  camera;
+  renderer;
+  // 事件监听器
+  onClickAnnotation;
+  onHoverAnnotation;
+  constructor(e, t, n, o) {
+    this.container = e, this.camera = t, this.renderer = n, this.sphereRadius = o, this.worldToScreen = new w(t, n), this.createAnnotationContainer();
+  }
+  /**
+   * 创建标注容器
+   */
+  createAnnotationContainer() {
+    this.annotationContainer = document.createElement("div"), this.annotationContainer.className = "panorama-annotation-container", this.annotationContainer.style.cssText = `
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            pointer-events: none;
+            z-index: 1000;
+            overflow: hidden;
+        `, this.container.appendChild(this.annotationContainer);
+  }
+  /**
+   * 添加标注
+   * @param config 标注配置
+   * @returns 标注 ID
+   */
+  addAnnotation(e) {
+    const t = this.generateId(), n = this.sphericalToCartesian(e.position), o = this.createAnnotationElement(e, t), a = {
+      id: t,
+      config: e,
+      element: o,
+      worldPosition: n,
+      screenPosition: { x: 0, y: 0 },
+      visible: !1
+    };
+    return this.annotationContainer.appendChild(o), this.annotations.set(t, a), this.updateAnnotationPosition(a), t;
+  }
+  /**
+   * 批量添加标注
+   * @param configs 标注配置数组
+   * @returns 标注 ID 数组
+   */
+  addAnnotations(e) {
+    return e.map((t) => this.addAnnotation(t));
+  }
+  /**
+   * 创建标注 DOM 元素
+   */
+  createAnnotationElement(e, t) {
+    const n = document.createElement("div");
+    switch (n.className = `panorama-annotation panorama-annotation-${e.type}`, n.dataset.annotationId = t, n.style.cssText = `
+            position: absolute;
+            pointer-events: auto;
+            cursor: pointer;
+            transform: translate(-50%, -50%);
+            transition: opacity 0.2s ease;
+        `, e.type) {
+      case d.ICON:
+        this.createIconAnnotation(n, e);
+        break;
+      case d.TEXT:
+        this.createTextAnnotation(n, e);
+        break;
+      case d.LINK:
+        this.createLinkAnnotation(n, e);
+        break;
+    }
+    return this.attachAnnotationEvents(n, t), n;
+  }
+  /**
+   * 创建图标标注
+   */
+  createIconAnnotation(e, t) {
+    const n = t.size || { width: 40, height: 40 };
+    e.style.width = `${n.width}px`, e.style.height = `${n.height}px`;
+    const o = document.createElement("img");
+    o.src = t.iconUrl, o.style.cssText = `
+            width: 100%;
+            height: 100%;
+            object-fit: contain;
+            display: block;
+        `, o.onerror = () => {
+      console.error(`Failed to load annotation icon: ${t.iconUrl}`);
+    }, e.appendChild(o), t.tooltip && (e.title = t.tooltip);
+  }
+  /**
+   * 创建文字标注
+   */
+  createTextAnnotation(e, t) {
+    const n = t.style || {};
+    e.style.cssText += `
+            padding: ${n.padding || "8px 12px"};
+            background-color: ${n.backgroundColor || "rgba(0, 0, 0, 0.7)"};
+            color: ${n.color || "#ffffff"};
+            font-size: ${n.fontSize || 14}px';
+            border-radius: 4px;
+            white-space: nowrap;
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+        `, e.textContent = t.text, t.tooltip && (e.title = t.tooltip);
+  }
+  /**
+   * 创建超链接标注
+   */
+  createLinkAnnotation(e, t) {
+    const n = t.style || {};
+    if (e.style.cssText += `
+            padding: 8px 12px;
+            background-color: rgba(59, 130, 246, 0.9);
+            color: ${n.color || "#ffffff"};
+            font-size: ${n.fontSize || 14}px';
+            border-radius: 4px;
+            text-decoration: ${n.textDecoration || "none"};
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            transition: background-color 0.2s ease;
+        `, e.addEventListener("mouseenter", () => {
+      e.style.backgroundColor = "rgba(37, 99, 235, 0.95)";
+    }), e.addEventListener("mouseleave", () => {
+      e.style.backgroundColor = "rgba(59, 130, 246, 0.9)";
+    }), t.iconUrl) {
+      const a = document.createElement("img");
+      a.src = t.iconUrl, a.style.cssText = `
+                width: 16px;
+                height: 16px;
+                display: block;
+            `, e.appendChild(a);
+    }
+    const o = document.createElement("span");
+    o.textContent = t.text || t.url, e.appendChild(o), t.tooltip && (e.title = t.tooltip);
+  }
+  /**
+   * 附加标注事件
+   */
+  attachAnnotationEvents(e, t) {
+    e.addEventListener("click", (n) => {
+      n.stopPropagation();
+      const o = this.annotations.get(t);
+      o && this.handleClickAnnotation(o);
+    }), e.addEventListener("mouseenter", () => {
+      const n = this.annotations.get(t);
+      n && this.handleHoverAnnotation(n);
+    }), e.addEventListener("mouseleave", () => {
+      this.onHoverAnnotation && this.onHoverAnnotation(null);
+    });
+  }
+  /**
+   * 球面坐标转笛卡尔坐标
+   */
+  sphericalToCartesian(e) {
+    const t = e.radius ?? this.sphereRadius;
+    return C.sphericalToCartesian({
+      ...e,
+      radius: t
+    });
+  }
+  /**
+   * 更新标注位置（单个标注）
+   */
+  updateAnnotationPosition(e) {
+    const t = new p(
+      e.worldPosition.x,
+      e.worldPosition.y,
+      e.worldPosition.z
+    ), n = this.worldToScreen.worldToScreen(t);
+    e.screenPosition = { x: n.x, y: n.y };
+    const o = this.isPositionInFront(t), a = this.isPositionInView(n);
+    e.visible = o && a, e.visible ? (e.element.style.display = "block", e.element.style.left = `${n.x}px`, e.element.style.top = `${n.y}px`) : e.element.style.display = "none";
+  }
+  /**
+   * 检查点是否在相机前方
+   */
+  isPositionInFront(e) {
+    const t = new p();
+    return this.camera.getWorldDirection(t), e.clone().normalize().dot(t) > 0;
+  }
+  /**
+   * 检查点是否在视野内
+   */
+  isPositionInView(e) {
+    const t = this.renderer.domElement.clientWidth, n = this.renderer.domElement.clientHeight;
+    return e.x >= 0 && e.x <= t && e.y >= 0 && e.y <= n;
+  }
+  /**
+   * 更新所有标注（每帧调用）
+   */
+  update() {
+    this.annotations.forEach((e) => {
+      this.updateAnnotationPosition(e);
+    });
+  }
+  /**
+   * 处理标注点击
+   */
+  handleClickAnnotation(e) {
+    if (e.config.type === d.LINK) {
+      const t = e.config;
+      window.open(t.url, "_blank");
+    }
+    this.onClickAnnotation && this.onClickAnnotation(e);
+  }
+  /**
+   * 处理标注悬停
+   */
+  handleHoverAnnotation(e) {
+    this.onHoverAnnotation && this.onHoverAnnotation(e);
+  }
+  /**
+   * 设置点击回调
+   */
+  setOnClickAnnotation(e) {
+    this.onClickAnnotation = e;
+  }
+  /**
+   * 设置悬停回调
+   */
+  setOnHoverAnnotation(e) {
+    this.onHoverAnnotation = e;
+  }
+  /**
+   * 移除标注
+   * @param id 标注 ID
+   */
+  removeAnnotation(e) {
+    const t = this.annotations.get(e);
+    t && (t.element.remove(), this.annotations.delete(e));
+  }
+  /**
+   * 清空所有标注
+   */
+  clearAll() {
+    this.annotations.forEach((e) => {
+      e.element.remove();
+    }), this.annotations.clear();
+  }
+  /**
+   * 获取所有标注
+   */
+  getAnnotations() {
+    return Array.from(this.annotations.values());
+  }
+  /**
+   * 获取标注
+   * @param id 标注 ID
+   */
+  getAnnotation(e) {
+    return this.annotations.get(e);
+  }
+  /**
+   * 更新相机引用（当相机发生变化时调用）
+   */
+  updateCamera(e) {
+    this.camera = e, this.worldToScreen.updateCamera(e);
+  }
+  /**
+   * 销毁管理器
+   */
+  dispose() {
+    this.clearAll(), this.annotationContainer.remove(), this.onClickAnnotation = void 0, this.onHoverAnnotation = void 0;
+  }
+  /**
+   * 生成唯一 ID
+   */
+  generateId() {
+    return `annotation-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+}
+class Y {
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * 订阅事件
+   * @param event 事件类型（字符串或枚举）
+   * @param callback 回调函数
+   */
+  on(e, t) {
+    const n = String(e);
+    this.listeners.has(n) || this.listeners.set(n, []), this.listeners.get(n).push(t);
+  }
+  /**
+   * 取消订阅事件
+   * @param event 事件类型
+   * @param callback 要移除的回调函数
+   */
+  off(e, t) {
+    const n = String(e), o = this.listeners.get(n);
+    if (o) {
+      const a = o.indexOf(t);
+      a !== -1 && o.splice(a, 1), o.length === 0 && this.listeners.delete(n);
+    }
+  }
+  /**
+   * 触发事件
+   * @param event 事件类型
+   * @param data 事件数据
+   */
+  trigger(e, t) {
+    const n = String(e), o = this.listeners.get(n);
+    if (o && o.length > 0) {
+      const a = [...o];
+      for (const s of a)
+        try {
+          s(t);
+        } catch (h) {
+          console.error(`EventModule: Error in event handler for "${n}":`, h);
+        }
+    }
+  }
+  /**
+   * 移除某个事件的所有监听器
+   * @param event 事件类型
+   */
+  removeAllListeners(e) {
+    const t = String(e);
+    this.listeners.delete(t);
+  }
+  /**
+   * 清空所有事件监听器
+   */
+  clear() {
+    this.listeners.clear();
+  }
+  /**
+   * 获取某个事件的监听器数量
+   * @param event 事件类型
+   */
+  listenerCount(e) {
+    const t = String(e), n = this.listeners.get(t);
+    return n ? n.length : 0;
+  }
+  /**
+   * 销毁事件模块
+   */
+  dispose() {
+    this.clear();
+  }
+}
+var r = /* @__PURE__ */ ((i) => (i.PanoramaLoadStart = "panorama-load-start", i.PanoramaLoadProgress = "panorama-load-progress", i.PanoramaLoaded = "panorama-loaded", i.PanoramaLoadError = "panorama-load-error", i.AnnotationClick = "annotation-click", i.AnnotationHover = "annotation-hover", i.AnnotationAdd = "annotation-add", i.AnnotationRemove = "annotation-remove", i.ViewAngleChanged = "view-angle-changed", i))(r || {});
+class N {
+  options;
+  // 核心模块（使用 definite assignment assertions）
+  sceneModule;
+  cameraModule;
+  renderModule;
+  controlModule;
+  eventModule;
+  // 功能管理器
+  panoramaLoader;
+  annotationManager;
+  worldToScreen;
+  // 内部状态
+  isInitialized = !1;
+  version = T;
+  localPanoramaResource = null;
+  constructor(e) {
+    this.options = e, this.initialize(e);
+  }
+  /**
+   * 初始化引擎
+   */
+  initialize(e) {
+    const t = {
+      fov: 75,
+      enableZoom: !0,
+      enableRotate: !0,
+      minFov: 30,
+      maxFov: 90,
+      sphereRadius: 500,
+      rotateSpeed: 0.35,
+      zoomSpeed: 0.8,
+      enableDamping: !0,
+      dampingFactor: 0.08,
+      ...e
+    }, n = document.getElementById(t.containerId);
+    if (!n)
+      throw new Error(`Container with id "${t.containerId}" not found`);
+    try {
+      this.eventModule = new Y(), this.sceneModule = new V(t.sphereRadius), this.cameraModule = new K(
+        n,
+        t.fov,
+        t.minFov,
+        t.maxFov
+      ), this.renderModule = new O(n, !0), this.controlModule = new U(
+        this.cameraModule,
+        this.renderModule.getDomElement()
+      );
+      const o = this.controlModule.getControls();
+      o.enableZoom = t.enableZoom, o.enableRotate = t.enableRotate, o.setRotateSpeed(t.rotateSpeed), o.setZoomSpeed(t.zoomSpeed), o.setEnableDamping(t.enableDamping), o.setDampingFactor(t.dampingFactor), o.setZoomLimits(t.minFov, t.maxFov), o.setOnViewAngleChange((a, s) => {
+        this.eventModule.trigger(r.ViewAngleChanged, { theta: a, phi: s });
+      }), this.panoramaLoader = new Z(), this.worldToScreen = new w(
+        this.cameraModule.getCamera(),
+        this.renderModule.getRenderer(),
+        this.sceneModule.getScene()
+      ), this.annotationManager = new W(
+        n,
+        this.cameraModule.getCamera(),
+        this.renderModule.getRenderer(),
+        t.sphereRadius
+      ), this.annotationManager.setOnClickAnnotation((a) => {
+        this.eventModule.trigger(r.AnnotationClick, {
+          id: a.id,
+          config: a.config,
+          metadata: a.config.metadata
+        });
+      }), this.annotationManager.setOnHoverAnnotation((a) => {
+        this.eventModule.trigger(r.AnnotationHover, {
+          annotation: a ? {
+            id: a.id,
+            config: a.config,
+            metadata: a.config.metadata
+          } : null
+        });
+      }), this.setupRenderLoop(), this.isInitialized = !0, console.log("EngineKernel720: Initialized successfully");
+    } catch (o) {
+      throw console.error("EngineKernel720: Initialization failed", o), o;
+    }
+  }
+  /**
+   * 设置渲染循环
+   */
+  setupRenderLoop() {
+    this.renderModule.setOnBeforeRender(() => {
+      this.controlModule.update(), this.annotationManager.update();
+    }), this.renderModule.startRenderLoop(
+      this.sceneModule.getScene(),
+      this.cameraModule.getCamera()
+    );
+  }
+  // --- 全景图加载 ---
+  /**
+   * 加载全景图
+   * @param imageUrl 全景图 URL（png, jpg）
+   */
+  async loadPanorama(e) {
+    this.checkInitialized(), this.eventModule.trigger(r.PanoramaLoadStart, { url: e });
+    try {
+      this.panoramaLoader.setOnProgress((n) => {
+        this.eventModule.trigger(r.PanoramaLoadProgress, {
+          url: e,
+          progress: n
+        });
+      });
+      const t = await this.panoramaLoader.loadTexture(e);
+      this.sceneModule.updatePanoramaTexture(t), this.eventModule.trigger(r.PanoramaLoaded, {
+        url: e,
+        progress: 100
+      }), console.log("EngineKernel720: Panorama loaded successfully");
+    } catch (t) {
+      throw console.error("EngineKernel720: Failed to load panorama", t), this.eventModule.trigger(r.PanoramaLoadError, {
+        url: e,
+        error: t
+      }), t;
+    }
+  }
+  async loadPanoramaFile(e) {
+    this.checkInitialized(), this.revokeLocalPanoramaResource();
+    const t = z(e);
+    this.localPanoramaResource = t;
+    try {
+      await this.loadPanorama(t.url);
+    } catch (n) {
+      throw this.revokeLocalPanoramaResource(), n;
+    }
+  }
+  async loadModelFile(e) {
+    if (e.length === 0)
+      throw new Error("EngineKernel720: no file selected");
+    await this.loadPanoramaFile(e[0]);
+  }
+  /**
+   * 通过 viewToken 解析全景资源地址，再复用现有全景加载逻辑。
+   */
+  async loadPanoramaByViewToken(e) {
+    const t = await _(
+      this.options,
+      e,
+      "720"
+    );
+    if (t.assetCategory === "composite_model" && t.urls.length > 1)
+      throw new Error("EngineKernel720: composite_model viewToken is not supported");
+    await this.loadPanorama(t.url);
+  }
+  /**
+   * 预加载多个全景图
+   * @param urls 全景图 URL 数组
+   */
+  async preloadPanoramas(e) {
+    this.checkInitialized();
+    try {
+      await this.panoramaLoader.preloadPanoramas(e), console.log(`EngineKernel720: Preloaded ${e.length} panoramas`);
+    } catch (t) {
+      throw console.error("EngineKernel720: Failed to preload panoramas", t), t;
+    }
+  }
+  // --- 标注管理 ---
+  /**
+   * 添加标注
+   * @param config 标注配置
+   * @returns 标注 ID
+   */
+  addAnnotation(e) {
+    this.checkInitialized();
+    const t = this.annotationManager.addAnnotation(e);
+    return this.eventModule.trigger(r.AnnotationAdd, { id: t, config: e }), t;
+  }
+  /**
+   * 批量添加标注
+   * @param configs 标注配置数组
+   * @returns 标注 ID 数组
+   */
+  addAnnotations(e) {
+    return this.checkInitialized(), e.map((t) => this.addAnnotation(t));
+  }
+  /**
+   * 移除标注
+   * @param id 标注 ID
+   */
+  removeAnnotation(e) {
+    this.checkInitialized(), this.annotationManager.removeAnnotation(e), this.eventModule.trigger(r.AnnotationRemove, { id: e });
+  }
+  /**
+   * 清空所有标注
+   */
+  clearAnnotations() {
+    this.checkInitialized(), this.annotationManager.clearAll();
+  }
+  /**
+   * 获取所有标注
+   */
+  getAnnotations() {
+    return this.checkInitialized(), this.annotationManager.getAnnotations();
+  }
+  /**
+   * 更新交互参数（旋转/缩放/阻尼等）
+   */
+  updateInteractionOptions(e) {
+    this.checkInitialized(), this.controlModule.updateInteractionOptions(e);
+  }
+  /**
+   * 根据屏幕坐标拾取全景球面坐标
+   */
+  pickPanoramaPoint(e, t) {
+    this.checkInitialized();
+    const o = this.renderModule.getRenderer().domElement, a = o.clientWidth, s = o.clientHeight;
+    if (a === 0 || s === 0)
+      return null;
+    const h = new D(
+      e / a * 2 - 1,
+      -(t / s * 2 - 1)
+    ), l = this.cameraModule.getCamera(), c = new p(h.x, h.y, 0.5);
+    c.unproject(l), c.sub(l.position).normalize();
+    const g = this.sceneModule.getSphereRadius(), u = l.position.clone().add(c.multiplyScalar(g)), M = C.cartesianToSpherical(u.x, u.y, u.z);
+    return {
+      theta: M.theta,
+      phi: M.phi,
+      radius: g
+    };
+  }
+  // --- 视角控制 ---
+  /**
+   * 设置视角（通过经纬度）
+   * @param theta 水平角度（弧度）
+   * @param phi 垂直角度（弧度）
+   * @param animate 是否动画过渡（暂未实现）
+   */
+  lookAt(e, t, n) {
+    this.checkInitialized(), n && console.warn("EngineKernel720: Animated lookAt not implemented yet"), this.controlModule.lookAt(e, t);
+  }
+  /**
+   * 获取当前视角
+   */
+  getViewAngle() {
+    return this.checkInitialized(), this.controlModule.getViewAngle();
+  }
+  /**
+   * 设置 FOV
+   * @param fov 视野角度（30-90）
+   */
+  setFov(e) {
+    this.checkInitialized(), this.cameraModule.setFov(e);
+  }
+  /**
+   * 获取当前 FOV
+   */
+  getFov() {
+    return this.checkInitialized(), this.cameraModule.getFov();
+  }
+  // --- 事件监听 ---
+  /**
+   * 监听事件
+   * @param event 事件类型
+   * @param callback 回调函数
+   */
+  on(e, t) {
+    this.checkInitialized(), this.eventModule.on(e, t);
+  }
+  /**
+   * 取消监听
+   * @param event 事件类型
+   * @param callback 回调函数
+   */
+  off(e, t) {
+    this.checkInitialized(), this.eventModule.off(e, t);
+  }
+  // --- 生命周期 ---
+  /**
+   * 调整尺寸
+   * @param width 容器宽度（可选，默认使用容器尺寸）
+   * @param height 容器高度（可选，默认使用容器尺寸）
+   */
+  resize(e, t) {
+    this.checkInitialized();
+    const n = e ?? this.renderModule.getRenderer().domElement.clientWidth, o = t ?? this.renderModule.getRenderer().domElement.clientHeight;
+    this.renderModule.resize(n, o), this.cameraModule.updateAspectRatio(n, o), console.log("EngineKernel720: Resized to", n, "x", o);
+  }
+  /**
+   * 暂停渲染
+   */
+  pauseRendering() {
+    this.checkInitialized(), this.renderModule.pauseRendering();
+  }
+  /**
+   * 恢复渲染
+   */
+  resumeRendering() {
+    this.checkInitialized(), this.renderModule.resumeRendering(
+      this.sceneModule.getScene(),
+      this.cameraModule.getCamera()
+    );
+  }
+  /**
+   * 检查渲染是否暂停
+   */
+  isRenderingPausedState() {
+    return this.isInitialized ? this.renderModule.isRenderingPausedState() : !0;
+  }
+  /**
+   * 获取版本
+   */
+  getVersion() {
+    return this.version;
+  }
+  /**
+   * 销毁引擎
+   */
+  dispose() {
+    if (this.isInitialized)
+      try {
+        this.renderModule.pauseRendering(), this.annotationManager.dispose(), this.panoramaLoader.dispose(), this.controlModule.dispose(), this.cameraModule.dispose(), this.renderModule.dispose(), this.sceneModule.dispose(), this.eventModule.dispose(), this.isInitialized = !1, this.revokeLocalPanoramaResource(), console.log("EngineKernel720: Disposed successfully");
+      } catch (e) {
+        console.error("EngineKernel720: Error during dispose", e);
+      }
+  }
+  /**
+   * 检查是否已初始化
+   */
+  checkInitialized() {
+    if (!this.isInitialized)
+      throw new Error("EngineKernel720: Not initialized");
+  }
+  revokeLocalPanoramaResource() {
+    this.localPanoramaResource?.revoke(), this.localPanoramaResource = null;
+  }
+}
+export {
+  N as EngineKernel720
+};