Merge branch 'v1.2.0-ga' of http://192.168.0.115:3000/bill/fuse-code into v1.2.0-ga

public/lib/potree/potree.js

@@ -81691,14 +81691,19 @@
 	  }
 	  at(time, delta) {
 	    var _this = this;
-	    if (time > this.duration + maxClipFadeTime / 2) return;
+	    if (time > this.duration + maxClipFadeTime / 2) {
+	      for (var [model, keys] of this.clipKeys) {
+	        model.actions.forEach(a => a.stop());
+	      }
+	      return;
+	    }
 	    var transitionRatio = 0.05 * delta * 60; //渐变系数，越小缓动程度越高，越平滑 //假设标准帧率为60fps，当帧率低时（delta大时） 降低缓动。速度快时缓动太高会偏移路径
 	    var _loop = function _loop() {
 	      var atPath; //是否在path中 至多只有一个 
 	      var fadeToPath; //是否在过渡到path中
 	      var fadeFromPath; //是否从path中过渡到下一pose
 	      //以上三个权重越来越小，但都比pose大
-	      keys.find(key => {
+	      _keys.find(key => {
 	        if (key.path.points.length < 2) return;
 	        var startToFade = key.time - maxClipFadeTime / 2;
 	        var endFade = key.time + key.dur + maxClipFadeTime / 2;
@@ -81715,7 +81720,7 @@
 	          }
 	        }
 	      });
-	      pathStates.set(model, {
+	      pathStates.set(_model, {
 	        atPath,
 	        fadeToPath,
 	        fadeFromPath
@@ -81727,37 +81732,37 @@
 	          position: _position,
 	          quaternion: _quaternion
 	        } = _this.getPoseAtPathKey(atPath, percent);
-	        model.position.copy(_position);
-	        _quaternion && model.quaternion.copy(_quaternion);
+	        _model.position.copy(_position);
+	        _quaternion && _model.quaternion.copy(_quaternion);
 	      } else if (fadeToPath) {
 	        var {
 	          position: _position2,
 	          quaternion: _quaternion2
 	        } = _this.getPoseAtPathKey(fadeToPath, 0);
-	        _quaternion2 && lerp.quaternion(model.quaternion, _quaternion2)(transitionRatio); //每次只改变一点点  
-	        lerp.vector(model.position, _position2)(transitionRatio);
+	        _quaternion2 && lerp.quaternion(_model.quaternion, _quaternion2)(transitionRatio); //每次只改变一点点  
+	        lerp.vector(_model.position, _position2)(transitionRatio);
 	      }
 	      if (atPath || fadeToPath) {
-	        model.dispatchEvent('position_changed'); //暂时都这么写，以后再判断是否真的改变了
-	        model.dispatchEvent('rotation_changed');
+	        _model.dispatchEvent('position_changed'); //暂时都这么写，以后再判断是否真的改变了
+	        _model.dispatchEvent('rotation_changed');
 	      }
 	    };
-	    for (var [model, keys] of this.pathKeys) {
+	    for (var [_model, _keys] of this.pathKeys) {
 	      _loop();
 	    }
-	    for (var [_model, _keys] of this.poseKeys) {
+	    for (var [_model2, _keys2] of this.poseKeys) {
 	      /* keys = keys.filter(e=>e.pos && e.scale && e.qua)*/
-	      if (_keys.length == 0) continue;
+	      if (_keys2.length == 0) continue;
 	      var {
 	        atPath,
 	        fadeFromPath,
 	        fadeToPath
-	      } = pathStates.get(_model) || {};
-	      tweens.scale = new Tween$1(_keys.map(e => e.time), _keys.map(e => e.scale));
-	      _model.scale.copy(tweens.scale.lerp(time));
+	      } = pathStates.get(_model2) || {};
+	      tweens.scale = new Tween$1(_keys2.map(e => e.time), _keys2.map(e => e.scale));
+	      _model2.scale.copy(tweens.scale.lerp(time));
 	      if (!atPath && !fadeToPath) {
-	        tweens.pos = new Tween$1(_keys.map(e => e.time), _keys.map(e => e.pos));
-	        tweens.qua = new Tween$1(_keys.map(e => e.time), _keys.map(e => e.qua));
+	        tweens.pos = new Tween$1(_keys2.map(e => e.time), _keys2.map(e => e.pos));
+	        tweens.qua = new Tween$1(_keys2.map(e => e.time), _keys2.map(e => e.qua));
 	        var time_ = time;
 	        if (fadeFromPath) {
 	          //但如果开始播放时模型已经在fadeFromPath这个区间里，也是直接过渡过去
@@ -81766,22 +81771,22 @@
 	        var position = tweens.pos.lerp(time_);
 	        var quaternion = tweens.qua.lerp(time_);
 	        if (fadeFromPath) {
-	          lerp.quaternion(_model.quaternion, quaternion)(transitionRatio); //每次只改变一点点  
-	          lerp.vector(_model.position, position)(transitionRatio);
+	          lerp.quaternion(_model2.quaternion, quaternion)(transitionRatio); //每次只改变一点点  
+	          lerp.vector(_model2.position, position)(transitionRatio);
 	        } else {
-	          _model.position.copy(position);
-	          _model.quaternion.copy(quaternion);
+	          _model2.position.copy(position);
+	          _model2.quaternion.copy(quaternion);
 	        }
 	      }
-	      _model.dispatchEvent('position_changed');
-	      _model.dispatchEvent('rotation_changed');
+	      _model2.dispatchEvent('position_changed');
+	      _model2.dispatchEvent('rotation_changed');
 	    }
-	    var _loop2 = function _loop2(_keys2) {
-	      if (_keys2.length == 0) return 1; // continue
-	      var weights = _keys2.map((key, i) => {
-	        var _keys3, _keys4;
-	        var fadeTimeStart = Math.min(maxClipFadeTime, key.dur, ((_keys3 = _keys2[i - 1]) === null || _keys3 === void 0 ? void 0 : _keys3.dur) || maxClipFadeTime) / 2; //half of dur
-	        var fadeTimeEnd = Math.min(maxClipFadeTime, key.dur, ((_keys4 = _keys2[i + 1]) === null || _keys4 === void 0 ? void 0 : _keys4.dur) || maxClipFadeTime) / 2;
+	    var _loop2 = function _loop2(_keys3) {
+	      if (_keys3.length == 0) return 1; // continue
+	      var weights = _keys3.map((key, i) => {
+	        var _keys4, _keys5;
+	        var fadeTimeStart = Math.min(maxClipFadeTime, key.dur, ((_keys4 = _keys3[i - 1]) === null || _keys4 === void 0 ? void 0 : _keys4.dur) || maxClipFadeTime) / 2; //half of dur
+	        var fadeTimeEnd = Math.min(maxClipFadeTime, key.dur, ((_keys5 = _keys3[i + 1]) === null || _keys5 === void 0 ? void 0 : _keys5.dur) || maxClipFadeTime) / 2;
 	        var startTime1 = key.time - fadeTimeStart;
 	        var endTime1 = key.time + key.dur + fadeTimeEnd;
 	        if (time < startTime1 || time > endTime1) return 0; //out bound 
@@ -81797,14 +81802,14 @@
 	      }); //最多有两个>0的，在过渡, 且能保证两个是不同的action
 
 	      var animateActions = []; //在播的动作
-	      _keys2.forEach((key, i) => {
+	      _keys3.forEach((key, i) => {
 	        weights[i] > 0 && !animateActions.includes(key.action) && animateActions.push(key.action);
 	      });
 
 	      //console.log(time, model.name, weights)
 
 	      var speed = 0;
-	      _keys2.forEach((key, i) => {
+	      _keys3.forEach((key, i) => {
 	        if (animateActions.includes(key.action)) {
 	          var weight = weights[i] * key.weight;
 	          if (weight > 0) {
@@ -81816,7 +81821,7 @@
 	          key.action.stop();
 	        }
 	      });
-	      _model2.mixer.timeScale = speed;
+	      _model3.mixer.timeScale = speed;
 
 	      /* let key = keys.find(key=>key.time < time && key.time + key.dur > time) 
 	      let action = key?.action
@@ -81832,8 +81837,8 @@
 	            //inKey.action.paused
 	      } */
 	    };
-	    for (var [_model2, _keys2] of this.clipKeys) {
-	      if (_loop2(_keys2)) continue;
+	    for (var [_model3, _keys3] of this.clipKeys) {
+	      if (_loop2(_keys3)) continue;
 	    }
 	    {
 	      if (this.camFollowObject) {
@@ -81842,11 +81847,11 @@
 
 	        if (this.camFollowObject.length == 1) {
 	          var dis = 4;
-	          var _model3 = this.camFollowObject[0];
-	          dir.multiplyScalar(dis).applyQuaternion(_model3.quaternion);
-	          var pos = new Vector3().addVectors(_model3.boundCenter, dir);
+	          var _model4 = this.camFollowObject[0];
+	          dir.multiplyScalar(dis).applyQuaternion(_model4.quaternion);
+	          var pos = new Vector3().addVectors(_model4.boundCenter, dir);
 	          viewer.mainViewport.view.position.copy(pos);
-	          viewer.mainViewport.view.lookAt(_model3.boundCenter);
+	          viewer.mainViewport.view.lookAt(_model4.boundCenter);
 	        } else {
 	          /* let dirAve = new THREE.Vector3
 	          this.camFollowObject.forEach(model=>{
@@ -81927,12 +81932,12 @@
 	    for (var [model, keys] of this.poseKeys) {
 	      keys.length > 0 && (maxTime = Math.max(maxTime, keys[keys.length - 1].time));
 	    }
-	    for (var [_model4, _keys5] of this.clipKeys) {
-	      _keys5.length > 0 && (maxTime = Math.max(maxTime, _keys5[_keys5.length - 1].time + _keys5[_keys5.length - 1].dur));
-	    }
-	    for (var [_model5, _keys6] of this.pathKeys) {
+	    for (var [_model5, _keys6] of this.clipKeys) {
 	      _keys6.length > 0 && (maxTime = Math.max(maxTime, _keys6[_keys6.length - 1].time + _keys6[_keys6.length - 1].dur));
 	    }
+	    for (var [_model6, _keys7] of this.pathKeys) {
+	      _keys7.length > 0 && (maxTime = Math.max(maxTime, _keys7[_keys7.length - 1].time + _keys7[_keys7.length - 1].dur));
+	    }
 	    this.duration = maxTime; //不算开始和结束动画的过渡时间的话
 
 	    /* for(let [model, keys] of this.clipKeys){
@@ -82066,8 +82071,8 @@
 	    for (var [model, keys] of this.clipKeys) {
 	      _loop3(model);
 	    }
-	    for (var [_model6, _keys7] of this.poseKeys) {
-	      data.poseKeys[_model6.name] = _keys7.map(key => {
+	    for (var [_model7, _keys8] of this.poseKeys) {
+	      data.poseKeys[_model7.name] = _keys8.map(key => {
 	        return {
 	          qua: key.qua.toArray(),
 	          pos: key.pos.toArray(),

src/sdk/cover/index.js

@@ -1355,6 +1355,9 @@ export const enter = ({ dom, mapDom, isLocal, lonlat, scenes, laserRoot, laserOS
                 let time = /* THREE.Math.clamp( */e.time/* , 0, AnimationEditor.duration) */
                 bus.emit('currentTime',time)
             })
+            /* AnimationEditor.addEventListener('stop',e=>{
+                bus.emit('stop') 
+            }) */
             
             let funs = {
                 bus,
@@ -1383,6 +1386,7 @@ export const enter = ({ dom, mapDom, isLocal, lonlat, scenes, laserRoot, laserOS
                         url: data.url,
                         title: data.title, 
                         fromType: 8, raw:{}, 
+                        //renderType : 'normal', //色彩好些，否则MeshBasic颜色偏深
                         type:'glb',  id:data.id
                     }
                     
@@ -1466,11 +1470,11 @@ export const enter = ({ dom, mapDom, isLocal, lonlat, scenes, laserRoot, laserOS
                             let key = Object.assign({},frame) 
                                 key.weight = key.amplitude || 1 //幅度
                                 key.speed = key.speed || 1
-                                key.actionIndex = model.actions.findIndex(e=>e.name == key.key)
-                                if(key.actionIndex == -1){
+                                key.action = model.actions.find(e=>e.name == key.key)
+                                if(!key.action){
                                     //return console.error('cannot find action', key.key)
                                     console.log('没找到动作，暂时先用第一个')
-                                    key.actionIndex = 0
+                                    key.action = model.actions[0]
                                 }   
                                 delete key.amplitude
                                 delete key.key
@@ -1541,7 +1545,7 @@ export const enter = ({ dom, mapDom, isLocal, lonlat, scenes, laserRoot, laserOS
                         
                         getCurrentSubtitlePixel({width , height}){// 获取当前模型旁白出现的适合位置，传入旁边dom的宽高，返回像素位置
                             let bound = model.boundingBox 
-                            let boundPoint = [  
+                            let boundPoints = [  
                                 new THREE.Vector3(bound.min.x, bound.min.y, bound.min.z ),
                                 new THREE.Vector3(bound.min.x, bound.min.y, bound.max.z ), 
                                 new THREE.Vector3(bound.min.x, bound.max.y, bound.min.z ),
@@ -1551,24 +1555,28 @@ export const enter = ({ dom, mapDom, isLocal, lonlat, scenes, laserRoot, laserOS
                                 new THREE.Vector3(bound.min.x, bound.max.y, bound.max.z ),
                                 new THREE.Vector3(bound.max.x, bound.max.y, bound.max.z ),
                             ];
-                            let pos2ds = boundPoint.map((point)=>{
-                                return Potree.Utils.getPos2d(point, viewer.mainViewport , viewer.renderArea, viewer.renderer  )
+                            let pos2ds = boundPoints.map((point)=>{ 
+                                return Potree.Utils.getPos2d(point.applyMatrix4(model.matrixWorld), viewer.mainViewport , viewer.renderArea, viewer.renderer  )
                             }).filter(e=>e.inSight && e.trueSide )
                             if(pos2ds.length == 0)return
                             
-                             
+                            pos2ds.sort((a,b)=>{return a.vector.y - b.vector.y})
+                            let top = pos2ds[0], btm = pos2ds[pos2ds.length - 1] 
+                            let centerY = (top.pos.y + btm.pos.y) / 2
+                            
                             pos2ds.sort((a,b)=>{return a.vector.x - b.vector.x})
                             let left = pos2ds[0], right = pos2ds[pos2ds.length - 1] 
+                            
                             let leftPad = left.vector.x - (-1) //模型左侧空出的宽度
                             let rightPad = 1 - right.vector.y
-                            let x,y //返回字幕左上角位置
-                            let margin = 30;
+                            const margin = 10;
+                            let x
+                            let y = centerY - height/2 //返回字幕左上角位置
+                            
                             if(leftPad > rightPad){//向左侧扩展
-                                x = left.pos.x - margin - width
-                                y = left.pos.y - height/2
+                                x = left.pos.x - margin - width 
                             }else{
-                                x = left.pos.x + margin 
-                                y = left.pos.y - height/2 
+                                x = right.pos.x + margin  
                             }
                             return {x,y}
                         },