gasInjection-project/src/views/vent/monitorManager/gateMonitor/gate.threejs.ts

import * as THREE from 'three';
import UseThree from '../../../../utils/threejs/useThree';
// import Fm1 from './gate.threejs.yy';
// import Fm3 from './gate.threejs.qd';
import FmXR from './gate.threejs.xr';
// import Fm2 from './gate.threejs.three';
// import FmTwoSs from './gate.threejs.two.ss';
// import FmThreeTl from './gate.threejs.three.tl';
// import FmDc from './gate.threejs.window';
// import FmDcHJG from './gate.threejs.window.hjg';
// import FmDcZHQ from './gate.threejs.window.zhq';
// import FmHsw3 from './gate.threejs.three.hsw';
// import FmYjXr from './gate.threejs.two.yj'; // 窑街行人
// import FmYj from './gate.threejs.yj'; // 窑街
// import FmSp1 from './gate.threejs.one.sp';
import { animateCamera } from '/@/utils/threejs/util';
import useEvent from '../../../../utils/threejs/useEvent';
import { getDictItemsByCode } from '/@/utils/dict';
import { useGlobSetting } from '/@/hooks/setting';

// 模型对象、 文字对象
let model,
  fm1, //液压风门
  fm2, //三道风门收缩
  fm3, //气动风门
  fmXr: FmXR, //行人风门
  fmTwoSs, //
  fmThreeTl, // 三道推拉
  fmWindowHjg, // 带风窗
  fmWindowZhq, // 带风窗 沼和泉
  fmWindow, // 带风窗
  fmHsw3, // 海石湾拱形三道风门
  fmYjXr, // 窑街拱形行人风门
  fmYj, // 窑街拱形行车风门
  fmSp1, // 沙坪一道风门
  fmDcBd, // 带风窗
  fmSsl, // 思山岭双道蓝色风门
  fm_fc_ssl, // 带风窗
  group: THREE.Object3D,
  fmType = '',
  windowType = 'singleWindow';

const rotationParam = {
  frontLeftDeg0: 0, // 前门初始
  frontLeftDeg1: 0, // 前门目标
  backLeftDeg0: 0, // 后门初始
  backLeftDeg1: 0, // 后门目标
  frontRightDeg0: 0, // 前门初始
  frontRightDeg1: 0, // 前门目标
  backRightDeg0: 0, // 后门初始
  backRightDeg1: 0, // 后门目标
  frontDeg0: 0,
  frontDeg1: 0,
  backDeg0: 0,
  backDeg1: 0,
};

const { mouseDownFn } = useEvent();

// 初始化左右摇摆动画
const startAnimation = () => {
  if (!model) return;
  // 定义鼠标点击事件
  model.canvasContainer?.addEventListener('mousedown', mouseEvent.bind(null));
  model.canvasContainer?.addEventListener('pointerup', (event) => {
    event.stopPropagation();
    // 单道、 双道
    if (fmType === 'fm1') {
      fm1?.mouseUpModel.call(fm1);
    } else if (fmType === 'fm2') {
      fm2?.mouseUpModel.call(fm2);
    } else if (fmType === 'fmThreeTl') {
      fmThreeTl?.mouseUpModel.call(fmThreeTl);
    } else if (fmType === 'fm3') {
      fm3?.mouseUpModel.call(fm3);
    } else if (fmType === 'fmXr') {
      fmXr?.mouseUpModel.call(fmXr);
    } else if (fmType === 'fmTwoSs') {
      fmTwoSs?.mouseUpModel.call(fmTwoSs);
    } else if (fmType === 'fmWindow') {
      fmWindow.mouseUpModel.call(fmWindow);
    } else if (fmType === 'fmWindowHjg') {
      fmWindowHjg.mouseUpModel();
    } else if (fmType === 'fmWindowZhq') {
      fmWindowZhq.mouseUpModel();
    } else if (fmType === 'fmHsw3') {
      fmHsw3.mouseUpModel();
    } else if (fmType === 'fmYjXr') {
      fmYjXr.mouseUpModel();
    } else if (fmType === 'fmYj') {
      fmYj.mouseUpModel();
    } else if (fmType === 'fmSp1') {
      fmSp1.mouseUpModel();
    } else if (fmType === 'fm_fc_bd') {
      fmDcBd.mouseUpModel();
    } else if (fmType === 'fmSsl') {
      fmSsl.mouseUpModel();
    } else if (fmType === 'fm_fc_ssl') {
      fm_fc_ssl.mouseUpModel();
    }
  });
};

// 鼠标点击、松开事件
const mouseEvent = (event) => {
  if (!model) return;
  if (event.button == 0) {
    mouseDownFn(model, group, event, (intersects) => {
      if (fmType === 'fm1' && fm1) {
        fm1?.mousedownModel.call(fm1, intersects);
      } else if (fmType === 'fm2' && fm2) {
        fm2?.mousedownModel.call(fm2, intersects);
      } else if (fmType === 'fm3' && fm3) {
        fm3?.mousedownModel.call(fm3, intersects);
      } else if (fmType === 'fmXr' && fmXr) {
        fmXr?.mousedownModel.call(fmXr, intersects);
      } else if (fmType === 'fmTwoSs' && fmTwoSs) {
        fmTwoSs?.mousedownModel.call(fmTwoSs, intersects);
      } else if (fmType === 'fmThreeTl') {
        fmThreeTl?.mousedownModel.call(fmThreeTl, intersects);
      } else if (fmType === 'fmWindow' && fmWindow) {
        fmWindow.mousedownModel.call(fmWindow, intersects);
      } else if (fmType === 'fmWindowHjg' && fmWindowHjg) {
        fmWindowHjg.mousedownModel(intersects);
      } else if (fmType === 'fmWindowZhq' && fmWindowZhq) {
        fmWindowZhq.mousedownModel(intersects);
      } else if (fmType === 'fmHsw3' && fmHsw3) {
        fmHsw3.mousedownModel(intersects);
      } else if (fmType === 'fmYjXr' && fmYjXr) {
        fmYjXr.mousedownModel(intersects);
      } else if (fmType === 'fmYj' && fmYj) {
        fmYj.mousedownModel(intersects);
      } else if (fmType === 'fmSp1') {
        fmSp1.mousedownModel(intersects);
      } else if (fmType === 'fm_fc_bd' && fmDcBd) {
        fmDcBd.mousedownModel(intersects);
      } else if (fmType === 'fmSsl' && fmSsl) {
        fmSsl.mousedownModel(intersects);
      } else if (fmType === 'fm_fc_ssl' && fm_fc_ssl) {
        fm_fc_ssl.mousedownModel(intersects);
      }
    });
    console.log('摄像头控制信息', model.orbitControls, model.camera);
  }
};

