update

man.gltf

@@ -0,0 +1,442 @@
+{
+    "asset": {
+        "generator": "FBX2glTF v0.9.7",
+        "version": "2.0"
+    },
+    "scene": 0,
+    "buffers": [
+        {
+            "byteLength": 628596,
+            "uri": "buffer.bin"
+        }
+    ],
+    "bufferViews": [
+        {
+            "buffer": 0,
+            "byteLength": 6864,
+            "byteOffset": 0,
+            "target": 34963
+        },
+        {
+            "buffer": 0,
+            "byteLength": 11880,
+            "byteOffset": 6864,
+            "target": 34962
+        },
+        {
+            "buffer": 0,
+            "byteLength": 11880,
+            "byteOffset": 18744,
+            "target": 34962
+        },
+        {
+            "buffer": 0,
+            "byteLength": 7920,
+            "byteOffset": 30624,
+            "target": 34962
+        },
+        {
+            "buffer": 0,
+            "byteLength": 7920,
+            "byteOffset": 38544,
+            "target": 34962
+        },
+        {
+            "buffer": 0,
+            "byteLength": 93330,
+            "byteOffset": 46464,
+            "target": 34963
+        },
+        {
+            "buffer": 0,
+            "byteLength": 131616,
+            "byteOffset": 139796,
+            "target": 34962
+        },
+        {
+            "buffer": 0,
+            "byteLength": 131616,
+            "byteOffset": 271412,
+            "target": 34962
+        },
+        {
+            "buffer": 0,
+            "byteLength": 87744,
+            "byteOffset": 403028,
+            "target": 34962
+        },
+        {
+            "buffer": 0,
+            "byteLength": 87744,
+            "byteOffset": 490772,
+            "target": 34962
+        },
+        {
+            "buffer": 0,
+            "byteLength": 11520,
+            "byteOffset": 578516,
+            "target": 34963
+        },
+        {
+            "buffer": 0,
+            "byteLength": 11568,
+            "byteOffset": 590036,
+            "target": 34962
+        },
+        {
+            "buffer": 0,
+            "byteLength": 11568,
+            "byteOffset": 601604,
+            "target": 34962
+        },
+        {
+            "buffer": 0,
+            "byteLength": 7712,
+            "byteOffset": 613172,
+            "target": 34962
+        },
+        {
+            "buffer": 0,
+            "byteLength": 7712,
+            "byteOffset": 620884,
+            "target": 34962
+        }
+    ],
+    "scenes": [
+        {
+            "name": "Root Scene",
+            "nodes": [
+                0
+            ]
+        }
+    ],
+    "accessors": [
+        {
+            "componentType": 5123,
+            "type": "SCALAR",
+            "count": 3432,
+            "bufferView": 0,
+            "byteOffset": 0
+        },
+        {
+            "componentType": 5126,
+            "type": "VEC3",
+            "count": 990,
+            "bufferView": 1,
+            "byteOffset": 0,
+            "min": [
+                -18.9603576660156,
+                -1.95723394902283e-15,
+                -28.4676513671875
+            ],
+            "max": [
+                18.9603576660156,
+                145.118713378906,
+                28.4676513671875
+            ]
+        },
+        {
+            "componentType": 5126,
+            "type": "VEC3",
+            "count": 990,
+            "bufferView": 2,
+            "byteOffset": 0
+        },
+        {
+            "componentType": 5126,
+            "type": "VEC2",
+            "count": 990,
+            "bufferView": 3,
+            "byteOffset": 0
+        },
+        {
+            "componentType": 5126,
+            "type": "VEC2",
+            "count": 990,
+            "bufferView": 4,
+            "byteOffset": 0
+        },
+        {
+            "componentType": 5123,
+            "type": "SCALAR",
+            "count": 46665,
+            "bufferView": 5,
+            "byteOffset": 0
+        },
+        {
+            "componentType": 5126,
+            "type": "VEC3",
+            "count": 10968,
+            "bufferView": 6,
+            "byteOffset": 0,
+            "min": [
+                -11.9018993377686,
+                68.2373580932617,
+                -24.3797779083252
+            ],
+            "max": [
+                15.3111619949341,
+                163.219161987305,
+                27.9203186035156
+            ]
+        },
+        {
+            "componentType": 5126,
+            "type": "VEC3",
+            "count": 10968,
+            "bufferView": 7,
+            "byteOffset": 0
+        },
+        {
+            "componentType": 5126,
+            "type": "VEC2",
+            "count": 10968,
+            "bufferView": 8,
+            "byteOffset": 0
+        },
+        {
+            "componentType": 5126,
+            "type": "VEC2",
+            "count": 10968,
+            "bufferView": 9,
+            "byteOffset": 0
+        },
+        {
+            "componentType": 5123,
+            "type": "SCALAR",
+            "count": 5760,
+            "bufferView": 10,
+            "byteOffset": 0
+        },
+        {
+            "componentType": 5126,
+            "type": "VEC3",
+            "count": 964,
+            "bufferView": 11,
+            "byteOffset": 0,
+            "min": [
+                1.17900586128235,
+                152.050842285156,
+                -5.79498147964478
+            ],
+            "max": [
+                4.93187427520752,
+                155.708953857422,
+                2.38377332687378
+            ]
+        },
+        {
+            "componentType": 5126,
+            "type": "VEC3",
+            "count": 964,
+            "bufferView": 12,
+            "byteOffset": 0
+        },
+        {
+            "componentType": 5126,
+            "type": "VEC2",
+            "count": 964,
+            "bufferView": 13,
+            "byteOffset": 0
+        },
+        {
+            "componentType": 5126,
+            "type": "VEC2",
+            "count": 964,
+            "bufferView": 14,
+            "byteOffset": 0
+        }
+    ],
+    "images": [
+        {
+            "name": "3d66Model-582188-files-5.jpg",
+            "uri": "3d66Model-582188-files-5.jpg"
+        },
+        {
+            "name": "3d66Model-582188-files-4.tga",
+            "uri": "3d66Model-582188-files-4.tga"
+        },
+        {
+            "name": "3d66Model-582188-files-1.tga",
+            "uri": "3d66Model-582188-files-1.tga"
+        }
+    ],
+    "samplers": [
+        {}
+    ],
+    "textures": [
+        {
+            "name": "3d66Model-582188-files-5",
+            "sampler": 0,
+            "source": 0
+        },
+        {
+            "name": "3d66Model-582188-files-4",
+            "sampler": 0,
+            "source": 1
+        },
+        {
+            "name": "3d66Model-582188-files-1",
+            "sampler": 0,
+            "source": 2
+        }
+    ],
+    "materials": [
+        {
+            "name": "11 - Default",
+            "alphaMode": "OPAQUE",
+            "extras": {
+                "fromFBX": {
+                    "shadingModel": "Lambert",
+                    "isTruePBR": false
+                }
+            },
+            "pbrMetallicRoughness": {
+                "baseColorTexture": {
+                    "index": 0,
+                    "texCoord": 0
+                },
+                "baseColorFactor": [
+                    1.0,
+                    1.0,
+                    1.0,
+                    1.0
+                ],
+                "metallicFactor": 0.200000002980232,
+                "roughnessFactor": 0.800000011920929
+            }
+        },
+        {
+            "name": "脸",
+            "alphaMode": "OPAQUE",
+            "extras": {
+                "fromFBX": {
+                    "shadingModel": "Phong",
+                    "isTruePBR": false
+                }
+            },
+            "pbrMetallicRoughness": {
+                "baseColorTexture": {
+                    "index": 1,
+                    "texCoord": 0
+                },
+                "baseColorFactor": [
+                    1.0,
+                    1.0,
+                    1.0,
+                    1.0
+                ],
+                "metallicFactor": 0.400000005960464,
+                "roughnessFactor": 0.577350258827209
+            }
+        },
+        {
+            "name": "eye",
+            "alphaMode": "OPAQUE",
+            "extras": {
+                "fromFBX": {
+                    "shadingModel": "Lambert",
+                    "isTruePBR": false
+                }
+            },
+            "pbrMetallicRoughness": {
+                "baseColorTexture": {
+                    "index": 2,
+                    "texCoord": 0
+                },
+                "baseColorFactor": [
+                    1.0,
+                    1.0,
+                    1.0,
+                    1.0
+                ],
+                "metallicFactor": 0.200000002980232,
+                "roughnessFactor": 0.800000011920929
+            }
+        }
+    ],
+    "meshes": [
+        {
+            "name": "工人",
+            "primitives": [
+                {
+                    "material": 0,
+                    "mode": 4,
+                    "attributes": {
+                        "NORMAL": 2,
+                        "POSITION": 1,
+                        "TEXCOORD_0": 3,
+                        "TEXCOORD_1": 4
+                    },
+                    "indices": 0
+                },
+                {
+                    "material": 1,
+                    "mode": 4,
+                    "attributes": {
+                        "NORMAL": 7,
+                        "POSITION": 6,
+                        "TEXCOORD_0": 8,
+                        "TEXCOORD_1": 9
+                    },
+                    "indices": 5
+                },
+                {
+                    "material": 2,
+                    "mode": 4,
+                    "attributes": {
+                        "NORMAL": 12,
+                        "POSITION": 11,
+                        "TEXCOORD_0": 13,
+                        "TEXCOORD_1": 14
+                    },
+                    "indices": 10
+                }
+            ]
+        }
+    ],
+    "nodes": [
+        {
+            "name": "RootNode",
+            "translation": [
+                0.0,
+                0.0,
+                0.0
+            ],
+            "rotation": [
+                0.0,
+                0.0,
+                0.0,
+                1.0
+            ],
+            "scale": [
+                1.0,
+                1.0,
+                1.0
+            ],
+            "children": [
+                1
+            ]
+        },
+        {
+            "name": "工人",
+            "translation": [
+                -0.614349067211151,
+                -0.000239464789046906,
+                -9.87876892089844
+            ],
+            "rotation": [
+                -3.74939939305299e-33,
+                6.12323426292584e-17,
+                1.0,
+                -6.12323426292584e-17
+            ],
+            "scale": [
+                -0.0105760004371405,
+                -0.010177000425756,
+                -0.0103780003264546
+            ],
+            "mesh": 0
+        }
+    ]
+}

