devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Threejs实现立体3D园区解决方案及代码_threejs3d智慧园区

作者：笔触狂放9 | 2024-06-07 01:41:01

赞

踩

threejs3d智慧园区

一、实现方案

单独贴代码可能容易混乱，所以这里只讲实现思路，代码放在最后汇总了下。

想要实现一个简单的工业园区、主要包含的内容是一个大楼、左右两片停车位、四条道路以及多个可在道路上随机移动的车辆、遇到停车位时随机选择是否要停车，简单设计图如下

二、实现步奏

2.1 引入环境，天空和地面

　引入天空有三种方式：

　　1) 第一种通过添加天空盒导入六个不同角度的天空图片可以形成，简单方便，缺点是在两个面之间会有视觉差

　　2) 第二种是设置scene的背景和环境是一张天空图片来实现的，缺点图片单一，而且在天、地斜街处很生硬

　　3) 不需要导入外部图片，通过在一个球体上添加渐变色实现，缺点球体只有一部分是天空颜色，内部为白色，需要设定旋转范围

　　4) 使用Three.js中的example中的Sky.js实现，效果比较完美

　引入地面：给一个大平面添加一张草地纹理即可。

2.2 创建一块地基

　　创建一个固定长度的平面，然后绕X轴旋转即可

2.3 布置围墙

　　导入一个围墙模型作为一个围墙的基本单位A，算出围墙所占的长和宽，为了完整性，可以将园区的长和宽设定为A的整数倍。

2.4 办公楼、停车场、充电桩加载

　　1）导入一个办公大楼模型

　　2）创建一个停车场类Parking.js，主要用来创建单个停车位，其中需要计算出停车位的进入点，方便以后车辆进入。

　　3）导入一个充电桩，每两个停车位使用一个充电桩

2.5 添加办公楼前景观、树、公交站点

　　1）在指定位置导入景观模型和公交站点模型

　　2）导入树模型，在园区前侧围墙均匀分布

2.6 铺设路面

　     　

           

　　首先道路可以细化为上下行多个车道，而车辆则是行驶在各车道的中心线位置处，所以为了方便后续车辆的控制，需要先将道路拆分，然后获取各个道路中心线和车道中心线信息

　　1）创建一个道路类Road.js，道路点信息传入的是图中红色点信息(图中菱形点)，需要标记出从哪个点开始道路非直线，

　　　　比如点信息格式为：[{ coord: [10, 0], type: 1}, { coord: [10, 10], type: 0}, { coord: [0, ], type: 1}] ；0代表曲线点，1代表直线点

　　2）由于使用传入的原始道路点无法绘制出平滑的曲线而且在细化道路点的时候直线点数据细化不明显，所以需要先按照一定的间隔插入部分点信息(图中绿色五角星点)

　　3）根据细化后的道路点按照道路宽度向两边开始扩展点信息，扩展方式通过获取当前点A和前一个点B组成的直线，取AB上垂线且距AB直线距离均为路宽的点即可，最终得到道路左侧点A和右侧点B

　　4）通过ThreeJS中创建一条平滑曲线获取曲线上的多个点即可得到三条平滑的曲线A、B、C。

　　5）经过第四步虽然可以得到道路数据，但是无法区分上下行，仍然不满足使用，通过图二上下行车辆最后生成组合成的一条闭合轨迹应该是逆时针的，

　　　  所以需要将最后生成的A、B线顶点反转拼接成一个完整的多边形，如果是逆时针则可以得到正确的上下行路线。

　　6）根据道路顶点即可画出道路面以及道路边界和中心线。

2.7 添加车辆以及车辆在道路随机移动的逻辑

　　

             

　　创建一个移动类，可以承接车辆或者行人，当前以车辆为主，主要包含移动轨迹、当前移动所在道路和车道、车位停车、驶离车位等内容。

　　1）创建一个Move.js类，创建对象时传入停车场对象信息、道路对象信息，方便后续移动时可以计算出轨迹信息

　　2）根据提供的初始位置计算出最近的道路和车道信息，与当前位置拼接在一起即可生成行动轨迹。

　　3）当车辆移动到道路尽头时可以获取到本道路的另外一条车道即可实现掉头

　　4）路口的判断：图三中，车辆由M车道途径N车道时，由M车道左侧当前位置和上一个位置组成的线段与N车道右侧车道起始或者终止点组成的线段有交集时则代表有路口，同样方法可以得到右侧道路的路口信息

　　5）路口处拐入其他车道的轨迹生成：根据4）可以找到转向N的车道信息，但是无法保证平稳转向，所以可以通过找到M和N的车道中心线所在直线获取到交点C，然后由A、C、B生成一条贝塞尔曲线即可平滑转弯

2.8 添加停车逻辑以及车辆驶离逻辑

　　1）寻找停车场：如图四，车辆在向前移动时，移动到的每个点都和所有停车场的入口B的位置判断距离，如果小于一个固定值的则代表临近车位，可以停车。

　　2）停车方式：根据6）获取到的停车位，同时在当前路径上继续向前取15个点的位置C、B、A组成的曲线则是倒车入口的路径线。

三、遗留问题、待优化点

1. 拐弯添加的点不多，所以在拐弯处速度较快

　　---  可以通过在拐弯处组成的多个点通过生成的线获取多个点来解决这个问题

2. 需要添加一个路口来管理各条之间的关系

　　--- 优点：(1). 有了路口后，可以解决车辆在路口移动时实时计算和其他路口的位置关系，可能会导致路口转弯混乱，通过在路口中心点生成一个外接圆，如果进入路口，则锁死移动方向，如果移出路口则解除锁定

　　　　(2). 解决在路口处，各道路绘制的边线有重叠问题，使各个道路之间能看着更平滑

　　　　缺点：最好不需要导入路口，而是由各个道路之间的相交关系计算得出，计算逻辑较为复杂。

3. 最好能添加一个停车场方便管理车位以及车辆驶入、驶离停车位

　　--- 添加停车场，车辆只需要和停车场的位置计算即可，不需要和每个停车位计算位置，减少冗余计算，而且车辆如果和单个停车位计算位置，可能存在从停车位A使出，途径相邻的停车位B，又会进入。

　　　　添加停车场通过给停车场添加标识即可解决这个问题

4. 车位和车道的边缘线无法加宽

　　--- Three.js目前的缺陷，尝试几种办法暂时没有解决

5. 没有添加车辆防碰撞功能

四、完整的代码