export const addMonitorText = (selectData) => {
  if (!model) return;
  if (fmType === 'fm1' && fm1) {
    return fm1?.addMonitorText.call(fm1, selectData);
  } else if (fmType === 'fm2' && fm2) {
    return fm2?.addMonitorText.call(fm2, selectData);
  } else if (fmType === 'fm3' && fm3) {
    return fm3?.addMonitorText.call(fm3, selectData);
  } else if (fmType === 'fmXr' && fmXr) {
    return fmXr?.addMonitorText.call(fmXr, selectData);
  } else if (fmType === 'fmTwoSs' && fmTwoSs) {
    return fmTwoSs?.addMonitorText.call(fmTwoSs, selectData);
  } else if (fmType === 'fmThreeTl') {
    fmThreeTl?.addMonitorText.call(fmThreeTl, selectData);
  } else if (fmType === 'fmWindow' && fmWindow) {
    fmWindow.addMonitorText.call(fmWindow, selectData);
  } else if (fmType === 'fmWindowHjg' && fmWindowHjg) {
    fmWindowHjg.addMonitorText(selectData);
  } else if (fmType === 'fmWindowZhq' && fmWindowZhq) {
    fmWindowZhq.addMonitorText(selectData);
  } else if (fmType === 'fmHsw3' && fmHsw3) {
    fmHsw3.addMonitorText(selectData);
  } else if (fmType === 'fmYjXr' && fmYjXr) {
    fmYjXr.addMonitorText(selectData);
  } else if (fmType === 'fmYj' && fmYj) {
    fmYj.addMonitorText(selectData);
  } else if (fmType === 'fmSp1' && fmSp1) {
    fmSp1.addMonitorText(selectData);
  } else if (fmType === 'fm_fc_bd' && fmDcBd) {
    return fmDcBd.addMonitorText(selectData);
  } else if (fmType === 'fmSsl' && fmSsl) {
    return fmSsl.addMonitorText.call(fmSsl, selectData);
  } else if (fmType === 'fm_fc_ssl' && fm_fc_ssl) {
    return fm_fc_ssl.addMonitorText.call(fm_fc_ssl, selectData);
  }
};

export const deviceDetailCard = () => {
  if (!model) return;
  if (fmType === 'fm1') {
    return fm1?.deviceDetailCard.call(fm1);
  } else if (fmType === 'fm3') {
    return fm3?.deviceDetailCard.call(fm3);
  } else if (fmType === 'fmXr') {
    return fmXr?.deviceDetailCard.call(fmXr);
  } else {
    // return fm2.addMonitorText.call(fm2);
  }
};

export const play = (handlerState, flag?) => {
  if (!model) return;
  if (fmType === 'fm1' && fm1) {
    return fm1.play.call(fm1, handlerState, flag);
  } else if (fmType === 'fm2' && fm2) {
    return fm2.play.call(fm2, handlerState, flag);
  } else if (fmType === 'fmWindow' && fmWindow) {
    return fmWindow.play.call(fmWindow, handlerState, flag);
  } else if (fmType === 'fmWindowHjg' && fmWindowHjg) {
    return fmWindowHjg.play.call(fmWindowHjg, handlerState, flag);
  } else if (fmType === 'fmWindowZhq' && fmWindowZhq) {
    return fmWindowZhq.play.call(fmWindowZhq, handlerState, flag);
  } else if (fmType === 'fm3' && fm3) {
    return fm3.play.call(fm3, handlerState, flag);
  } else if (fmType === 'fmXr' && fmXr) {
    return fmXr.play.call(fmXr, handlerState, flag);
  } else if (fmType === 'fmTwoSs' && fmTwoSs) {
    return fmTwoSs.play.call(fmTwoSs, handlerState, flag);
  } else if (fmType === 'fmThreeTl') {
    return fmThreeTl?.play.call(fmThreeTl, handlerState, flag);
  } else if (fmType === 'fmHsw3') {
    return fmHsw3?.play.call(fmHsw3, handlerState, flag);
  } else if (fmType === 'fmYjXr') {
    return fmYjXr?.play.call(fmYjXr, handlerState, flag);
  } else if (fmType === 'fmYj') {
    return fmYj?.play.call(fmYj, handlerState, flag);
  } else if (fmType === 'fmSp1') {
    return fmSp1?.play(handlerState, flag);
  } else if (fmType === 'fm_fc_bd' && fmDcBd) {
    return fmDcBd.play.call(fmDcBd, handlerState, flag);
  } else if (fmType === 'fmSsl' && fmSsl) {
    return fmSsl.play.call(fmSsl, handlerState, flag);
  } else if (fmType === 'fm_fc_ssl' && fm_fc_ssl) {
    return fm_fc_ssl.play.call(fm_fc_ssl, handlerState, flag);
  }
};

// export const playWindow = (rotationParam, flag) => {
//   if (fmType === 'fmWindow' && fmWindow) {
//     return fmWindow.playWindow.call(fmWindow, rotationParam, flag);
//   } else if (fmType === 'fmWindowHjg' && fmWindowHjg) {
//     return fmWindowHjg.playWindow.call(fmWindowHjg, rotationParam, flag);
//   }
// };

