| 
					
				 | 
			
			
				@@ -0,0 +1,292 @@ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import * as THREE from 'three'; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js'; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import { OutlinePass } from 'three/examples/jsm/postprocessing/OutlinePass.js'; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import { setModalCenter } from '/@/utils/threejs/util'; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+// import * as dat from 'dat.gui'; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+// const gui = new dat.GUI(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+// gui.domElement.style = 'position:absolute;top:100px;left:10px;z-index:99999999999999'; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+class WorkFaceGas { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  model; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  modelName = 'workFaceGas'; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  group: THREE.Object3D = new THREE.Object3D(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  planeGroup: THREE.Group = new THREE.Group(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  bloomComposer: EffectComposer | null = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  finalComposer: EffectComposer | null = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  outlinePass: OutlinePass | null = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  positions: THREE.Vector3[][] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  bloomLayer = new THREE.Layers(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  darkMaterial = new THREE.MeshBasicMaterial({ color: 'black', transparent: true, side: THREE.DoubleSide }); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  materials = {}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  glob = { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ENTIRE_SCENE: 0, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    BLOOM_SCENE: 10, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    N: 100, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  locationTexture: THREE.Texture | null = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  warningLocationTexture: THREE.Texture | null = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  errorLocationTexture: THREE.Texture | null = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  playerStartClickTime1 = new Date().getTime(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  playerStartClickTime2 = new Date().getTime(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  planeNum = 0; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  constructor(model) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    this.model = model; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    this.group.name = this.modelName; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  addLight() { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const directionalLight = new THREE.DirectionalLight(0xffffff, 1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    directionalLight.position.set(-196, 150, 258); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    this.group.add(directionalLight); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    directionalLight.target = this.group; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  setControls = () => { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    if (this.model && this.model.orbitControls) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      this.model.orbitControls.panSpeed = 0.5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      this.model.orbitControls.rotateSpeed = 0.5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      this.model.orbitControls.maxPolarAngle = Math.PI / 3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      this.model.orbitControls.minPolarAngle = Math.PI / 4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      this.model.orbitControls.minAzimuthAngle = -Math.PI / 3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      this.model.orbitControls.maxAzimuthAngle = Math.PI / 4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  render() { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    this.model.renderer?.render(this.model.scene as THREE.Scene, this.model.camera as THREE.PerspectiveCamera); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  /* 点击 */ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  mousedownModel(rayCaster: THREE.Raycaster) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const opticalFiber = this.group.getObjectByName('opticalfiber'); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    if (opticalFiber) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      const intersects = rayCaster?.intersectObjects([...opticalFiber.children]) as THREE.Intersection[]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      // 判断是否点击到视频 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      intersects.find((intersect) => { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        const mesh = intersect.object; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        if (mesh.name.startsWith('optical_fiber_')) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          // outlinePass?.selectedObjects.push(mesh); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          return true; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        return false; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      }); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    this.render(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  mouseUpModel() { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  setThreePlane() { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const gltfModal = this.group.getObjectByName('workFace'); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const PouMian01 = gltfModal?.getObjectByName('WaSiPouMian01'); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const DiXing = PouMian01?.getObjectByName('DiXing'); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // 绘制采空区三带 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // new THREE.Vector3(934.695, -141.85, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // new THREE.Vector3(934.695, 623.933, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    //-365.355 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const material1 = new THREE.MeshBasicMaterial({ side: THREE.DoubleSide, vertexColors: true }); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const offeset = 10; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const yellowLen = offeset * 8; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // 红=》红 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const curveRed = new THREE.CatmullRomCurve3([new THREE.Vector3(-477.721, -141.83, -365.375), new THREE.Vector3(-477.721, 623.933, -365.375)]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const curve0 = new THREE.CatmullRomCurve3([ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(-231.811 - 150, -141.83, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(-121.899 - 150, 67.201, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(-242.441 - 150, 408.812, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(-179.811 - 150, 620.836, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const pointsRed = curveRed.getPoints(80); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const points0 = curve0.getPoints(80); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const newPointRed: number[] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const normalsRed: number[] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const colorsRed: number[] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    for (let i = 0; i < 80; i++) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPointRed.push(pointsRed[i].x, pointsRed[i].y, pointsRed[i].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPointRed.push(points0[i].x, points0[i].y, points0[i].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPointRed.push(points0[i + 1].x, points0[i + 1].y, points0[i + 1].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPointRed.push(points0[i + 1].x, points0[i + 1].y, points0[i + 1].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPointRed.push(pointsRed[i + 1].x, pointsRed[i + 1].y, pointsRed[i + 1].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPointRed.push(pointsRed[i].x, pointsRed[i].y, pointsRed[i].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      normalsRed.push(0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      colorsRed.push(1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const geometryRed = new THREE.BufferGeometry(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometryRed.setAttribute('position', new THREE.BufferAttribute(new Float32Array(newPointRed), 3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometryRed.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(normalsRed), 3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometryRed.setAttribute('color', new THREE.BufferAttribute(new Float32Array(colorsRed), 3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const meshRed = new THREE.Mesh(geometryRed, material1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    meshRed.position.setZ(-1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    DiXing?.add(meshRed); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // 红=》黄 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const curve1 = new THREE.CatmullRomCurve3([ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(-231.811 - yellowLen, -141.83, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(-121.899 - yellowLen, 67.201, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(-242.441 - yellowLen, 408.812, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(-179.811 - yellowLen, 620.836, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const points1 = curve1.getPoints(80); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const newPoints0: number[] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const normals0: number[] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const colors0: number[] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    for (let i = 0; i < 80; i++) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPoints0.push(points0[i].x, points0[i].y, points0[i].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPoints0.push(points1[i].x, points1[i].y, points1[i].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPoints0.push(points1[i + 1].x, points1[i + 1].y, points1[i + 1].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPoints0.push(points1[i + 1].x, points1[i + 1].y, points1[i + 1].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPoints0.push(points0[i + 1].x, points0[i + 1].y, points0[i + 1].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPoints0.push(points0[i].x, points0[i].y, points0[i].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      normals0.push(0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      colors0.push(1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const geometry0 = new THREE.BufferGeometry(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometry0.setAttribute('position', new THREE.BufferAttribute(new Float32Array(newPoints0), 3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometry0.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(normals0), 3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometry0.setAttribute('color', new THREE.BufferAttribute(new Float32Array(colors0), 3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometry0.computeBoundingBox(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // const material1 = new THREE.MeshBasicMaterial({ side: THREE.DoubleSide, color: '#fff' }); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const mesh0 = new THREE.Mesh(geometry0, material1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    mesh0.name = 'yellow'; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    mesh0.position.setZ(-1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    DiXing?.add(mesh0); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // 黄=》黄 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const curveYellow1 = new THREE.CatmullRomCurve3([ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(784.664 - yellowLen, 623.933, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(167.212 - yellowLen, 450.517, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(7.587 - yellowLen, 262.225, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(426.499 - yellowLen, 31.416, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(261.665 - yellowLen, -139.495, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const curveYellow2 = new THREE.CatmullRomCurve3([ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(-179.811 - yellowLen, 620.836, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(-242.441 - yellowLen, 408.812, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(-121.899 - yellowLen, 67.201, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(-231.811 - yellowLen, -141.83, -365.375), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const pointsYellow1 = curveYellow1.getPoints(80); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const pointsYellow2 = curveYellow2.getPoints(80); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const newPointYellow: number[] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const normalsYellow: number[] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const colorsYellow: number[] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    for (let i = 0; i < 80; i++) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPointYellow.push(pointsYellow1[i].x, pointsYellow1[i].y, pointsYellow1[i].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPointYellow.push(pointsYellow2[i].x, pointsYellow2[i].y, pointsYellow2[i].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPointYellow.push(pointsYellow2[i + 1].x, pointsYellow2[i + 1].y, pointsYellow2[i + 1].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPointYellow.push(pointsYellow2[i + 1].x, pointsYellow2[i + 1].y, pointsYellow2[i + 1].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPointYellow.push(pointsYellow1[i + 1].x, pointsYellow1[i + 1].y, pointsYellow1[i + 1].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPointYellow.push(pointsYellow1[i].x, pointsYellow1[i].y, pointsYellow1[i].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      normalsYellow.push(0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      colorsYellow.push(1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const geometryYellow = new THREE.BufferGeometry(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometryYellow.setAttribute('position', new THREE.BufferAttribute(new Float32Array(newPointYellow), 3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometryYellow.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(normalsYellow), 3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometryYellow.setAttribute('color', new THREE.BufferAttribute(new Float32Array(colorsYellow), 3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const meshYellow = new THREE.Mesh(geometryYellow, material1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    meshYellow.position.setZ(-1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    DiXing?.add(meshYellow); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // 蓝 =》 蓝 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const curve3 = new THREE.CatmullRomCurve3([ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(784.664, 623.933, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(167.212, 450.517, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(7.587, 262.225, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(426.499, 31.416, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(261.665, -139.495, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const points = curve3.getPoints(80); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    points.unshift(new THREE.Vector3(934.695, 623.933, -365.375)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    points.unshift(new THREE.Vector3(934.695, -141.85, -365.375)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    points.push(new THREE.Vector3(934.695, -141.85, -365.375)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const newPoints: THREE.Vector2[] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    for (let i = 0; i < points.length; i++) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      const point = points[i]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPoints.push(new THREE.Vector2(point.x, point.y)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const shape = new THREE.Shape(newPoints); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const geometry = new THREE.ShapeGeometry(shape); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const material = new THREE.MeshBasicMaterial({ side: THREE.BackSide, color: '#00F' }); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const mesh = new THREE.Mesh(geometry, material); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    mesh.position.setZ(-366.485); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    DiXing?.add(mesh); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // 黄色-》蓝色 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const curve2 = new THREE.CatmullRomCurve3([ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(784.664 - yellowLen, 623.933, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(167.212 - yellowLen, 450.517, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(7.587 - yellowLen, 262.225, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(426.499 - yellowLen, 31.416, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(261.665 - yellowLen, -139.495, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const curve4 = new THREE.CatmullRomCurve3([ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(784.664, 623.933, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(167.212, 450.517, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(7.587, 262.225, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(426.499, 31.416, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new THREE.Vector3(261.665, -139.495, -365.355), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const points2 = curve2.getPoints(80); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const points3 = curve4.getPoints(80); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const newPoints1: number[] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const normals: number[] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const colors: number[] = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    for (let i = 0; i < 80; i++) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPoints1.push(points2[i].x, points2[i].y, points2[i].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPoints1.push(points3[i].x, points3[i].y, points3[i].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPoints1.push(points3[i + 1].x, points3[i + 1].y, points3[i + 1].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPoints1.push(points3[i + 1].x, points3[i + 1].y, points3[i + 1].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPoints1.push(points2[i + 1].x, points2[i + 1].y, points2[i + 1].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      newPoints1.push(points2[i].x, points2[i].y, points2[i].z); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      normals.push(0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      colors.push(1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const geometry1 = new THREE.BufferGeometry(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometry1.setAttribute('position', new THREE.BufferAttribute(new Float32Array(newPoints1), 3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometry1.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(normals), 3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometry1.setAttribute('color', new THREE.BufferAttribute(new Float32Array(colors), 3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    geometry1.computeBoundingBox(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    const mesh1 = new THREE.Mesh(geometry1, material1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    mesh1.name = 'blue'; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    mesh1.position.setZ(-1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    DiXing?.add(mesh1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  mountedThree() { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    return new Promise(async (resolve) => { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      this.model.renderer.sortObjects = true; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      this.model.orbitControls.update(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      this.model.setGLTFModel('workFace').then(async (gltf) => { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        const gltfModal = gltf[0]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        this.group = gltfModal; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        this.group.name = this.modelName; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        setModalCenter(this.group); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        this.group.scale.set(2.5, 2.5, 2.5); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        this.addLight(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        this.setThreePlane(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        this.setControls(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        resolve(null); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      }); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  destroy() { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    this.model.clearGroup(this.group); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    this.model = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    this.group = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    this.bloomComposer?.dispose(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    this.finalComposer?.dispose(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+export default WorkFaceGas; 
			 |