package.json

@@ -11,6 +11,7 @@
     "axios": "^0.18.1",
     "core-js": "^3.8.3",
     "element-ui": "^2.15.14",
+    "fbx2gltf": "^0.9.7-p1",
     "less": "^4.2.0",
     "less-loader": "^11.1.3",
     "mitt": "^3.0.1",

public/index.html

@@ -204,4 +204,6 @@
 <script src="./sdk/ShaderPass.js"></script>
 <script src="./sdk/OutlinePass.js"></script>
 <script src="./sdk/OrbitControls.js"></script>
+<script src="./sdk/BufferGeometryUtils.js"></script>
+
 

public/sdk/BufferGeometryUtils.js

@@ -0,0 +1,386 @@
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.BufferGeometryUtils = {
+
+	computeTangents: function ( geometry ) {
+
+		var index = geometry.index;
+		var attributes = geometry.attributes;
+
+		// based on http://www.terathon.com/code/tangent.html
+		// (per vertex tangents)
+
+		if ( index === null ||
+			 attributes.position === undefined ||
+			 attributes.normal === undefined ||
+			 attributes.uv === undefined ) {
+
+			console.warn( 'THREE.BufferGeometry: Missing required attributes (index, position, normal or uv) in BufferGeometry.computeTangents()' );
+			return;
+
+		}
+
+		var indices = index.array;
+		var positions = attributes.position.array;
+		var normals = attributes.normal.array;
+		var uvs = attributes.uv.array;
+
+		var nVertices = positions.length / 3;
+
+		if ( attributes.tangent === undefined ) {
+
+			geometry.addAttribute( 'tangent', new THREE.BufferAttribute( new Float32Array( 4 * nVertices ), 4 ) );
+
+		}
+
+		var tangents = attributes.tangent.array;
+
+		var tan1 = [], tan2 = [];
+
+		for ( var i = 0; i < nVertices; i ++ ) {
+
+			tan1[ i ] = new THREE.Vector3();
+			tan2[ i ] = new THREE.Vector3();
+
+		}
+
+		var vA = new THREE.Vector3(),
+			vB = new THREE.Vector3(),
+			vC = new THREE.Vector3(),
+
+			uvA = new THREE.Vector2(),
+			uvB = new THREE.Vector2(),
+			uvC = new THREE.Vector2(),
+
+			sdir = new THREE.Vector3(),
+			tdir = new THREE.Vector3();
+
+		function handleTriangle( a, b, c ) {
+
+			vA.fromArray( positions, a * 3 );
+			vB.fromArray( positions, b * 3 );
+			vC.fromArray( positions, c * 3 );
+
+			uvA.fromArray( uvs, a * 2 );
+			uvB.fromArray( uvs, b * 2 );
+			uvC.fromArray( uvs, c * 2 );
+
+			var x1 = vB.x - vA.x;
+			var x2 = vC.x - vA.x;
+
+			var y1 = vB.y - vA.y;
+			var y2 = vC.y - vA.y;
+
+			var z1 = vB.z - vA.z;
+			var z2 = vC.z - vA.z;
+
+			var s1 = uvB.x - uvA.x;
+			var s2 = uvC.x - uvA.x;
+
+			var t1 = uvB.y - uvA.y;
+			var t2 = uvC.y - uvA.y;
+
+			var r = 1.0 / ( s1 * t2 - s2 * t1 );
+
+			sdir.set(
+				( t2 * x1 - t1 * x2 ) * r,
+				( t2 * y1 - t1 * y2 ) * r,
+				( t2 * z1 - t1 * z2 ) * r
+			);
+
+			tdir.set(
+				( s1 * x2 - s2 * x1 ) * r,
+				( s1 * y2 - s2 * y1 ) * r,
+				( s1 * z2 - s2 * z1 ) * r
+			);
+
+			tan1[ a ].add( sdir );
+			tan1[ b ].add( sdir );
+			tan1[ c ].add( sdir );
+
+			tan2[ a ].add( tdir );
+			tan2[ b ].add( tdir );
+			tan2[ c ].add( tdir );
+
+		}
+
+		var groups = geometry.groups;
+
+		if ( groups.length === 0 ) {
+
+			groups = [ {
+				start: 0,
+				count: indices.length
+			} ];
+
+		}
+
+		for ( var i = 0, il = groups.length; i < il; ++ i ) {
+
+			var group = groups[ i ];
+
+			var start = group.start;
+			var count = group.count;
+
+			for ( var j = start, jl = start + count; j < jl; j += 3 ) {
+
+				handleTriangle(
+					indices[ j + 0 ],
+					indices[ j + 1 ],
+					indices[ j + 2 ]
+				);
+
+			}
+
+		}
+
+		var tmp = new THREE.Vector3(), tmp2 = new THREE.Vector3();
+		var n = new THREE.Vector3(), n2 = new THREE.Vector3();
+		var w, t, test;
+
+		function handleVertex( v ) {
+
+			n.fromArray( normals, v * 3 );
+			n2.copy( n );
+
+			t = tan1[ v ];
+
+			// Gram-Schmidt orthogonalize
+
+			tmp.copy( t );
+			tmp.sub( n.multiplyScalar( n.dot( t ) ) ).normalize();
+
+			// Calculate handedness
+
+			tmp2.crossVectors( n2, t );
+			test = tmp2.dot( tan2[ v ] );
+			w = ( test < 0.0 ) ? - 1.0 : 1.0;
+
+			tangents[ v * 4 ] = tmp.x;
+			tangents[ v * 4 + 1 ] = tmp.y;
+			tangents[ v * 4 + 2 ] = tmp.z;
+			tangents[ v * 4 + 3 ] = w;
+
+		}
+
+		for ( var i = 0, il = groups.length; i < il; ++ i ) {
+
+			var group = groups[ i ];
+
+			var start = group.start;
+			var count = group.count;
+
+			for ( var j = start, jl = start + count; j < jl; j += 3 ) {
+
+				handleVertex( indices[ j + 0 ] );
+				handleVertex( indices[ j + 1 ] );
+				handleVertex( indices[ j + 2 ] );
+
+			}
+
+		}
+
+	},
+
+	/**
+	 * @param  {Array<THREE.BufferGeometry>} geometries
+	 * @param  {Boolean} useGroups
+	 * @return {THREE.BufferGeometry}
+	 */
+	mergeBufferGeometries: function ( geometries, useGroups ) {
+
+		var isIndexed = geometries[ 0 ].index !== null;
+
+		var attributesUsed = new Set( Object.keys( geometries[ 0 ].attributes ) );
+		var morphAttributesUsed = new Set( Object.keys( geometries[ 0 ].morphAttributes ) );
+
+		var attributes = {};
+		var morphAttributes = {};
+
+		var mergedGeometry = new THREE.BufferGeometry();
+
+		var offset = 0;
+
+		for ( var i = 0; i < geometries.length; ++ i ) {
+
+			var geometry = geometries[ i ];
+
+			// ensure that all geometries are indexed, or none
+
+			if ( isIndexed !== ( geometry.index !== null ) ) return null;
+
+			// gather attributes, exit early if they're different
+
+			for ( var name in geometry.attributes ) {
+
+				if ( ! attributesUsed.has( name ) ) return null;
+
+				if ( attributes[ name ] === undefined ) attributes[ name ] = [];
+
+				attributes[ name ].push( geometry.attributes[ name ] );
+
+			}
+
+			// gather morph attributes, exit early if they're different
+
+			for ( var name in geometry.morphAttributes ) {
+
+				if ( ! morphAttributesUsed.has( name ) ) return null;
+
+				if ( morphAttributes[ name ] === undefined ) morphAttributes[ name ] = [];
+
+				morphAttributes[ name ].push( geometry.morphAttributes[ name ] );
+
+			}
+
+			// gather .userData
+
+			mergedGeometry.userData.mergedUserData = mergedGeometry.userData.mergedUserData || [];
+			mergedGeometry.userData.mergedUserData.push( geometry.userData );
+
+			if ( useGroups ) {
+
+				var count;
+
+				if ( isIndexed ) {
+
+					count = geometry.index.count;
+
+				} else if ( geometry.attributes.position !== undefined ) {
+
+					count = geometry.attributes.position.count;
+
+				} else {
+
+					return null;
+
+				}
+
+				mergedGeometry.addGroup( offset, count, i );
+
+				offset += count;
+
+			}
+
+		}
+
+		// merge indices
+
+		if ( isIndexed ) {
+
+			var indexOffset = 0;
+			var mergedIndex = [];
+
+			for ( var i = 0; i < geometries.length; ++ i ) {
+
+				var index = geometries[ i ].index;
+
+				for ( var j = 0; j < index.count; ++ j ) {
+
+					mergedIndex.push( index.getX( j ) + indexOffset );
+
+				}
+
+				indexOffset += geometries[ i ].attributes.position.count;
+
+			}
+
+			mergedGeometry.setIndex( mergedIndex );
+
+		}
+
+		// merge attributes
+
+		for ( var name in attributes ) {
+
+			var mergedAttribute = this.mergeBufferAttributes( attributes[ name ] );
+
+			if ( ! mergedAttribute ) return null;
+
+			mergedGeometry.addAttribute( name, mergedAttribute );
+
+		}
+
+		// merge morph attributes
+
+		for ( var name in morphAttributes ) {
+
+			var numMorphTargets = morphAttributes[ name ][ 0 ].length;
+
+			if ( numMorphTargets === 0 ) break;
+
+			mergedGeometry.morphAttributes = mergedGeometry.morphAttributes || {};
+			mergedGeometry.morphAttributes[ name ] = [];
+
+			for ( var i = 0; i < numMorphTargets; ++ i ) {
+
+				var morphAttributesToMerge = [];
+
+				for ( var j = 0; j < morphAttributes[ name ].length; ++ j ) {
+
+					morphAttributesToMerge.push( morphAttributes[ name ][ j ][ i ] );
+
+				}
+
+				var mergedMorphAttribute = this.mergeBufferAttributes( morphAttributesToMerge );
+
+				if ( ! mergedMorphAttribute ) return null;
+
+				mergedGeometry.morphAttributes[ name ].push( mergedMorphAttribute );
+
+			}
+
+		}
+
+		return mergedGeometry;
+
+	},
+
+	/**
+	 * @param {Array<THREE.BufferAttribute>} attributes
+	 * @return {THREE.BufferAttribute}
+	 */
+	mergeBufferAttributes: function ( attributes ) {
+
+		var TypedArray;
+		var itemSize;
+		var normalized;
+		var arrayLength = 0;
+
+		for ( var i = 0; i < attributes.length; ++ i ) {
+
+			var attribute = attributes[ i ];
+
+			if ( attribute.isInterleavedBufferAttribute ) return null;
+
+			if ( TypedArray === undefined ) TypedArray = attribute.array.constructor;
+			if ( TypedArray !== attribute.array.constructor ) return null;
+
+			if ( itemSize === undefined ) itemSize = attribute.itemSize;
+			if ( itemSize !== attribute.itemSize ) return null;
+
+			if ( normalized === undefined ) normalized = attribute.normalized;
+			if ( normalized !== attribute.normalized ) return null;
+
+			arrayLength += attribute.array.length;
+
+		}
+
+		var array = new TypedArray( arrayLength );
+		var offset = 0;
+
+		for ( var i = 0; i < attributes.length; ++ i ) {
+
+			array.set( attributes[ i ].array, offset );
+
+			offset += attributes[ i ].array.length;
+
+		}
+
+		return new THREE.BufferAttribute( array, itemSize, normalized );
+
+	}
+
+};