export function computePlay(data, maxarea, isFirst = false) {
  if (!model) return;
  // 前门后窗  rearPresentValue1
  // 前门前窗 frontPresentValue1
  // 后门后窗 rearPresentValue2
  // 后门前窗 frontPresentValue2
  // data['frontArea'] = 70;
  // data['rearArea'] = 40;

  if (
    (fmType === 'fmWindowHjg' || fmType === 'fmWindowZhq') &&
    (data.rearPresentValue1 || data.frontPresentValue1 || data.rearPresentValue2 || data.frontPresentValue2)
  ) {
    maxarea = 90;
    rotationParam.frontLeftDeg0 = (90 / maxarea) * Number(isFirst ? 0 : data.frontPresentValue1);
    rotationParam.frontRightDeg0 = (90 / maxarea) * Number(isFirst ? 0 : data.rearPresentValue1);
    rotationParam.frontLeftDeg1 = (90 / maxarea) * Number(data.frontPresentValue1) || 0;
    rotationParam.frontRightDeg1 = (90 / maxarea) * Number(data.rearPresentValue1) || 0;
    rotationParam.backLeftDeg0 = (90 / maxarea) * Number(isFirst ? 0 : data.frontPresentValue2);
    rotationParam.backRightDeg0 = (90 / maxarea) * Number(isFirst ? 0 : data.rearPresentValue2);
    rotationParam.backLeftDeg1 = (90 / maxarea) * Number(data.frontPresentValue2) || 0;
    rotationParam.backRightDeg1 = (90 / maxarea) * Number(data.rearPresentValue2) || 0;

    rotationParam.backLeftDeg1 = 90;
    if (fmType === 'fmWindowHjg') {
      fmWindowHjg.playWindow(rotationParam, 1);
      fmWindowHjg.playWindow(rotationParam, 2);
      fmWindowHjg.playWindow(rotationParam, 3);
      fmWindowHjg.playWindow(rotationParam, 4);
    } else {
      fmWindowZhq.playWindow(rotationParam, 1);
      fmWindowZhq.playWindow(rotationParam, 2);
      fmWindowZhq.playWindow(rotationParam, 3);
      fmWindowZhq.playWindow(rotationParam, 4);
    }
  } else if (fmType === 'fmWindow' && data.frontPresentValue1 && data.frontPresentValue2 && data.rearPresentValue1 && data.rearPresentValue2) {
    maxarea = 90;
    rotationParam.frontLeftDeg0 = (90 / maxarea) * Number(isFirst ? 0 : data.frontPresentValue1);
    rotationParam.frontRightDeg0 = (90 / maxarea) * Number(isFirst ? 0 : data.frontPresentValue2);
    rotationParam.frontLeftDeg1 = (90 / maxarea) * Number(data.frontPresentValue1) || 0;
    rotationParam.frontRightDeg1 = (90 / maxarea) * Number(data.frontPresentValue2) || 0;
    rotationParam.backLeftDeg0 = (90 / maxarea) * Number(isFirst ? 0 : data.rearPresentValue1);
    rotationParam.backRightDeg0 = (90 / maxarea) * Number(isFirst ? 0 : data.rearPresentValue2);
    rotationParam.backLeftDeg1 = (90 / maxarea) * Number(data.rearPresentValue1) || 0;
    rotationParam.backRightDeg1 = (90 / maxarea) * Number(data.rearPresentValue2) || 0;
    fmWindow.playWindow(rotationParam, 1);
    fmWindow.playWindow(rotationParam, 2);
    fmWindow.playWindow(rotationParam, 3);
    fmWindow.playWindow(rotationParam, 4);
  } else if (fmType === 'fm_fc_bd' || fmType === 'fm_fc_ssl') {
    maxarea = 90;
    rotationParam.frontDeg0 = (90 / maxarea) * Number(isFirst ? 0 : data.forntArea);
    rotationParam.backDeg0 = (90 / maxarea) * Number(isFirst ? 0 : data.rearArea);
    rotationParam.frontDeg1 = (90 / maxarea) * Number(data.forntArea) || 0;
    rotationParam.backDeg1 = (90 / maxarea) * Number(data.rearArea) || 0;
    // rotationParam.frontDeg1 = 50;
    // rotationParam.backDeg1 = 80;
    let fmDc;
    if (fmType === 'fm_fc_bd') {
      fmDc = fmDcBd;
    } else if (fmType === 'fm_fc_ssl') {
      fmDc = fm_fc_ssl;
    }

    fmDc.playWindow(rotationParam, 1);
    fmDc.playWindow(rotationParam, 2);
  }
}