　　为了简单点，没有用Node安装依赖包，下述JS中引入的其他文件均在threeJS安装包中可以找到，拷贝过来即可。

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.  
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  8.     <title>园区案例</title>
  9. </head>
  10.  
  11. <body style="margin: 0;">
  12.     <div id="webgl" style="border: 1px solid;"></div>
  13. <script type="importmap">
  14.     {
  15.         "imports": {
  16.             "three": "./three.module.js"
  17.         }
  18.     }
  19. </script>
  20.       <script type="module" src="./Objects/Main.js"></script>
  21.     </script>
  22. </body>
  23.  
  24. </html>
  25.  
  26. 主页面index.html
  1. /**
  2.  * 办公园区
  3.  */
  4. import * as THREE from 'three';
  5. import { OrbitControls } from '../OrbitControls.js';
  6. import { GLTFLoader } from '../GLTFLoader.js';
  7. import { addEnviorment, segmentsIntr } from '../Objects/Common.js';
  8. import Move from './Move.js';
  9. import Road from './Road.js';
  10. import Parking from './Parking.js';
  11.  
  12. /**
  13.  * 1. 先引入环境 天空和地面
  14.  * 2. 创建一块全区的地皮
  15.  * 3. 布置围墙
  16.  * 4. 办公楼、停车场、充电桩的位置
  17.  * 5. 添加办公楼前装饰物、树、公交站点
  18.  * 6. 铺设路面
  19.  * 7. 写动态逻辑，设置页面动态化
  20.  */
  22. const wWidth = window.innerWidth; // 屏幕宽度
  23. const wHeight = window.innerHeight; // 屏幕高度
  24.  
  25. const scene = new THREE.Scene();
  26. let renderer = null;
  27. let camera = null;
  28. let controls = null;
  29. const roadObj = []; // 存储道路数据
  30. const moveObj = []; // 存储车辆数据
  31.  
  32. // 园区宽度本身
  33. const long = 600; // 园区的长
  34. const width = 300; // 园区的宽
  35. // 停车场的长和宽
  36. const [parkingW, parkingH] = [20, 30];
  37. const parks = []; // 存储停车场数据
  38.  
  39. let everyL = 0; // 单个围墙的长度
  40. let everyW = 0; // 单个围墙的厚度
  41. let buildH = 0; // 办公楼的厚度
  42. let wallNumL = 0; // 展示园区占多少个墙的长度，当前设置为最大的整数-1
  43. let wallNumW = 0;
  44.  
  45. /**
  46.  * 初始化
  47.  */
  48. function init() {
  49.   addEnvir(true, false);
  50.   createBase();
  51.   loadWall();
  52.   setTimeout(() => {
  53.     loadBuildings();
  54.     setTimeout(() => {
  55.       loadOrnament();
  56.     }, 200)
  57.     loadRoad();
  58.     loadBusAndPeople();
  59.     addClick();
  60.   }, 500)
  61. }
  62.  
  63. /**
  64.  * 添加相机等基础功能
  65.  */
  66. function addEnvir(lightFlag = true, axFlag = true, gridFlag = false) {
  67.   // 初始化相机
  68.   camera = new THREE.PerspectiveCamera(100, wWidth / wHeight, 1, 3000);
  69.   camera.position.set(300, 100, 300);
  70.   camera.lookAt(0, 0, 0);
  71.  
  72.   // 创建灯光
  73.   // 创建环境光
  74.   const ambientLight = new THREE.AmbientLight(0xf0f0f0, 1.0);
  75.   ambientLight.position.set(0,0,0);
  76.   scene.add(ambientLight);
  77.   if (lightFlag) {
  78.     // 创建点光源
  79.     const pointLight = new THREE.PointLight(0xffffff, 1);
  80.     pointLight.decay = 0.0;
  81.     pointLight.position.set(200, 200, 50);
  82.     scene.add(pointLight);
  83.   }
  84.  
  85.   // 添加辅助坐标系
  86.   if (axFlag) {
  87.     const axesHelper = new THREE.AxesHelper(150);
  88.     scene.add(axesHelper);
  89.   }
  90.  
  91.   // 添加网格坐标
  92.   if (gridFlag) {
  93.     const gridHelper = new THREE.GridHelper(300, 25, 0x004444, 0x004444);
  94.     scene.add(gridHelper);
  95.   }
  96.  
  97.   // 创建渲染器
  98.   renderer = new THREE.WebGLRenderer({ antialias:true, logarithmicDepthBuffer: true });
  99.   renderer.setPixelRatio(window.devicePixelRatio);
  100.   renderer.setClearColor(0xf0f0f0, 0.8);
  101.   renderer.setSize(wWidth, wHeight); //设置three.js渲染区域的尺寸(像素px)
  102.   renderer.render(scene, camera); //执行渲染操作
  103.  
  104.   controls = new OrbitControls(camera, renderer.domElement);
  105.   // 设置拖动范围
  106.   controls.minPolarAngle = - Math.PI / 2;
  107.   controls.maxPolarAngle = Math.PI / 2 - Math.PI / 360;
  108.   
  109.   controls.addEventListener('change', () => {
  110.     renderer.render(scene, camera);
  111.   })
  112.  
  113.   // 添加天空和草地
  114.   scene.add(...addEnviorment());
  115.  
  116.   function render() {
  117.     // 随机选择一个移动物体作为第一视角
  118.     // const cur = moveObj[3];
  119.     // if (cur) {
  120.     //   const relativeCameraOffset = new THREE.Vector3(0, 20, -15);  
  121.     
  122.     //   const cameraOffset = relativeCameraOffset.applyMatrix4( cur.target.matrixWorld );  
  123.         
  124.     //   camera.position.x = cameraOffset.x;
  125.     //   camera.position.y = cameraOffset.y;
  126.     //   camera.position.z = cameraOffset.z;
  127.     //   // 始终让相机看向物体  
  128.     //   controls.target = cur.target.position;  
  129.  
  130.     //   camera.lookAt(...cur.target.position.toArray());
  131.     // }
  132.     
  133.     renderer.render(scene, camera);
  134.     requestAnimationFrame(render);
  135.   }
  136.   render();
  137.  
  138.   document.getElementById('webgl').appendChild(renderer.domElement);
  139. }
  140.  
  141. /**
  142.  * 创建园区的地基
  143.  */
  144. function createBase() {
  145.   const baseGeo = new THREE.PlaneGeometry(long, width);
  146.   baseGeo.rotateX(-Math.PI / 2);
  147.   const baseMesh = new THREE.Mesh(
  148.     baseGeo,
  149.     new THREE.MeshBasicMaterial({
  150.       color: '#808080',
  151.       side: THREE.FrontSide
  152.     })
  153.   );
  154.   baseMesh.name = 'BASE';
  155.   scene.add(baseMesh);
  156. }
  157.  
  158. /**
  159.  * 加载围墙
  160.  */
  161. function loadWall() {
  162.   const loader = new GLTFLoader();
  163.   loader.load('./Objects/model/wall.gltf', (gltf) => {
  164.     gltf.scene.scale.set(3, 3, 3);
  165.     const source = gltf.scene.clone();
  166.  
  167.     // 获取单个围墙的大小
  168.     const box3 = new THREE.Box3().setFromObject(gltf.scene);
  169.     everyL = box3.max.x - box3.min.x;
  170.     everyW = box3.max.z - box3.min.z;
  171.     wallNumL = Math.floor(long / everyL) - 1;
  172.     wallNumW = Math.floor(width / everyL) - 1;
  173.     
  174.     // 加载后墙
  175.     // 墙的起点和终点
  176.     const backS = [-long / 2, 0, -width / 2];
  177.     for (let i = 0; i < wallNumL; i++) {
  178.       const cloneWall = source.clone();
  179.       cloneWall.position.x = backS[0] + everyL * i + everyL / 2;
  180.       cloneWall.position.z = backS[2];
  181.       scene.add(cloneWall);
  182.     }
  183.  
  184.     // 加载左侧墙
  185.     const leftS = [-long / 2, 0, -width / 2];
  186.     for (let i = 0; i < wallNumW; i++) {
  187.       const cloneWall = source.clone();
  188.       cloneWall.rotateY(Math.PI / 2);
  189.       cloneWall.position.x = leftS[0];
  190.       cloneWall.position.z = leftS[2] + everyL * i + everyL / 2;
  191.       scene.add(cloneWall);
  192.     }
  193.  
  194.     // 加载右侧墙
  195.     const rightS = [-long / 2 + wallNumL * everyL, 0, -width / 2];
  196.     for (let i = 0; i < wallNumW; i++) {
  197.       const cloneWall = source.clone();
  198.       cloneWall.rotateY(Math.PI / 2);
  199.       cloneWall.position.x = rightS[0];
  200.       cloneWall.position.z = rightS[2] + everyL * i + everyL / 2;
  201.       scene.add(cloneWall);
  202.     }
  203.  
  204.     // 加载前侧墙
  205.     const frontS = [-long / 2, 0, -width / 2 + wallNumW * everyL];
  206.     for (let i = 0; i < wallNumL; i++) {
  207.       if (i !== Math.floor(wallNumL / 2)) {
  208.         const cloneWall = source.clone();
  209.         cloneWall.position.x = frontS[0] + everyL * i + everyL / 2;
  210.         cloneWall.position.z = frontS[2];
  211.         scene.add(cloneWall);
  212.       }
  213.     }
  214.   })
  215. }
  216.  
  217. /**
  218.  * 加载办公大楼以及停车场和充电桩
  219.  */
  220. function loadBuildings() {
  221.   const loader = new GLTFLoader();
  222.   loader.load('./Objects/model/buildings.gltf', (gltf) => {
  223.     gltf.scene.scale.set(4, 4, 4);
  224.  
  225.     // 获取大楼的大小
  226.     const box3 = new THREE.Box3().setFromObject(gltf.scene);
  227.     buildH = box3.max.z - box3.min.z;
  228.     gltf.scene.position.z = -width / 2 + buildH / 2;
  229.     scene.add(gltf.scene);
  230.   })
  231.  
  232.   // 添加左侧停车场
  233.   // 左侧停车场起始点坐标
  234.   const leftSPos = [-long / 2 + everyW + parkingH / 2, 0, -width / 2 + everyW + parkingW / 2 + 3];
  235.   for (let i = 0; i < 4; i++) {
  236.     const z =  leftSPos[2] + i * parkingW;
  237.     const parking = new Parking({
  238.       name: `A00${i + 1}`,
  239.       width: parkingW,
  240.       height: parkingH,
  241.       position: [leftSPos[0], leftSPos[1] + 1, z]
  242.     })
  243.     scene.add(parking.group);
  244.     parks.push(parking);
  245.   }
  246.  
  247.   // 右侧充电桩起始点坐标 并预留位置给充电枪
  248.   const rightSPos = [-long / 2 + wallNumL * everyL - everyW - parkingH / 2 - 10, 0, -width / 2 + everyW + parkingW / 2 + 3];
  249.   for (let i = 0; i < 4; i++) {
  250.     const parking = new Parking({
  251.       name: `B00${i + 1}`,
  252.       width: parkingW,
  253.       height: parkingH,
  254.       position: [rightSPos[0], rightSPos[1] + 1, rightSPos[2] + i * parkingW],
  255.       rotate: Math.PI
  256.     })
  257.     scene.add(parking.group);
  258.     parks.push(parking);
  259.   }
  260.   
  261.   // 添加充电桩
  262.   const chargePos = [-long / 2 + wallNumL * everyL - everyW - 4, 0, -width / 2 + everyW + 3 + parkingW];
  263.   loader.load('./Objects/model/charging.gltf', (gltf) => {
  264.     for (let i = 0; i < 2; i++) {
  265.       const source = gltf.scene.clone();
  266.       source.scale.set(6, 6, 6);
  267.       source.rotateY(Math.PI / 2);
  268.       source.position.x = chargePos[0];
  269.       source.position.y = chargePos[1];
  270.       source.position.z = chargePos[2] + i * 2 * parkingW;
  271.       scene.add(source);
  272.     }
  273.   })
  274. }
  275.  
  276.  
  277. /**
  278.  * 添加办公楼前装饰物、树、公交站点
  279.  */
  280. function loadOrnament() {
  281.   // 加载办公室前方雕塑
  282.   const loader = new GLTFLoader();
  283.   loader.load('./Objects/model/bed.gltf', (bedGltf) => {
  284.     bedGltf.scene.scale.set(2, 2, 2);
  285.     bedGltf.scene.rotateY(-Math.PI * 7 / 12);
  286.     loader.load('./Objects/model/sculpture.gltf', (sculGltf) => {
  287.       sculGltf.scene.scale.set(20, 20, 20);
  288.       sculGltf.scene.y = sculGltf.scene.y + 4;
  289.       const group = new THREE.Group();
  290.       group.add(bedGltf.scene);
  291.       group.add(sculGltf.scene);
  292.       group.position.set(0, 0, -width / 2 + everyW + buildH + 10);
  293.       scene.add(group);
  294.     });
  295.   });
  296.   
  297.   // 加载树木，沿街用的是柏树
  298.   loader.load('./Objects/model/songshu.gltf', (gltf) => {
  299.     const source = gltf.scene;
  300.     source.scale.set(8, 8, 8);
  301.     // 前面墙的树木, 单个墙的中间区域放置一棵树
  302.     const frontS = [-long / 2 + everyL / 2, 0, -width / 2 + wallNumW * everyL - 5];
  303.     for (let i = 0; i < wallNumL; i++) {
  304.       // 同样门口不放置树
  305.       if (i !== Math.floor(wallNumL / 2)) {
  306.         const temp = source.clone();
  307.         temp.position.set(frontS[0] + i * everyL, frontS[1], frontS[2]);
  308.         scene.add(temp);
  309.       }
  310.     }
  311.   });
  312.  
  313.   // 加载公交站点,位置在距离大门右侧第二单面墙处
  314.   loader.load('./Objects/model/busStops.gltf', (gltf) => {
  315.     const source = gltf.scene;
  316.     source.scale.set(4, 4, 4);
  317.     gltf.scene.position.set(-long / 2 + (Math.floor(wallNumL / 2) + 3) * everyL, 0, -width / 2 + wallNumW * everyL + everyW + 3);
  318.     scene.add(gltf.scene);
  319.   });
  320. }
  321.  
  322. /**
  323.  * 铺设园区和园区外面的公路
  324.  * 包含公路以及部分人行道路
  325.  */
  326. function loadRoad() {
  327.   const space = 40;
  328.   const outWidth = 40;
  329.   // 加载园区外面的公路
  330.   const outerP1 = [
  331.     { coord: [-long / 2, 0, -width / 2 + wallNumW * everyL + space], type: 1 },
  332.     { coord: [long / 2, 0, -width / 2 + wallNumW * everyL + space], type: 1 },
  333.   ];
  334.   const road1 = new Road({
  335.     name: 'road_1',
  336.     sourceCoord: outerP1,
  337.     width: outWidth,
  338.     showCenterLine: true
  339.   });
  340.   scene.add(road1.group);
  341.  
  342.   const outerP2 = [
  343.     { coord: [-long / 2 + wallNumL * everyL + outWidth / 2  + 10, 0, -width / 2 + wallNumW * everyL + space - outWidth / 2 + 0.5], type: 1 },
  344.     { coord: [-long / 2 + wallNumL * everyL + outWidth / 2  + 10, 0, -width / 2], type: 1 },
  345.   ];
  346.   const road2 = new Road({
  347.     name: 'road_2',
  348.     sourceCoord: outerP2,
  349.     width: outWidth,
  350.     showCenterLine: true,
  351.     zIndex: 0.8
  352.   });
  353.   scene.add(road2.group);
  354.  
  355.   // 加载园区内的道路
  356.   const innerWidth = 25;
  357.   const color = 0x787878;
  358.   const lineColor = 0xc2c2c2;
  359.   // 加载到停车场的道路
  360.   const innerP1 = [
  361.     { coord: [-long / 2 + Math.floor(wallNumL / 2) * everyL + everyL / 2, 0, -width / 2 + wallNumW * everyL + space - outWidth / 2 + 0.5], type: 1 },
  362.     { coord: [-long / 2 + Math.floor(wallNumL / 2) * everyL + everyL / 2, 0, -width / 2 + wallNumW * everyL + space - 60], type: 0 },
  363.     { coord: [-long / 2 + Math.floor(wallNumL / 2) * everyL + everyL / 2 - innerWidth / 2, 0, -width / 2 + wallNumW * everyL + space - 60 - innerWidth / 2], type: 1 },
  364.     { coord: [-long / 2 + parkingH + 20 + innerWidth / 2, 0, -width / 2 + wallNumW * everyL + space - 60 - innerWidth / 2], type: 0 },
  365.     { coord: [-long / 2 + parkingH + 20, 0, -width / 2 + wallNumW * everyL + space - 60 - innerWidth], type: 1 },
  366.     { coord: [-long / 2 + parkingH + 20, 0, -width / 2 + everyW + 10], type: 1 },
  367.   ];
  368.   const street1 = new Road({
  369.     name: 'street_1',
  370.     sourceCoord: innerP1,
  371.     width: innerWidth,
  372.     showCenterLine: true,
  373.     zIndex: 0.8,
  374.     planeColor: color,
  375.     sideColor: lineColor
  376.   });
  377.   scene.add(street1.group);
  378.  
  379.   // 加载到充电桩的道路
  380.   const innerP2 = [
  381.     { coord: [-long / 2 + Math.floor(wallNumL / 2) * everyL + everyL / 2, 0, -width / 2 + wallNumW * everyL + space - outWidth / 2 + 0.5], type: 1 },
  382.     { coord: [-long / 2 + Math.floor(wallNumL / 2) * everyL + everyL / 2, 0, -width / 2 + wallNumW * everyL + space - 60], type: 0 },
  383.     { coord: [-long / 2 + Math.floor(wallNumL / 2) * everyL + everyL / 2 + innerWidth / 2, 0, -width / 2 + wallNumW * everyL + space - 60 - innerWidth / 2], type: 1 },
  384.     { coord: [-long / 2 + wallNumL * everyL - parkingH - everyW - 39, 0, -width / 2 + wallNumW * everyL + space - 60 - innerWidth / 2], type: 0 },
  385.     { coord: [-long / 2 + wallNumL * everyL - parkingH - everyW - 39 + innerWidth / 2, 0, -width / 2 + wallNumW * everyL + space - 60 - innerWidth], type: 1 },
  386.     { coord: [-long / 2 + wallNumL * everyL - parkingH - everyW - 39 + innerWidth / 2, 0, -width / 2 + everyW + 10], type: 1 },
  387.   ];
  388.   const street2 = new Road({
  389.     name: 'street_2',
  390.     sourceCoord: innerP2,
  391.     width: innerWidth,
  392.     showCenterLine: true,
  393.     zIndex: 0.8,
  394.     planeColor: color,
  395.     sideColor: lineColor
  396.   });
  397.   scene.add(street2.group);
  398.  
  399.   roadObj.push(
  400.     road1,
  401.     road2,
  402.     street1,
  403.     street2
  404.   );
  405.  
  406.   calFork();
  407. }
  408.  
  409. /**
  410.  * 计算pointA和pointB 组成的直线与点集points是否有相交
  411.  * @param {*} points 
  412.  * @param {*} pontA 
  413.  * @param {*} pointB 
  414.  */
  415. function judgeIntersect(points, pointA, pointB) {
  416.   let res = { flag: false, interP: [] };
  417.   for (let i = 0; i < points.length - 1; i++) {
  418.     const cur = points[i];
  419.     const nextP = points[i + 1];
  420.     const interP = segmentsIntr(cur, nextP, pointA, pointB, true)
  421.     if ( interP !== false) {
  422.       res.flag = true;
  423.       res.interP = interP;
  424.       res.index = i;
  425.       break;
  426.     }
  427.   }
  428.   return res;
  429. }
  430.  
  431. /**
  432.  * 计算各条道路的岔口信息并统计到道路对象中
  433.  */
  434. function calFork() {
  435.   function setInter(cur, next, interP, corner, width) {
  436.     const circle = new THREE.ArcCurve(corner[0], corner[2], width * 2).getPoints(20);
  437.     const cirPoints = circle.map(e => new THREE.Vector3(e.x, 0, e.y));
  438.  
  439.     cur.intersect.push({ name: next.name,
  440.       interPoint: interP,
  441.       corner: cirPoints,
  442.       cornerCenter: corner
  443.     });
  444.  
  445.     next.intersect.push({
  446.       name: cur.name,
  447.       interPoint: interP,
  448.       corner: cirPoints,
  449.       cornerCenter: corner
  450.     });
  451.   }
  452.  
  453.   roadObj.forEach((e, i) => {
  454.     if (i < roadObj.length - 1) {
  455.       for (let j = i + 1; j < roadObj.length; j++) {
  456.         if (e.intersect.map(e => e.name).indexOf(roadObj[j].name) < 0) {
  457.           const middle = roadObj[j].middle;
  458.           // 计算路牙和其他道路是否有相交
  459.           // 左边路牙和下一条路的起始位置做对比
  460.           let inter = judgeIntersect(e.left, middle[0], middle[1]);
  461.           if (inter.flag) {
  462.             const cornerCenter = segmentsIntr(e.middle[inter.index], e.middle[inter.index + 1], middle[0], middle[1]);
  463.             setInter(e, roadObj[j], inter.interP, cornerCenter, roadObj[j].width);
  464.             continue;
  465.           }
  466.  
  467.           // 左边路牙和下一条路的终止位置做对比
  468.           inter = judgeIntersect(e.left, middle[middle.length - 1], middle[middle.length - 2])
  469.           if (inter.flag) {
  470.             const cornerCenter = segmentsIntr(e.middle[inter.index], e.middle[inter.index + 1], middle[middle.length - 1], middle[middle.length - 2]);
  471.             setInter(e, roadObj[j], inter.interP, cornerCenter, roadObj[j].width);
  472.             continue;
  473.           } 
  474.           
  475.           // 右边路牙和下一条路的起始位置做对比
  476.           inter = judgeIntersect(e.right, middle[0], middle[1]);
  477.           if (inter.flag) {
  478.             const cornerCenter = segmentsIntr(e.middle[inter.index], e.middle[inter.index + 1], middle[0], middle[1]);
  479.             setInter(e, roadObj[j], inter.interP, cornerCenter, roadObj[j].width);
  480.             continue;
  481.           }
  482.           
  483.           // 右边路牙和下一条路的终止位置做对比
  484.           inter = judgeIntersect(e.right, middle[middle.length - 1], middle[middle.length - 2]);
  485.           if (inter.flag) {
  486.             const cornerCenter = segmentsIntr(e.middle[inter.index], e.middle[inter.index + 1], middle[middle.length - 1], middle[middle.length - 2]);
  487.             setInter(e, roadObj[j], inter.interP, cornerCenter, roadObj[j].width);
  488.             continue;
  489.           }
  490.         }
  491.       }
  492.     }
  493.   })
  494. }
  495.  
  496.  
  497. function actionTemp(target, name, flag, moveName) {
  498.   const filter = roadObj.filter(e => e.name === name)[0];
  499.  
  500.   const carObject = new Move({
  501.     name: moveName,
  502.     target: target,
  503.     roads: roadObj,
  504.     startPos: flag ? filter.left[0] : filter.right[0],
  505.     parks: parks
  506.   });
  507.   moveObj.push(carObject);
  508. }
  509.  
  510. /**
  511.  * 加载行人和汽车
  512.  */
  513. function loadBusAndPeople() {
  514.   // 加载汽车和公交车
  515.   const loader = new GLTFLoader();
  516.  
  517.   const carId = [
  518.     'car0',
  519.     'car2',
  520.     'car4',
  521.     'car5',
  522.     'bus',
  523.  
  524.     'car3',
  525.   ];
  526.   const roadIds = [
  527.     'road_1',
  528.     'road_2',
  529.     'street_1',
  530.     'street_2',
  531.     'street_2',
  532.  
  533.     'road_2',
  534.   ];
  535.  
  536.   carId.forEach((e, i) => {
  537.     loader.load(`./Objects/model/${e}.gltf`, (gltf) => {
  538.       gltf.scene.scale.set(4, 4, 4);
  539.       scene.add(gltf.scene);
  540.       gltf.scene.name = e;
  541.       actionTemp(gltf.scene, roadIds[i], false, e);
  542.     });
  543.   })
  544. }
  545.  
  546. /**
  547.  * 点击汽车驶离停车位
  548.  */
  549. function addClick() {
  550.   renderer.domElement.addEventListener('click', (event) => {
  551.     const px = event.offsetX;
  552.     const py = event.offsetY;
  553.     const x = (px / wWidth) * 2 - 1;
  554.     const y = -(py / wHeight) * 2 + 1;
  555.     //创建一个射线发射器
  556.     const raycaster = new THREE.Raycaster();
  557.     // .setFormCamera()计算射线投射器的射线属性ray
  558.     // 即在点击位置创造一条射线，被射线穿过的模型代表选中
  559.     raycaster.setFromCamera(new THREE.Vector2(x, y), camera);
  560.  
  561.     const intersects = raycaster.intersectObjects(moveObj.map(e => e.target));
  562.     if (intersects.length > 0) {
  563.       const move = moveObj.filter(e => e.name === intersects[0].object.parent.name || e.name === intersects[0].object.parent.parent.name)[0];
  564.       if (move && move.pause) {
  565.         move.unParkCar();
  566.       }
  567.     }
  568.   })
  569. }
  570.  
  571. init();
  572.  
  573. 控制器Main.js
  1. import * as THREE from 'three';
  2. import { getCurvePoint, getSidePoints, segmentsIntr, clone, isClockWise } from './Common.js';
  3.  
  4. /**
  5.  * 移动类，实现物体如何按照路径运动以及在岔路口如何选择等功能
  6.  * 后期可以增加碰撞检测避让等功能
  7.  */
  8. class Road {
  9.   constructor(props) {
  10.  
  11.     // 道路的原始点信息，通过这些点信息扩展道路
  12.     this.sourceCoord = props.sourceCoord;
  13.  
  14.     // 道路名称
  15.     this.name = props.name;
  16.  
  17.     // 道路宽度
  18.     this.width = props.width;
  19.  
  20.     // 是否显示道路中心线
  21.     this.showCenterLine = props.showCenterLine === false ? false : true;
  22.  
  23.     // 左侧路牙点集合
  24.     this.left = [];
  25.  
  26.     // 道路中心线点集合
  27.     this.middle = [];
  28.  
  29.     // 右侧路牙点集合
  30.     this.right = [];
  31.  
  32.     // 道路面的颜色
  33.     this.planeColor = props.planeColor || 0x606060;
  34.  
  35.     // 道路边线的颜色
  36.     this.sideColor = props.sideColor || 0xffffff;
  37.  
  38.     // 道路中心线的颜色
  39.     this.middleColor = props.middleColor || 0xe0e0e0;
  40.     
  41.     // 道路的层级
  42.     this.zIndex = props.zIndex || 0.5;
  43.  
  44.     // 车道信息
  45.     this.lanes = [];
  46.  
  47.     // 道路组合对象
  48.     this.group = null;
  49.  
  50.     // 相交的道路名称 数据格式{name: ***, interPoint: [xx,xx,xx]}
  51.     this.intersect = [];
  52.  
  53.     this.lineInsert();
  54.     this.create();
  55.   }
  56.  
  57.   /**
  58.    * 由于直线获取贝塞尔点的时候插入的点较少导致物体运动较快，所以在
  59.    * 平行与X、Y轴的线插入部分点，保证物体运动平滑,插入点时保证X或者Z轴间距为路宽的一半
  60.    */
  61.   lineInsert() {
  62.     const temp = [];
  63.     const half = this.width / 2;
  64.     this.sourceCoord.forEach((cur, i) => {
  65.       temp.push(cur);
  66.       if (i < this.sourceCoord.length - 1) {
  67.         const e = cur.coord;
  68.         const nextP = this.sourceCoord[i + 1].coord;
  69.         // 处理直线
  70.         if (cur.type === 1) {
  71.           if (e[0] - nextP[0] === 0) {
  72.             // 平行Z轴
  73.             if (e[2] < nextP[2]) {
  74.               for (let i = e[2] + half; i < nextP[2]; i += half) {
  75.                 temp.push({
  76.                   coord: [e[0], e[1], i],
  77.                   type: 1
  78.                 });
  79.               }
  80.             } else {
  81.               for (let i = e[2] - half; i > nextP[2]; i -= half) {
  82.                 temp.push({
  83.                   coord: [e[0], e[1], i],
  84.                   type: 1
  85.                 });
  86.               }
  87.             }
  88.           } else if (e[2] - nextP[2] === 0) {
  89.             // 平行X轴
  90.             if (e[0] < nextP[0]) {
  91.               for (let i = e[0] + half; i < nextP[0]; i += half) {
  92.                 temp.push({
  93.                   coord: [i, e[1], e[2]],
  94.                   type: 1
  95.                 });
  96.               }
  97.             } else {
  98.               for (let i = e[0] - half; i > nextP[0]; i -= half) {
  99.                 temp.push({
  100.                   coord: [i, e[1], e[2]],
  101.                   type: 1
  102.                 });
  103.               }
  104.             }
  105.           }
  106.         }
  107.       }
  108.     })
  109.     this.sourceCoord = temp;
  110.   }
  111.  
  112.   /**
  113.    * 创建道路
  114.    */
  115.   create() {
  116.     const group = new THREE.Group();
  117.     const roadPoints = this.getPoints(this.sourceCoord, this.width);
  118.     
  119.     this.left = roadPoints[0];
  120.     this.middle = roadPoints[1];
  121.     this.right = roadPoints[2];
  122.  
  123.     const isWise = isClockWise(this.left.concat(clone(this.right).reverse()));
  124.  
  125.     // 添加左车道
  126.     this.lanes.push(new Lane({
  127.       name: `${this.name}_lane_0`,
  128.       type: 'left',
  129.       isReverse: isWise,
  130.       side: this.left,
  131.       middle: this.middle
  132.     }));
  133.  
  134.     // 添加右车道
  135.     this.lanes.push(new Lane({
  136.       name: `${this.name}_lane_1`,
  137.       type: 'right',
  138.       isReverse: !isWise,
  139.       side: this.right,
  140.       middle: this.middle
  141.     }));
  142.     
  143.     const outlinePoint = roadPoints[0].concat(clone(roadPoints[2]).reverse());
  144.     outlinePoint.push(roadPoints[0][0]);
  145.     const shape = new THREE.Shape();
  146.     outlinePoint.forEach((e, i) => {
  147.       if (i === 0) {
  148.         shape.moveTo(e[0], e[2], e[1]);
  149.       } else {
  150.         shape.lineTo(e[0], e[2], e[1]);
  151.       }
  152.     })
  153.  
  154.     // 创建道路面
  155.     const plane = new THREE.Mesh(
  156.       new THREE.ShapeGeometry(shape),
  157.       new THREE.MeshBasicMaterial({
  158.         color: this.planeColor,
  159.         side: THREE.DoubleSide
  160.       })
  161.     )
  162.     plane.rotateX(Math.PI / 2);
  163.     group.add(plane);
  164.     
  165.     // 创建道路边沿线
  166.     const sideL = new THREE.Line(
  167.       new THREE.BufferGeometry().setFromPoints(roadPoints[0].map(e => new THREE.Vector3(...e))),
  168.       new THREE.LineBasicMaterial({ color: this.sideColor, linewidth: 10 })
  169.     );
  170.  
  171.     const sideR = new THREE.Line(
  172.       new THREE.BufferGeometry().setFromPoints(roadPoints[2].map(e => new THREE.Vector3(...e))),
  173.       new THREE.LineBasicMaterial({ color: this.sideColor, linewidth: 10 })
  174.     );
  175.     group.add(sideL, sideR);
  176.     // 创建道路中心虚线
  177.     if (this.showCenterLine) {
  178.       const sideM = new THREE.Line(
  179.         new THREE.BufferGeometry().setFromPoints(roadPoints[1].map(e => new THREE.Vector3(...e))),
  180.         new THREE.LineDashedMaterial({ color: this.middleColor, linewidth: 10, gapSize: 5, dashSize: 5 })
  181.       );
  182.       sideM.computeLineDistances();
  183.       group.add(sideM);
  184.     }
  185.  
  186.     group.position.y = group.position.y + this.zIndex;
  187.     group.name = this.name;
  188.     this.group = group;
  189.   }
  190.  
  191.   /**
  192.    * 获取道路的顶点信息
  193.    */
  194.   getPoints(points) {
  195.     const half = this.width / 2;
  196.  
  197.     // 存储左中右三条线路的顶点信息
  198.     const [left, middle, right] = [[], [], []];
  199.     for (let i = 0; i < points.length;) {
  200.       const e = points[i].coord;
  201.       if (points[i].type === 1) {
  202.         // 直线处理方式
  203.         if (i === 0) {
  204.           const nextP = points[i + 1].coord;
  205.           const side = getSidePoints(e, nextP, e, half);
  206.           left.push(side[0]);
  207.           middle.push(e);
  208.           right.push(side[1]);
  209.         } else {
  210.           const preP = points[i - 1].coord;
  211.           const side = getSidePoints(preP, e, e, half);
  212.           left.push(side[0]);
  213.           middle.push(e);
  214.           right.push(side[1]);
  215.         }
  216.         i++;
  217.       } else {
  218.         // 曲线处理方式
  219.         const preMidP = points[i - 1].coord;
  220.         const nextMidP1 = points[i + 1].coord;
  221.         const nextMidP2 = points[i + 2].coord;
  222.  
  223.         // 获取两侧点信息
  224.         const sideP1 = getSidePoints(preMidP, e, e, half);
  225.         const sideP2 = getSidePoints(nextMidP1, nextMidP2, nextMidP1, half);
  226.         const sideP3 = getSidePoints(nextMidP1, nextMidP2, nextMidP2, half);
  227.         
  228.         // 左侧
  229.         const interLeft = segmentsIntr(left[left.length - 1], sideP1[0], sideP2[0], sideP3[0]);
  230.         const curveLeft = getCurvePoint(sideP1[0], interLeft, sideP2[0]);
  231.         left.push(...curveLeft);
  232.  
  233.         // 中间
  234.         const interMid = segmentsIntr(middle[middle.length - 1], e, nextMidP1, nextMidP2);
  235.         const curveMid = getCurvePoint(e, interMid, nextMidP1);
  236.         middle.push(...curveMid);
  237.  
  238.         // 右侧
  239.         const interRight = segmentsIntr(right[right.length - 1], sideP1[1], sideP2[1], sideP3[1]);
  240.         const curveRight = getCurvePoint(sideP1[1], interRight, sideP2[1]);
  241.         right.push(...curveRight);
  242.         i += 2;
  243.       }
  244.     }
  245.  
  246.     return [left, middle, right];
  247.   }
  248. }
  249.  
  250. /**
  251.  * 车道对象
  252.  */
  253. class Lane {
  254.   constructor(options) {
  255.     //车道名称
  256.     this.name = options.name;
  257.  
  258.     // 标识左车道还是右车道
  259.     this.type = options.type;
  260.  
  261.     // 行驶方向和点的方向是否一致
  262.     this.direction = options.direction;
  263.  
  264.     // 车道中心线
  265.     this.coord = this.getCenter(options.middle, options.side, options.isReverse);
  266.   }
  267.   getCenter(middle, side, reverseFlag) {
  268.     const center = middle.map((e, i) => {
  269.       return [(e[0] + side[i][0]) / 2, e[1], (e[2] + side[i][2]) / 2];
  270.     });
  271.     return reverseFlag ? center.reverse() : center;
  272.   }
  273. }
  274.  
  275. export default Road;
  276.  
  277. 道路类Road.js
  1. import * as THREE from 'three';
  2. import { calDistance, drawLine, clone, pointInPolygon, segmentsIntr } from './Common.js';
  3.  
  4. /**
  5.  * 移动类，实现物体如何按照路径运动以及在岔路口如何选择等功能
  6.  * 后期可以增加碰撞检测避让等功能
  7.  */
  8. class Move {
  9.   constructor(props) {
  10.     // 所有道路信息
  11.     this.roads = {};
  12.     props.roads.forEach(e => this.roads[e.name] = e);
  13.  
  14.     this.name = props.name;
  15.  
  16.     // 物体对象
  17.     this.target = props.target;
  18.  
  19.     // 前进还是倒车 1：前进；-1：倒车
  20.     this.direction = 1;
  21.  
  22.     // 物体初始位置
  23.     this.startPos = props.startPos;
  24.  
  25.     // 移动轨迹
  26.     this.trace = [];
  27.  
  28.     // 当前形式的道路
  29.     this.curRoad = null;
  30.  
  31.     // 锁定下一步行动趋势，主要是为了解决在路口物体获取到下一步行动后再次获取行动导致功能乱掉
  32.     this.trendLock = false;
  33.  
  34.     this.preRoadName = null;
  35.  
  36.     // 当前移动所在的车道
  37.     this.curLane = null;
  38.  
  39.     // 是否暂停移动
  40.     this.pause = false;
  41.  
  42.     // 园区停车场信息
  43.     this.parks = props.parks;
  44.  
  45.     this.parkObj = null;
  46.  
  47.     this.init();
  48.   }
  49.  
  50.   /**
  51.    * 获取当前实体所在道路以及移动方向和移动轨迹
  52.    */
  53.   init() {
  54.     let minDis = {
  55.       roadName: '',  // 起始位置所在道路的道路名
  56.       distance: 100000, // 起始物体与车道左右边线的最小距离
  57.       curLane: null, // 移动的车道
  58.     };
  59.     for (let o in this.roads) {
  60.       const road = this.roads[o];
  61.       const startLeftDis = calDistance(road.lanes[0].coord[0], this.startPos);
  62.       const startRightDis = calDistance(road.lanes[1].coord[0], this.startPos);
  63.       const endLeftDis = calDistance(road.lanes[0].coord[road.lanes[0].coord.length - 1], this.startPos);
  64.       const endRightDis = calDistance(road.lanes[1].coord[road.lanes[1].coord.length - 1], this.startPos);
  65.       const min = Math.min(startLeftDis, startRightDis, endLeftDis, endRightDis);
  66.  
  67.       if (minDis.distance > min) {
  68.         minDis = {
  69.           roadName: o,
  70.           distance: min,
  71.           curLane: (min === startRightDis || min === endRightDis) ? road.lanes[0] : road.lanes[1],
  72.           index: (startLeftDis === min || startRightDis === min) ? 0 : road.left.length - 1
  73.         };
  74.       }
  75.     }
  76.  
  77.     this.curLane = minDis.curLane;
  78.     
  79.     this.curRoad = this.roads[minDis.roadName];
  80.     this.trace = this.getSpreadPoint(this.curLane.coord);
  81.     this.moveIndex = minDis.index;
  82.     this.move();
  83.   }
  84.  
  85.   /**
  86.    * 获取车道中心线
  87.    * 将车道的左右线取平均值即可
  88.    * @param {*} params 
  89.    */
  90.   getLaneCenter(points1, points2) {
  91.     return points1.map((e, i) => {
  92.       return [(e[0] + points2[i][0]) / 2, e[1], (e[2] + points2[i][2]) / 2];
  93.     })
  94.   }
  95.  
  96.   move() {
  97.     if (!this.pause) {
  98.       this.checkMoveOutCorner();
  99.       this.parkCar();
  100.       // 如果移动到当前轨迹的最后一个点时，需要进行掉头重新寻找轨迹
  101.       const forks = this.checkFork();
  102.       if (forks.length !== 0) {
  103.         this.getRandomTrend(forks);
  104.       } else if (this.moveIndex === this.trace.length - 1) {
  105.         this.getTurnPoint();
  106.       }
  107.       const curPosition = this.trace[this.moveIndex].toArray();
  108.       this.target.position.set(...curPosition);
  109.       if (this.direction === 1) {
  110.         // 前进
  111.         if (this.moveIndex !== this.trace.length - 1) {
  112.           this.target.lookAt(...this.trace[this.moveIndex + 1].toArray());
  113.         }
  114.       } else {
  115.         // 倒车
  116.         if (this.moveIndex !== 0) {
  117.           this.target.lookAt(...this.trace[this.moveIndex - 1].toArray());
  118.         }
  119.       }
  120.       
  121.       this.moveIndex ++;
  122.     }
  123.     requestAnimationFrame(this.move.bind(this));
  124.   }
  125.  
  126.   /**
  127.    * 在锁定后检查物体是否已经移出路口，如果移出则解除锁定
  128.    */
  129.   checkMoveOutCorner() {
  130.     if (!this.trendLock) {
  131.       return false;
  132.     }
  133.     const preObj = this.curRoad.intersect.filter(e => e.name === this.preRoadName)[0];
  134.     if (preObj && !pointInPolygon(this.trace[this.moveIndex], preObj.corner)) {
  135.       this.trendLock = false;
  136.       this.preRoadName = null;
  137.     }
  138.     return this.trendLock;
  139.   }
  140.  
  141.   /**
  142.    * 根据提供的点信息寻找最近的点值
  143.    */
  144.   findNearIndex(points, pointA) {
  145.     let min = 100000;
  146.     let index = -1;
  147.     for (let i = 0; i < points.length; i++) {
  148.       const dis = calDistance(points[i], pointA);
  149.       if (dis < min) {
  150.         min = dis;
  151.       } else {
  152.         index = i - 1;
  153.         break;
  154.       }
  155.     }
  156.     return index;
  157.   }
  158.  
  159.   /**
  160.    * 在岔路口时随机获取下一步行动方向
  161.    */
  162.   getRandomTrend(forks) {
  163.     const isEnd = calDistance(this.trace[this.moveIndex].toArray(), this.trace[this.trace.length - 1].toArray()) < this.curRoad.width / 2;
  164.     // 从多条路中随机选择一条，当前园区路况简单 路口数据目前只有一条
  165.     const randomRoad = forks[Math.floor(Math.random() * forks.length)];
  166.     // 分别代表掉头、转弯、直行四种情况
  167.     let types = [0, 1, 2];
  168.     if (isEnd) {
  169.       // 如果是道路的尽头 可以选择掉头或者转弯
  170.       types = [0, 1, 2];
  171.     } else {
  172.       // 如果不是道路的尽头，可以选择转弯或者直行
  173.       types = [1, 2];
  174.     }
  175.  
  176.     const random = types[Math.floor(Math.random() * types.length)];
  177.     if (random === 0) {
  178.       // 掉头
  179.       this.trendLock = true;
  180.       this.getTurnPoint();
  181.     } else if (random === 1) {
  182.       // 转弯
  183.       this.trendLock = true;
  184.       this.getForkPoint(randomRoad, isEnd);
  185.     } else if (random === 2) {
  186.       this.preRoadName = randomRoad;
  187.       // 直线
  188.       this.trendLock = true;
  189.     }
  190.   }
  191.  
  192.   /**
  193.    * 在岔路口时根据获取道路轨迹信息
  194.    */
  195.   getForkPoint(name, isEnd) {
  196.     this.preRoadName = this.curRoad.name;
  197.     const roadObj = this.roads[name];
  198.     let splitPoint = [];
  199.     if (isEnd) {
  200.       // 如果在道路尽头转弯，随机产生是左侧还是右侧道路
  201.       const leftOrRight = Math.floor(Math.random() * roadObj.lanes.length);
  202.       const coord = roadObj.lanes[leftOrRight].coord;
  203.       this.curLane = roadObj.lanes;
  204.       const index = this.findNearIndex(coord, this.trace[this.moveIndex].toArray());
  205.       splitPoint = coord.slice(index + 1);
  206.       // 为了平滑过渡获取道路末端和当前行驶位置的交点
  207.       const corInter = segmentsIntr(splitPoint[0], splitPoint[1], this.trace[this.trace.length - 2].toArray(), this.trace[this.trace.length - 3].toArray());
  208.       if (corInter) {
  209.         splitPoint.unshift(corInter);
  210.       }
  211.       splitPoint.unshift(this.trace[this.moveIndex]);
  212.     } else {
  213.       // 转弯前需要判断当前路可以向那个方向转弯，比如临近路口只能转向右车道，非临近路口需要转到对象车道
  214.       // 可以根据当前点和车道点的距离来判断
  215.       const lane1Dis = calDistance(roadObj.lanes[0].coord[0], this.trace[this.moveIndex].toArray());
  216.       const lane2Dis = calDistance(roadObj.lanes[1].coord[0], this.trace[this.moveIndex].toArray());
  217.       let temp = null;
  218.       if (lane1Dis < lane2Dis) {
  219.         temp = clone(roadObj.lanes[0].coord);
  220.         this.curLane = roadObj.lanes[0];
  221.       } else {
  222.         temp = clone(roadObj.lanes[1].coord);
  223.         this.curLane = roadObj.lanes[1];
  224.       }
  225.       this.curRoad = roadObj;
  226.       const index = this.findNearIndex(temp, this.trace[this.moveIndex].toArray());
  227.       splitPoint = temp.slice(index + 1);
  228.       // 为了平滑过渡获取道路末端和当前行驶位置的交点
  229.       const corInter = segmentsIntr(splitPoint[0], splitPoint[1], this.trace[this.moveIndex].toArray(), this.trace[this.moveIndex + 1].toArray());
  230.       if (corInter) {
  231.         splitPoint.unshift(corInter);  
  232.       }
  233.       splitPoint.unshift(this.trace[this.moveIndex]);
  234.     }
  235.     
  236.     this.trace = this.getSpreadPoint(splitPoint).map(e => new THREE.Vector3(...e));
  237.     // drawLine(this.target.parent, this.trace);
  238.  
  239.     this.moveIndex = 0;
  240.   }
  241.  
  242.   /**
  243.    * 掉头后获取道路轨迹信息
  244.    */
  245.   getTurnPoint() {
  246.     const roadObj = this.curRoad;
  247.     const nextLane = roadObj.lanes.filter(e => e.name !== this.curLane.name)[0]
  248.     const clonePoint = clone(nextLane.coord);
  249.     clonePoint.unshift(this.trace[this.moveIndex].toArray());
  250.     this.trace = this.getSpreadPoint(clonePoint);
  251.     this.curLane = nextLane;
  252.     // drawLine(this.target.parent, this.trace);
  253.     this.moveIndex = 0;
  254.   }
  255.  
  256.   /**
  257.    * 获取离散点即将点与点之间更加细化，使物体运行起来更加平滑
  258.    * @param {*} points 
  259.    * @returns 
  260.    */
  261.   getSpreadPoint(points, beta = 1) {
  262.     const trail = new THREE.CatmullRomCurve3([...points.map(e => new THREE.Vector3(...e))]);
  263.     return trail.getPoints(trail.getLength() * beta);
  264.   }
  265.  
  266.   /**
  267.    * 将车辆停入停车场内
  268.    */
  269.   parkCar() {
  270.     // 是否允许停车
  271.     if (this.parkEnable) {
  272.       return;
  273.     }
  274.     if (this.parkObj) {
  275.       if (this.direction === -1 && this.moveIndex === this.trace.length - 2) {
  276.         this.pause = true;
  277.         this.parkObj.object.placed = true;
  278.       }
  279.       if (this.moveIndex === this.trace.length - 1) {
  280.         this.direction = -1;
  281.         this.trace = this.parkObj.backTrace;
  282.         // drawLine(this.target.parent, this.trace);
  283.         this.moveIndex = 0;
  284.       } else {
  285.         return;
  286.       }
  287.     } else {
  288.       let flag = false;
  289.       let parkObj = null;
  290.       const frontIndex = 13;
  291.       for (let i = 0; i < this.parks.length; i++) {
  292.         if (calDistance(this.parks[i].entryPoint, this.trace[this.moveIndex].toArray()) < 13 && !this.parks[i].placed) {
  293.           flag = true;
  294.           parkObj = this.parks[i];
  295.           break;
  296.         }
  297.       }
  298.       // return flag;
  299.       if (flag) {
  300.         const random = Math.floor(Math.random() * 2);
  301.         // 1代表停车
  302.         if (random === 1) {
  303.           const front = this.trace.slice(this.moveIndex, this.moveIndex + frontIndex).map(e => new THREE.Vector3(...e));
  304.           const back = this.getSpreadPoint([front[front.length - 1], parkObj.entryPoint, parkObj.position]);
  305.           this.moveIndex = 0;
  306.           this.trace = front;
  307.           this.parkObj = { object: parkObj, backTrace: back };
  308.         }
  309.       }
  310.     }
  311.   }
  312.  
  313.   unParkCar() {
  314.     this.direction = 1;
  315.     const parkObj = this.parkObj.object;
  316.     parkObj.placed = false;
  317.     const index = this.findNearIndex(this.curLane.coord, parkObj.entryPoint);
  318.     const temp = this.curLane.coord.slice(index);
  319.     temp.unshift(parkObj.entryPoint);
  320.     temp.unshift(parkObj.position);
  321.     this.trace = this.getSpreadPoint(temp);
  322.     this.moveIndex = 0;
  323.     this.pause = false;
  324.     this.parkObj = null;
  325.     this.parkEnable = true;
  326.     // 不想再扩展功能了 就在这临时用标识符处理了下出库时不断循环查询车位的情况
  327.     setTimeout(() => {
  328.       this.parkEnable = false;
  329.     }, 3000)
  330.   }
  331.  
  332.   /**
  333.    * 检查岔路口
  334.    */
  335.   checkFork() {
  336.     if (this.trendLock) {
  337.       return [];
  338.     }
  339.     const forks = [];
  340.     for (let i = 0; i < this.curRoad.intersect.length; i++) {
  341.       if (this.moveIndex < this.trace.length - 1) {
  342.         const dis1 = calDistance(this.trace[this.moveIndex].toArray(), this.curRoad.intersect[i].interPoint);
  343.         const dis2 = calDistance(this.trace[this.moveIndex + 1].toArray(), this.curRoad.intersect[i].interPoint);
  344.         if (dis1 < this.curRoad.width && dis1 > dis2) {
  345.           forks.push(this.curRoad.intersect[i].name);
  346.         }
  347.       }
  348.     }
  349.     return forks;
  350.   }
  351. }
  352.  
  353. export default Move;
  354.  
  355. 移动类Move.js

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/683467
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号