src/components/MyLayout/index.less

@@ -35,3 +35,13 @@ html {
   height: 100%;
   z-index: -1;
 }
+.collision-menu{
+  margin-left: 25vw;
+  margin-top: 5vh;
+  position: absolute;
+  width: 50vw !important;
+  height: 10.81vh;
+  color: white;
+  font-size:xx-large;
+  scale: 2;
+}

src/components/MyLayout/index.vue

@@ -1,5 +1,6 @@
 <template>
   <el-container class="el-container" id="elcontainerid">   
+    <div class="collision-menu" id="collisionmenuid">碰撞检测中</div>
     <div class="el-aside">
       <div class="side-menu">
         <div class="top">
@@ -31,6 +32,8 @@
       components: {NavMenu},
       methods:{
         modeChange() {
+          window.location.href = 'https://zh3x.cn/webgl/';
+          return;
           // window.sdkInstance.changeMode("panorama");
           // this.$router.push({path: '/home?m=8b934420_ZJUb_b6f9'})
           if(window.location.href.indexOf('home')!==-1)

src/uwb-sample.js

@@ -61,6 +61,7 @@ Date.prototype.Format = function (fmt) {
 
 let dracoLoader = null;
 let g_sqlResult = null;
+let g_childMeshTmp = null;
 
 function getsqlData() {
   if(g_PosArrayResult == null)
@@ -114,8 +115,12 @@ function getsqlData() {
       THREE.DRACOLoader.setDecoderPath("../gltf/");
       var fbxLoader1 = new THREE.GLTFLoader();
       fbxLoader1.setDRACOLoader(dracoLoader);
+      
+      var bMovingMan = false;
+
+      fbxLoader1.load("../models/man.gltf", function (fbx) {
 
-      fbxLoader1.load("../models/meshDraco.gltf", function (fbx) {
+        console.log("success",g_sqlResult)
 
       let result = g_sqlResult;
       for (var item of result) {
@@ -199,10 +204,28 @@ function getsqlData() {
         let show_remote_button = item.show_remote_button;
         if(benchType == 1)
         {
-          console.log("控制台查看加载gltf文件返回的对象结构", fbx);
-          var childMesh = childMesh = fbx.scene.children[0].children[0];
-          let childMeshTmp = new THREE.Mesh(childMesh.geometry,childMesh.material)
-          let scale = 5;
+          //console.log("控制台查看加载gltf文件返回的对象结构", fbx);
+          var childMesh = fbx.scene.children[0].children[1].children[1];
+
+
+          let geometryArray = []; // 将你的要合并的多个geometry放入到该数组
+          let materialArray = []; // 将你的要赋值的多个material放入到该数组
+          let arr = fbx.scene.children[0].children[1].children;
+          for(let i = 0;i<arr.length;i++){
+            geometryArray.push(arr[i].geometry)
+            materialArray.push(arr[i].material)
+          }
+          console.log('geo',geometryArray,materialArray)
+          // 合并模型
+          const mergedGeometries = THREE.BufferGeometryUtils.mergeBufferGeometries(geometryArray, true);
+          console.log('zmg1');
+          const singleMergeMesh = new THREE.Mesh(mergedGeometries, materialArray);
+          //scene.add( singleMerge ); // 在场景中添加合并后的mesh(模型)
+          console.log('singleMergeMesh',singleMergeMesh)
+
+          //let childMeshTmp = new THREE.Mesh(childMesh.geometry,childMesh.material)
+          let childMeshTmp = singleMergeMesh;
+          let scale = 0.1;
           childMeshTmp.scale.set(scale, scale, scale)
           //fbx.scene.children[0].scale.set(5, 5, 5)
           //fbx.scene.children[0].position.set(8.7, -1.6, 5.4)
@@ -219,6 +242,62 @@ function getsqlData() {
           childMeshTmp.userData = customData;
 
           sdkInstance.sceneRenderer.scene.add(childMeshTmp)
+
+          
+          
+
+          if(bMovingMan == false)
+          {
+            g_childMeshTmp = childMeshTmp
+            bMovingMan = true;
+            var startX = 8.7;
+            var startY = 50;
+            var endX = 20;
+            var endY = 15;
+            var speed = 1;
+            var distance = Math.sqrt((endX - startX)*(endX - startX)+(endY - startY)*(endY - startY))
+            var sin = (endX - startX)/distance
+            var cos = (endY - startY)/distance
+            var direct = 1;
+            var curX = 8.7;
+            var curY = 50;
+            var distanceOffset = 5;
+            var xOffset = 10
+            setInterval(()=>{
+              if(curX>endX || curX<startX)
+              {
+                direct*=-1;
+              }
+              curX+=direct*sin*speed;
+              curY+=direct*cos*speed;
+              let z = 0.75;
+              if(curX>xOffset)
+              {
+                z=-1;
+              }
+
+              g_childMeshTmp.position.set(curX, z, curY)
+              var distanceCur = Math.sqrt((endX - curX)*(endX - curX)+(endY - curY)*(endY - curY))
+              var objText = document.getElementById('collisionmenuid')
+              if(distanceCur<distanceOffset)
+              {
+                objText.textContent = ''
+                setTimeout(()=>{
+                  objText.textContent = '碰撞危险报警，距离塔吊'+distanceCur.toFixed(2)+'米'
+                  objText.style.color = 'red';
+                },100)
+                
+              }
+              else
+              {
+                objText.textContent = ''
+                setTimeout(()=>{
+                  objText.textContent = '未检测到碰撞危险，距离塔吊'+distanceCur.toFixed(2)+'米'
+                  objText.style.color = 'white';
+                },100)
+              }
+            },1000)
+          }
         }
         
       };
@@ -226,7 +305,7 @@ function getsqlData() {
       var fbxLoader2 = new THREE.GLTFLoader();
       fbxLoader2.setDRACOLoader(dracoLoader);
 
-      fbxLoader2.load("../models/mesh2Draco.gltf", function (fbx) {
+      fbxLoader2.load("../models/crane.gltf", function (fbx) {
 
         let result = g_sqlResult;
       for (var item of result) {
@@ -312,7 +391,65 @@ function getsqlData() {
         {
           console.log("控制台查看加载gltf文件返回的对象结构", fbx);
           var childMesh = fbx.scene.children[0];
-          let childMeshTmp = new THREE.Mesh(childMesh.geometry,childMesh.material)
+          let arrTop = fbx.scene.children[0].children[0].children
+          let geometryArrayTop = []; // 将你的要合并的多个geometry放入到该数组
+          let materialArrayTop = []; // 将你的要赋值的多个material放入到该数组
+          
+          for(let iTop = 0;iTop<arrTop.length;iTop++){
+          //for(let iTop = 0;iTop<1;iTop++){
+            let geometryArray = []; // 将你的要合并的多个geometry放入到该数组
+            let materialArray = []; // 将你的要赋值的多个material放入到该数组
+            if(iTop == 9)
+            {
+              geometryArrayTop.push(arrTop[iTop].geometry)
+              materialArrayTop.push(arrTop[iTop].material) 
+            }
+            else
+            {
+              let arr = arrTop[iTop].children;
+            
+              for(let i = 0;i<arr.length;i++){
+                //geometryArray.push(arr[i].geometry)
+                //materialArray.push(arr[i].material)
+                geometryArrayTop.push(arr[i].geometry)
+                materialArrayTop.push(arr[i].material)
+              }
+              //console.log('geo3',geometryArray,materialArray,arr)
+              //// 合并模型
+              //const mergedGeometries = THREE.BufferGeometryUtils.mergeBufferGeometries(geometryArray, true);
+              //console.log('zmg1');
+              //const singleMergeMesh = new THREE.Mesh(mergedGeometries, materialArray);
+              ////scene.add( singleMerge ); // 在场景中添加合并后的mesh(模型)
+              //console.log('singleMergeMesh',singleMergeMesh)
+//
+              //geometryArrayTop.push(singleMergeMesh.geometry)
+              //materialArrayTop.push(singleMergeMesh.material)
+            }
+            
+
+            //let childMeshTmp = new THREE.Mesh(childMesh.geometry,childMesh.material)
+            
+          }
+
+          //let geometryArray2 = []; // 将你的要合并的多个geometry放入到该数组
+          //let materialArray2 = []; // 将你的要赋值的多个material放入到该数组
+          
+          //for(let j = 0;j<10;j++){
+          //  //const singleMergeMesh = new THREE.Mesh(mergedGeometries, materialArrayTop);
+          //  const singleMergeMesh = new THREE.Mesh(geometryArrayTop[j], materialArrayTop[j]);
+          //  //scene.add( singleMerge ); // 在场景中添加合并后的mesh(模型)
+          //  console.log('singleMergeMesh',singleMergeMesh)
+          //  geometryArray2.push(singleMergeMesh.geometry)
+          //  materialArray2.push(singleMergeMesh.material)
+          //}
+          const mergedGeometries2 = THREE.BufferGeometryUtils.mergeBufferGeometries(geometryArrayTop, true);
+          //const singleMergeMesh = new THREE.Mesh(mergedGeometries, materialArrayTop);
+          const singleMergeMesh = new THREE.Mesh(mergedGeometries2, materialArrayTop);
+          //scene.add( singleMerge ); // 在场景中添加合并后的mesh(模型)
+          console.log('singleMergeMesh',singleMergeMesh)
+          
+          let childMeshTmp = singleMergeMesh;
+
           let scale = 0.05;
           childMeshTmp.scale.set(scale, scale, scale)
           //fbx.scene.children[0].scale.set(5, 5, 5)