// 切换风门类型
export const setModelType = (type) => {
  if (!model) return Promise.reject('model is null');
  fmType = type;
  return new Promise((resolve) => {
    // 暂停风门1动画
    if (fmType === 'fm1' && fm1 && fm1.group) {
      if (fm1.clipActionArr.frontDoor && fm1.clipActionArr.backDoor) {
        fm1.clipActionArr.frontDoor.reset();
        fm1.clipActionArr.frontDoor.time = 0.5;
        fm1.clipActionArr.backDoor.reset();
        fm1.clipActionArr.backDoor.time = 0.5;
        fm1.clipActionArr.frontDoor.stop();
        fm1.clipActionArr.backDoor.stop();
      }

      if (fm1.frontDamperOpenMesh) fm1.frontDamperOpenMesh.visible = false;
      if (fm1.frontDamperClosedMesh) fm1.frontDamperClosedMesh.visible = true;
      if (fm1.backDamperOpenMesh) fm1.backDamperOpenMesh.visible = false;
      if (fm1.backDamperClosedMesh) fm1.backDamperClosedMesh.visible = true;
      model.scene.remove(group);
      model.startAnimation = fm1.render.bind(fm1);
      group = fm1.group;
      group.rotation.y = 0;
      const oldCameraPosition = { x: -1000, y: 100, z: 500 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fm1.group);
        await animateCamera(
          oldCameraPosition,
          { x: 0, y: 0, z: 0 },
          { x: 50.99, y: 69.32, z: 93.61 },
          { x: -10.04, y: -14.38, z: -31.4 },
          model,
          0.8
        );
      }, 300);
    } else if (fmType === 'fm2' && fm2 && fm2.group) {
      if (fm2.clipActionArr.frontDoor && fm2.clipActionArr.backDoor) {
        fm2.clipActionArr.frontDoor.reset();
        fm2.clipActionArr.frontDoor.time = 0.5;
        fm2.clipActionArr.backDoor.reset();
        fm2.clipActionArr.backDoor.time = 0.5;

        fm2.clipActionArr.centerDoor.reset();
        fm2.clipActionArr.centerDoor.time = 0.5;

        fm2.clipActionArr.frontDoor.stop();
        fm2.clipActionArr.backDoor.stop();
        fm2.clipActionArr.centerDoor.stop();
      }

      // 显示单道风窗
      model.startAnimation = fm2.render.bind(fm2);
      model.scene.remove(group);
      group = fm2.group;
      const oldCameraPosition = { x: -761, y: 569, z: 871 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fm2.group);
        const position = { x: -2.28, y: -0.91, z: -5.68 };

        await animateCamera(
          oldCameraPosition,
          { x: -2.27, y: -0.91, z: -5.67 },
          { x: 66.257, y: 57.539, z: 94.313 },
          { x: position.x, y: position.y, z: position.z },
          model,
          0.6
        );
      }, 300);
    } else if (fmType === 'fmWindow' && fmWindow && fmWindow.group) {
      if (fmWindow.clipActionArr.frontDoor && fmWindow.clipActionArr.backDoor) {
        fmWindow.clipActionArr.frontDoor.reset();
        fmWindow.clipActionArr.frontDoor.time = 0.5;
        fmWindow.clipActionArr.backDoor.reset();
        fmWindow.clipActionArr.backDoor.time = 0.5;

        fmWindow.clipActionArr.frontDoor.stop();
        fmWindow.clipActionArr.backDoor.stop();
      }

      model.startAnimation = fmWindow.render.bind(fmWindow);
      model.scene.remove(group);
      group = fmWindow.group;
      const oldCameraPosition = { x: -761, y: 569, z: 871 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fmWindow.group);
        const position = { x: -2.28, y: -0.91, z: -5.68 };

        await animateCamera(
          oldCameraPosition,
          { x: -2.27, y: -0.91, z: -5.67 },
          { x: 66.257, y: 57.539, z: 94.313 },
          { x: position.x, y: position.y, z: position.z },
          model,
          0.6
        );
      }, 300);
    } else if (fmType === 'fmWindowHjg' && fmWindowHjg && fmWindowHjg.group) {
      if (fmWindowHjg.clipActionArr.frontDoor && fmWindowHjg.clipActionArr.backDoor) {
        fmWindowHjg.clipActionArr.frontDoor.reset();
        fmWindowHjg.clipActionArr.frontDoor.time = 0.5;
        fmWindowHjg.clipActionArr.backDoor.reset();
        fmWindowHjg.clipActionArr.backDoor.time = 0.5;

        fmWindowHjg.clipActionArr.frontDoor.stop();
        fmWindowHjg.clipActionArr.backDoor.stop();
      }

      model.startAnimation = fmWindowHjg.render.bind(fmWindowHjg);
      model.scene.remove(group);
      group = fmWindowHjg.group;
      const oldCameraPosition = { x: -761, y: 569, z: 871 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fmWindowHjg.group);
        const position = { x: -2.28, y: -0.91, z: -5.68 };

        await animateCamera(
          oldCameraPosition,
          { x: -2.27, y: -0.91, z: -5.67 },
          { x: 66.257, y: 57.539, z: 94.313 },
          { x: position.x, y: position.y, z: position.z },
          model,
          0.6
        );
      }, 300);
    } else if (fmType === 'fmWindowZhq' && fmWindowZhq && fmWindowZhq.group) {
      if (fmWindowZhq.clipActionArr.frontDoor && fmWindowZhq.clipActionArr.backDoor) {
        fmWindowZhq.clipActionArr.frontDoor.reset();
        fmWindowZhq.clipActionArr.frontDoor.time = 0.5;
        fmWindowZhq.clipActionArr.backDoor.reset();
        fmWindowZhq.clipActionArr.backDoor.time = 0.5;

        fmWindowZhq.clipActionArr.frontDoor.stop();
        fmWindowZhq.clipActionArr.backDoor.stop();
      }

      model.startAnimation = fmWindowZhq.render.bind(fmWindowZhq);
      model.scene.remove(group);
      group = fmWindowZhq.group;
      const oldCameraPosition = { x: -761, y: 569, z: 871 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fmWindowZhq.group);
        const position = { x: -2.28, y: -0.91, z: -5.68 };

        await animateCamera(
          oldCameraPosition,
          { x: -2.27, y: -0.91, z: -5.67 },
          { x: 66.257, y: 57.539, z: 94.313 },
          { x: position.x, y: position.y, z: position.z },
          model,
          0.6
        );
      }, 300);
    } else if (fmType === 'fm_fc_bd' && fmDcBd && fmDcBd.group) {
      if (fmDcBd.frontClipAction) {
        fmDcBd.frontClipAction.reset();
        fmDcBd.frontClipAction.time = 0.5;
        fmDcBd.frontClipAction.stop();
      }

      model.startAnimation = fmDcBd.render.bind(fmDcBd);
      model.scene.remove(group);
      group = fmDcBd.group;
      const oldCameraPosition = { x: -761, y: 569, z: 871 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fmDcBd.group);
        const position = { x: -2.28, y: -0.91, z: -5.68 };

        await animateCamera(
          oldCameraPosition,
          { x: -2.27, y: -0.91, z: -5.67 },
          { x: 66.257, y: 57.539, z: 94.313 },
          { x: position.x, y: position.y, z: position.z },
          model,
          0.6
        );
      }, 300);
    } else if (fmType === 'fm_fc_ssl' && fm_fc_ssl && fm_fc_ssl.group) {
      if (fm_fc_ssl.frontClipAction) {
        fm_fc_ssl.frontClipAction.reset();
        fm_fc_ssl.frontClipAction.time = 0.5;
        fm_fc_ssl.frontClipAction.stop();
      }

      model.startAnimation = fm_fc_ssl.render.bind(fm_fc_ssl);
      model.scene.remove(group);
      group = fm_fc_ssl.group;
      const oldCameraPosition = { x: -761, y: 569, z: 871 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fm_fc_ssl.group);
        const position = { x: -2.28, y: -0.91, z: -5.68 };

        await animateCamera(
          oldCameraPosition,
          { x: -2.27, y: -0.91, z: -5.67 },
          { x: 66.257, y: 57.539, z: 94.313 },
          { x: position.x, y: position.y, z: position.z },
          model,
          0.6
        );
      }, 300);
    } else if (fmType === 'fmThreeTl' && fmThreeTl && fmThreeTl.group) {
      if (fmThreeTl.clipActionArr.frontDoor && fmThreeTl.clipActionArr.backDoor && fmThreeTl.clipActionArr.centerDoor) {
        fmThreeTl.clipActionArr.frontDoor.reset();
        fmThreeTl.clipActionArr.frontDoor.time = 0.5;
        fmThreeTl.clipActionArr.backDoor.reset();
        fmThreeTl.clipActionArr.backDoor.time = 0.5;
        fmThreeTl.clipActionArr.centerDoor.reset();
        fmThreeTl.clipActionArr.centerDoor.time = 0.5;

        fmThreeTl.clipActionArr.frontDoor.stop();
        fmThreeTl.clipActionArr.backDoor.stop();
        fmThreeTl.clipActionArr.centerDoor.stop();
      }
      if (fmThreeTl.frontDamperOpenMesh) fmThreeTl.frontDamperOpenMesh.visible = false;
      if (fmThreeTl.frontDamperClosedMesh) fmThreeTl.frontDamperClosedMesh.visible = true;
      if (fmThreeTl.centerDamperOpenMesh) fmThreeTl.centerDamperOpenMesh.visible = false;
      if (fmThreeTl.centerDamperClosedMesh) fmThreeTl.centerDamperClosedMesh.visible = true;
      if (fmThreeTl.backDamperOpenMesh) fmThreeTl.backDamperOpenMesh.visible = false;
      if (fmThreeTl.backDamperClosedMesh) fmThreeTl.backDamperClosedMesh.visible = true;

      // 显示单道风窗
      model.startAnimation = fmThreeTl.render.bind(fmThreeTl);
      model.scene.remove(group);
      group = fmThreeTl.group;
      const oldCameraPosition = { x: -761, y: 569, z: 871 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fmThreeTl.group);
        const position = { x: 31.873075535732386, y: -3.501715880262631, z: -15.490295891616942 };

        await animateCamera(
          oldCameraPosition,
          { x: -2.27, y: -0.91, z: -5.67 },
          { x: 88.60102093060523, y: 53.89462381404774, z: 109.90762232602137 },
          { x: position.x, y: position.y, z: position.z },
          model,
          0.6
        );
      }, 300);
    } else if (fmType === 'fm3' && fm3 && fm3.group) {
      if (fm3.clipActionArr.frontDoor && fm3.clipActionArr.backDoor) {
        fm3.clipActionArr.frontDoor.reset();
        fm3.clipActionArr.frontDoor.time = 0.5;
        fm3.clipActionArr.backDoor.reset();
        fm3.clipActionArr.backDoor.time = 0.5;
        fm3.clipActionArr.frontDoor.stop();
        fm3.clipActionArr.backDoor.stop();
      }

      if (fm3.frontDamperOpenMesh) fm3.frontDamperOpenMesh.visible = false;
      if (fm3.frontDamperClosedMesh) fm3.frontDamperClosedMesh.visible = true;
      if (fm3.backDamperOpenMesh) fm3.backDamperOpenMesh.visible = false;
      if (fm3.backDamperClosedMesh) fm3.backDamperClosedMesh.visible = true;

      model.scene.remove(group);
      model.startAnimation = fm3.render.bind(fm3);
      group = fm3.group;
      group.rotation.y = 0;
      const oldCameraPosition = { x: -1000, y: 100, z: 500 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fm3.group);
        await animateCamera(
          oldCameraPosition,
          { x: 0, y: 0, z: 0 },
          { x: 50.99, y: 69.32, z: 93.61 },
          { x: -10.04, y: -14.38, z: -31.4 },
          model,
          0.8
        );
      }, 300);
    } else if (fmType === 'fmXr' && fmXr && fmXr.group) {
      if (fmXr.clipActionArr.frontDoor && fmXr.clipActionArr.backDoor) {
        fmXr.clipActionArr.frontDoor.reset();
        fmXr.clipActionArr.frontDoor.time = 0.5;
        fmXr.clipActionArr.backDoor.reset();
        fmXr.clipActionArr.backDoor.time = 0.5;
        fmXr.clipActionArr.frontDoor.stop();
        fmXr.clipActionArr.backDoor.stop();
      }

      if (fmXr.frontDamperOpenMesh) fmXr.frontDamperOpenMesh.visible = false;
      if (fmXr.frontDamperClosedMesh) fmXr.frontDamperClosedMesh.visible = true;
      if (fmXr.backDamperOpenMesh) fmXr.backDamperOpenMesh.visible = false;
      if (fmXr.backDamperClosedMesh) fmXr.backDamperClosedMesh.visible = true;

      model.startAnimation = fmXr.render.bind(fmXr);
      model.scene.remove(group);
      group = fmXr.group;
      group.rotation.y = 0;

      const oldCameraPosition = { x: -1000, y: 100, z: 500 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fmXr.group);
        await animateCamera(
          oldCameraPosition,
          { x: 0, y: 0, z: 0 },
          { x: 50.99, y: 69.32, z: 93.61 },
          { x: -10.04, y: -14.38, z: -31.4 },
          model,
          0.8
        );
      }, 300);
    } else if (fmType === 'fmTwoSs' && fmTwoSs && fmTwoSs.group) {
      if (fmTwoSs.clipActionArr.frontDoor && fmTwoSs.clipActionArr.backDoor) {
        fmTwoSs.clipActionArr.frontDoor.reset();
        fmTwoSs.clipActionArr.frontDoor.time = 0.5;
        fmTwoSs.clipActionArr.backDoor.reset();
        fmTwoSs.clipActionArr.backDoor.time = 0.5;
        fmTwoSs.clipActionArr.frontDoor.stop();
        fmTwoSs.clipActionArr.backDoor.stop();
      }

      if (fmTwoSs.frontDamperOpenMesh) fmTwoSs.frontDamperOpenMesh.visible = false;
      if (fmTwoSs.frontDamperClosedMesh) fmTwoSs.frontDamperClosedMesh.visible = true;
      if (fmTwoSs.backDamperOpenMesh) fmTwoSs.backDamperOpenMesh.visible = false;
      if (fmTwoSs.backDamperClosedMesh) fmTwoSs.backDamperClosedMesh.visible = true;

      model.startAnimation = fmTwoSs.render.bind(fmTwoSs);
      model.scene.remove(group);
      group = fmTwoSs.group;
      group.rotation.y = 0;

      const oldCameraPosition = { x: -1000, y: 100, z: 500 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fmTwoSs.group);
        await animateCamera(
          oldCameraPosition,
          { x: 0, y: 0, z: 0 },
          { x: 50.99, y: 69.32, z: 93.61 },
          { x: -10.04, y: -14.38, z: -31.4 },
          model,
          0.8
        );
      }, 300);
    } else if (fmType === 'fmHsw3' && fmHsw3 && fmHsw3.group) {
      if (fmHsw3.clipActionArr.frontDoor && fmHsw3.clipActionArr.backDoor) {
        fmHsw3.clipActionArr.frontDoor.reset();
        fmHsw3.clipActionArr.frontDoor.time = 0.5;
        fmHsw3.clipActionArr.backDoor.reset();
        fmHsw3.clipActionArr.backDoor.time = 0.5;
        fmHsw3.clipActionArr.frontDoor.stop();
        fmHsw3.clipActionArr.backDoor.stop();
      }

      if (fmHsw3.frontDamperOpenMesh) fmHsw3.frontDamperOpenMesh.visible = false;
      if (fmHsw3.frontDamperClosedMesh) fmHsw3.frontDamperClosedMesh.visible = true;
      if (fmHsw3.backDamperOpenMesh) fmHsw3.backDamperOpenMesh.visible = false;
      if (fmHsw3.backDamperClosedMesh) fmHsw3.backDamperClosedMesh.visible = true;

      model.startAnimation = fmHsw3.render.bind(fmHsw3);
      model.scene.remove(group);
      group = fmHsw3.group;
      group.rotation.y = 0;

      const oldCameraPosition = { x: -1000, y: 100, z: 500 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fmHsw3.group);
        await animateCamera(
          oldCameraPosition,
          { x: 0, y: 0, z: 0 },
          { x: 50.99, y: 69.32, z: 93.61 },
          { x: -10.04, y: -14.38, z: -31.4 },
          model,
          0.8
        );
      }, 300);
    } else if (fmType === 'fmYjXr' && fmYjXr && fmYjXr.group) {
      if (fmYjXr.clipActionArr.frontDoor && fmYjXr.clipActionArr.backDoor) {
        fmYjXr.clipActionArr.frontDoor.reset();
        fmYjXr.clipActionArr.frontDoor.time = 0.5;
        fmYjXr.clipActionArr.backDoor.reset();
        fmYjXr.clipActionArr.backDoor.time = 0.5;
        fmYjXr.clipActionArr.frontDoor.stop();
        fmYjXr.clipActionArr.backDoor.stop();
      }

      if (fmYjXr.frontDamperOpenMesh) fmYjXr.frontDamperOpenMesh.visible = false;
      if (fmYjXr.frontDamperClosedMesh) fmYjXr.frontDamperClosedMesh.visible = true;
      if (fmYjXr.backDamperOpenMesh) fmYjXr.backDamperOpenMesh.visible = false;
      if (fmYjXr.backDamperClosedMesh) fmYjXr.backDamperClosedMesh.visible = true;

      model.startAnimation = fmYjXr.render.bind(fmYjXr);
      model.scene.remove(group);
      group = fmYjXr.group;
      group.rotation.y = 0;

      const oldCameraPosition = { x: -1000, y: 100, z: 500 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fmYjXr.group);
        await animateCamera(
          oldCameraPosition,
          { x: 0, y: 0, z: 0 },
          { x: 50.99, y: 69.32, z: 93.61 },
          { x: -10.04, y: -14.38, z: -31.4 },
          model,
          0.8
        );
      }, 300);
    } else if (fmType === 'fmYj' && fmYj && fmYj.group) {
      if (fmYj.clipActionArr.frontDoor && fmYj.clipActionArr.backDoor) {
        fmYj.clipActionArr.frontDoor.reset();
        fmYj.clipActionArr.frontDoor.time = 0.5;
        fmYj.clipActionArr.backDoor.reset();
        fmYj.clipActionArr.backDoor.time = 0.5;
        fmYj.clipActionArr.frontDoor.stop();
        fmYj.clipActionArr.backDoor.stop();
      }

      if (fmYj.frontDamperOpenMesh) fmYj.frontDamperOpenMesh.visible = false;
      if (fmYj.frontDamperClosedMesh) fmYj.frontDamperClosedMesh.visible = true;
      if (fmYj.backDamperOpenMesh) fmYj.backDamperOpenMesh.visible = false;
      if (fmYj.backDamperClosedMesh) fmYj.backDamperClosedMesh.visible = true;

      model.startAnimation = fmYj.render.bind(fmYj);
      model.scene.remove(group);
      group = fmYj.group;
      group.rotation.y = 0;

      const oldCameraPosition = { x: -1000, y: 100, z: 500 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fmYj.group);
        await animateCamera(
          oldCameraPosition,
          { x: 0, y: 0, z: 0 },
          { x: 50.99, y: 69.32, z: 93.61 },
          { x: -10.04, y: -14.38, z: -31.4 },
          model,
          0.8
        );
      }, 300);
    } else if (fmType === 'fmSp1' && fmSp1 && fmSp1.group) {
      if (fmSp1.clipActionArr.frontDoor) {
        fmSp1.clipActionArr.frontDoor.reset();
        fmSp1.clipActionArr.frontDoor.time = 0.5;
        fmSp1.clipActionArr.frontDoor.stop();
      }

      if (fmSp1.frontDamperOpenMesh) fmSp1.frontDamperOpenMesh.visible = false;
      if (fmSp1.frontDamperClosedMesh) fmSp1.frontDamperClosedMesh.visible = true;

      model.startAnimation = fmSp1.render.bind(fmSp1);
      model.scene.remove(group);
      group = fmSp1.group;
      group.rotation.y = 0;

      const oldCameraPosition = { x: -1000, y: 100, z: 500 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fmSp1.group);
        await animateCamera(
          oldCameraPosition,
          { x: 0, y: 0, z: 0 },
          { x: 50.99, y: 69.32, z: 93.61 },
          { x: -10.04, y: -14.38, z: -31.4 },
          model,
          0.8
        );
      }, 300);
    } else if (fmType === 'fmSsl' && fmSsl && fmSsl.group) {
      if (fmSsl.clipActionArr.frontDoor) {
        fmSsl.clipActionArr.frontDoor.reset();
        fmSsl.clipActionArr.frontDoor.time = 0.5;
        fmSsl.clipActionArr.frontDoor.stop();
      }
      if (fmSsl.clipActionArr.backDoor) {
        fmSsl.clipActionArr.backDoor.reset();
        fmSsl.clipActionArr.backDoor.time = 0.5;
        fmSsl.clipActionArr.backDoor.stop();
      }
      model.startAnimation = fmSsl.render.bind(fmSsl);
      model.scene.remove(group);
      group = fmSsl.group;
      group.rotation.y = 0;

      const oldCameraPosition = { x: -1000, y: 100, z: 500 };
      setTimeout(async () => {
        resolve(null);
        model.scene.add(fmSsl.group);
        await animateCamera(
          oldCameraPosition,
          { x: 0, y: 0, z: 0 },
          { x: 50.99, y: 69.32, z: 93.61 },
          { x: -10.04, y: -14.38, z: -31.4 },
          model,
          0.8
        );
      }, 300);
    }
  });
};

export const initCameraCanvas = async (playerVal1) => {
  if (!model) return;
  if (fmType === 'fm1' && fm1) {
    return await fm1.initCamera.call(fm1, playerVal1);
  } else if (fmType === 'fm2' && fm2) {
    return fm2.initCamera.call(fm2, playerVal1);
  } else if (fmType === 'fm3' && fm3) {
    return fm3.initCamera.call(fm3, playerVal1);
  } else if (fmType === 'fmXr' && fmXr) {
    return fmXr.initCamera.call(fmXr, playerVal1);
  }
};

const loadModel = (code): Promise<any> => {
  if (code === 'Fm1') return import('./gate.threejs.yy').then((r) => r.default);
  if (code === 'Fm3') return import('./gate.threejs.qd').then((r) => r.default);
  if (code === 'FmXR') return import('./gate.threejs.xr').then((r) => r.default);
  if (code === 'Fm2') return import('./gate.threejs.three').then((r) => r.default);
  if (code === 'FmTwoSs') return import('./gate.threejs.two.ss').then((r) => r.default);
  if (code === 'FmThreeTl') return import('./gate.threejs.three.tl').then((r) => r.default);
  if (code === 'FmDc') return import('./gate.threejs.window').then((r) => r.default);
  if (code === 'FmDcHJG') return import('./gate.threejs.window.hjg').then((r) => r.default);
  if (code === 'FmDcZHQ') return import('./gate.threejs.window.zhq').then((r) => r.default);
  if (code === 'FmHsw3') return import('./gate.threejs.three.hsw').then((r) => r.default);
  if (code === 'FmYjXr') return import('./gate.threejs.two.yj').then((r) => r.default); // 姚街行人
  if (code === 'FmYj') return import('./gate.threejs.yj').then((r) => r.default); // 姚街
  if (code === 'FmSp1') return import('./gate.threejs.one.sp').then((r) => r.default);
  if (code === 'fmDcBd') return import('./dandaoFcBd3.threejs').then((r) => r.default);
  if (code === 'fmSsl') return import('./gate.threejs.two.ssl').then((r) => r.default);
  if (code === 'fm_fc_ssl') return import('./gate.threejs.tj.ssl').then((r) => r.default);
  return import('./gate.threejs.yy').then((r) => r.default);
};

export const mountedThree = (playerDom) => {
  // const { sysOrgCode } = useGlobSetting();
  // const sysOrgCode = 'gsgszdek';
  return new Promise(async (resolve) => {
    model = new UseThree('#damper3D', '', '#deviceDetail');
    model.setEnvMap('test1.hdr');
    model.renderer.toneMappingExposure = 0.9;
    model.camera.position.set(100, 0, 1000);
    const dictCodes = getDictItemsByCode('gateStyle');
    if (dictCodes && dictCodes.length > 0) {
      for (let i = 0; i < dictCodes.length; i++) {
        const dict = dictCodes[i];
        switch (dict.value) {
          case 'fmXr':
            const FmXR = await loadModel('FmXR');
            fmXr = new FmXR(model);
            fmXr.mountedThree(playerDom);
            break;
          case 'fmYy':
            const Fm1 = await loadModel('Fm1');
            fm1 = new Fm1(model);
            fm1.mountedThree(playerDom);
            break;
          case 'gate_qd':
            const Fm3 = await loadModel('Fm3');
            fm3 = new Fm3(model);
            await fm3.mountedThree();
            break;
          case 'fmSs':
            const FmTwoSs = await loadModel('FmTwoSs');
            fmTwoSs = new FmTwoSs(model);
            await fmTwoSs.mountedThree();
            break;
          case 'fmtl3':
            const FmThreeTl = await loadModel('FmThreeTl');
            fmThreeTl = new FmThreeTl(model);
            await fmThreeTl.mountedThree();
            break;
          case 'fmSs3':
            const Fm2 = await loadModel('Fm2');
            fm2 = new Fm2(model);
            await fm2.mountedThree();
            break;
          case 'fm_fc_hjg':
            const FmDcHJG = await loadModel('FmDcHJG');
            fmWindowHjg = new FmDcHJG(model);
            await fmWindowHjg.mountedThree();
            break;
          case 'fm_fc':
            const FmDc = await loadModel('FmDc');
            fmWindow = new FmDc(model);
            await fmWindow.mountedThree();
            break;
          case 'fm_fc_zhq': //fmWindowZhq
            const FmDcZHQ = await loadModel('FmDcZHQ');
            fmWindowZhq = new FmDcZHQ(model);
            await fmWindowZhq.mountedThree();
            break;
          case 'fmHsw3':
            const FmHsw3 = await loadModel('FmHsw3');
            fmHsw3 = new FmHsw3(model);
            await fmHsw3.mountedThree();
            break;
          case 'fmYjXr':
            const FmYjXr = await loadModel('FmYjXr');
            fmYjXr = new FmYjXr(model);
            await fmYjXr.mountedThree();
            break;
          case 'fmYj':
            const FmYj = await loadModel('FmYj');
            fmYj = new FmYj(model);
            await fmYj.mountedThree();
            break;
          case 'fmSp1':
            const FmSp1 = await loadModel('FmSp1');
            fmSp1 = new FmSp1(model);
            await fmSp1.mountedThree();
            break;
          case 'fm_fc_bd':
            const FmDcBd = await loadModel('fmDcBd');
            fmDcBd = new FmDcBd(model);
            await fmDcBd.mountedThree();
            break;
          case 'fmSsl':
            const FmSsl = await loadModel('fmSsl');
            fmSsl = new FmSsl(model);
            await fmSsl.mountedThree();
            break;
          case 'fm_fc_ssl':
            const Fm_fc_ssl = await loadModel('fm_fc_ssl');
            fm_fc_ssl = new Fm_fc_ssl(model);
            await fm_fc_ssl.mountedThree();
            break;
        }
      }
      resolve(null);
    } else {
      const Fm3 = await loadModel('Fm3');
      fm3 = new Fm3(model);
      fm3.mountedThree(playerDom);
      const FmTwoSs = await loadModel('FmTwoSs');
      fmTwoSs = new FmTwoSs(model);
      fmTwoSs.mountedThree(playerDom);
      const Fm2 = await loadModel('Fm2');
      fm2 = new Fm2(model);
      fm2.mountedThree(playerDom);
      // 三道门
      const FmThreeTl = await loadModel('FmThreeTl');
      fmThreeTl = new FmThreeTl(model);
      if (fmThreeTl) fmThreeTl.mountedThree(playerDom);
      const FmXR = await loadModel('FmXR');
      fmXr = new FmXR(model);
      fmXr.mountedThree(playerDom);
      // 液压风门
      const Fm1 = await loadModel('Fm1');
      fm1 = new Fm1(model);
      fm1.mountedThree(playerDom);
      resolve(null);
    }

    model.animate();
    // startAnimation();
  });
};

export const destroy = () => {
  if (model) {
    model.isRender = false;
    if (fm1) fm1.destroy();
    if (fm2) fm2.destroy();
    if (fm3) fm3.destroy();
    if (fmXr) fmXr.destroy();
    if (fmTwoSs) fmTwoSs.destroy();
    if (fmWindowHjg) fmWindowHjg.destroy();
    if (fmWindowZhq) fmWindowZhq.destroy();
    if (fmWindow) fmWindow.destroy();
    if (fmThreeTl) fmThreeTl.destroy();
    if (fmHsw3) fmHsw3.destroy();
    if (fmYjXr) fmYjXr.destroy();
    if (fmYj) fmYj.destroy();
    if (fmSp1) fmSp1.destroy();
    if (fmDcBd) fmDcBd.destroy();
    if (fm_fc_ssl) fm_fc_ssl.destroy();
    fm1 = null;
    fm2 = null;
    fm3 = null;
    fmXr = null;
    fmWindow = null;
    fmWindowHjg = null;
    fmWindowZhq = null;
    fmThreeTl = null;
    fmTwoSs = null;
    fmHsw3 = null;
    fmYjXr = null;
    fmYj = null;
    fmSp1 = null;
    fmDcBd = null;
    fm_fc_ssl = null;
    group = null;
    model.mixers = [];
    model.destroy();
  }
  model = null;
};