fix: ani

public/lib/potree/potree.js

@@ -82202,11 +82202,12 @@
 	      time
 	    }); //该时间可以大于本动画持续时间
 	    this.cursorTime = time;
-	    if (time > this.duration + maxClipFadeTime / 2) {
-	      for (var [model, keys] of this.clipKeys) {
-	        model.actions.forEach(a => a.stop());
-	      }
-	    }
+	    /* if(time > this.duration + maxClipFadeTime/2){  
+	        for(let [model, keys] of this.clipKeys){
+	            model.actions.forEach(a=>a.stop())
+	        } 
+	    } */
+
 	    var maxTime = this.duration + maxClipFadeTime / 2;
 	    if (time >= maxTime) time = maxTime;
 	    if (this.time == time && !force) return;
@@ -82221,7 +82222,7 @@
 	      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;
@@ -82238,7 +82239,7 @@
 	          }
 	        }
 	      });
-	      pathStates.set(_model, {
+	      pathStates.set(model, {
 	        atPath,
 	        fadeToPath,
 	        fadeFromPath
@@ -82250,37 +82251,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 [_model2, _keys2] of this.poseKeys) {
+	    for (var [_model, _keys] of this.poseKeys) {
 	      /* keys = keys.filter(e=>e.pos && e.scale && e.qua)*/
-	      if (_keys2.length == 0) continue;
+	      if (_keys.length == 0) continue;
 	      var {
 	        atPath,
 	        fadeFromPath,
 	        fadeToPath
-	      } = 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));
+	      } = 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));
 	      if (!atPath && !fadeToPath) {
-	        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));
+	        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));
 	        var time_ = time;
 	        if (fadeFromPath) {
 	          //但如果开始播放时模型已经在fadeFromPath这个区间里，也是直接过渡过去
@@ -82289,52 +82290,60 @@
 	        var position = tweens.pos.lerp(time_);
 	        var quaternion = tweens.qua.lerp(time_);
 	        if (fadeFromPath) {
-	          lerp.quaternion(_model2.quaternion, quaternion)(transitionRatio); //每次只改变一点点  
-	          lerp.vector(_model2.position, position)(transitionRatio);
+	          lerp.quaternion(_model.quaternion, quaternion)(transitionRatio); //每次只改变一点点  
+	          lerp.vector(_model.position, position)(transitionRatio);
 	        } else {
 	          if (this.poseTransition && delta != void 0) {
-	            lerp.quaternion(_model2.quaternion, quaternion)(transitionRatio2); //每次只改变一点点  
-	            lerp.vector(_model2.position, position)(transitionRatio2);
+	            lerp.quaternion(_model.quaternion, quaternion)(transitionRatio2); //每次只改变一点点  
+	            lerp.vector(_model.position, position)(transitionRatio2);
 	          } else {
-	            _model2.position.copy(position);
-	            _model2.quaternion.copy(quaternion);
+	            _model.position.copy(position);
+	            _model.quaternion.copy(quaternion);
 	          }
 	        }
 	      }
-	      _model2.dispatchEvent('position_changed');
-	      _model2.dispatchEvent('rotation_changed');
+	      _model.dispatchEvent('position_changed');
+	      _model.dispatchEvent('rotation_changed');
 	    }
-	    var _loop2 = function _loop2(_keys3) {
-	      if (_keys3.length == 0) return 1; // continue
-	      var weights = _keys3.map((key, i) => {
-	        var _keys4, _keys5;
+	    var _loop2 = function _loop2(_keys2) {
+	      if (_keys2.length == 0) return 1; // continue
+	      var weights = _keys2.map((key, i) => {
+	        var _keys3, _keys4;
 	        //计算每个动作权重（幅度）。  
 
 	        /* if(delta == void 0){//无缓动  但会造成和缓动时动作time不同
 	            return time >= key.time && time <= key.time + key.dur ? 1 : 0
 	        } */
 
-	        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; //过渡时间不超过当前和后一个的 half of dur
+	        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; //过渡时间不超过当前和后一个的 half of dur
 
 	        var startTime1 = key.time - fadeTimeStart;
 	        var endTime1 = key.time + key.dur + fadeTimeEnd;
-	        if (time < startTime1 || time > endTime1) return 0; //out bound 
-
-	        key.tempTime_ = time - startTime1; //当前动作时间 
-
 	        var startTime2 = key.time + fadeTimeStart;
 	        var endTime2 = key.time + key.dur - fadeTimeEnd;
-	        if (time >= startTime2 && time <= endTime2) return 1;
-	        if (time < startTime2) {
-	          return Potree.math.linearClamp(time, [startTime1, startTime2], [0, 1]);
+	        key.tempTime_ = time - startTime1; //当前动作时间 
+
+	        if (i == _keys2.length - 1 && time > endTime2) {
+	          //所有动作播完后维持最后一个动作
+	          key.tempTime_ = Math.min(key.tempTime_, key.dur);
+	          return 1;
 	        } else {
-	          return Potree.math.linearClamp(time, [endTime2, endTime1], [1, 0]);
+	          if (time < startTime1 || time > endTime1) return 0; //out bound 
+
+	          key.tempTime_ = time - startTime1; //当前动作时间 
+
+	          if (time >= startTime2 && time <= endTime2) return 1;
+	          if (time < startTime2) {
+	            return Potree.math.linearClamp(time, [startTime1, startTime2], [0, 1]);
+	          } else {
+	            return Potree.math.linearClamp(time, [endTime2, endTime1], [1, 0]);
+	          }
 	        }
 	      }); //最多有两个>0的，在过渡 
 
 	      var animateActions = []; //在播的动作
-	      _keys3.forEach((key, i) => {
+	      _keys2.forEach((key, i) => {
 	        weights[i] > 0 && !animateActions.includes(key.action) && (animateActions.push(key.action), key.action.tempSW_ = {
 	          scale: 0,
 	          weight: 0,
@@ -82343,7 +82352,7 @@
 	      });
 	      //万一前后是一个动作…… 所以用tempSW_计算总值
 
-	      _keys3.forEach((key, i) => {
+	      _keys2.forEach((key, i) => {
 	        if (animateActions.includes(key.action)) {
 	          var weight = weights[i] * key.weight; //权重乘以自身幅度
 	          if (weight > 0) {
@@ -82351,7 +82360,7 @@
 	            key.action.paused = time != key.time || delta != void 0; //停在某帧 //如果没有点击该动作块的话 不停
 
 	            key.action.tempSW_.time == null && (key.action.tempSW_.time = key.tempTime_); //相同动作优先用前一个的时间
-	            key.action.tempSW_.scale += weights[i] * key.speed; //乘以一个weight缓动 
+	            key.action.tempSW_.scale += key.speed; // * weights[i] //乘以weight在开始和结束作为缓动效果好，但是不好计算实时time
 	            key.action.tempSW_.weight += weight;
 	          }
 	        } else {
@@ -82366,31 +82375,31 @@
 
 	      //model.mixer.timeScale = 1 ;
 	    };
-	    for (var [_model3, _keys3] of this.clipKeys) {
-	      if (_loop2(_keys3)) continue;
+	    for (var [_model2, _keys2] of this.clipKeys) {
+	      if (_loop2(_keys2)) continue;
 	    }
 	    {
 	      if (this.camFollowObject && !viewer.scene.monitors.some(e => e.isWatching)) {
 	        //in front of model 
 	        if (this.camFollowObject.length == 1) {
-	          var _model4 = this.camFollowObject[0];
+	          var _model3 = this.camFollowObject[0];
 	          if (viewer.images360.latestRequestMode == 'showPointCloud') {
 	            if (this.camFaceToObject) {
 	              var dis = 4;
 	              var dir = new Vector3(0, 0.1, 1).normalize(); //稍微朝上
-	              dir.multiplyScalar(dis).applyQuaternion(_model4.quaternion);
-	              var pos = new Vector3().addVectors(_model4.boundCenter, dir);
+	              dir.multiplyScalar(dis).applyQuaternion(_model3.quaternion);
+	              var pos = new Vector3().addVectors(_model3.boundCenter, dir);
 	              viewer.mainViewport.view.position.copy(pos);
-	              viewer.mainViewport.view.lookAt(_model4.boundCenter);
+	              viewer.mainViewport.view.lookAt(_model3.boundCenter);
 	            } else if (this.keepDistance) {
 	              //不改镜头方向 保持一定角度。如果要改镜头方向，把lookAt提前
-	              viewer.mainViewport.view.position.subVectors(_model4.boundCenter, viewer.mainViewport.view.direction.clone().multiplyScalar(oldDisToCam));
+	              viewer.mainViewport.view.position.subVectors(_model3.boundCenter, viewer.mainViewport.view.direction.clone().multiplyScalar(oldDisToCam));
 	              viewer.mainViewport.view.radius = oldDisToCam;
 	            } else {
-	              viewer.mainViewport.view.lookAt(_model4.boundCenter);
+	              viewer.mainViewport.view.lookAt(_model3.boundCenter);
 	            }
 	          } else {
-	            viewer.mainViewport.view.lookAt(_model4.boundCenter);
+	            viewer.mainViewport.view.lookAt(_model3.boundCenter);
 	          }
 	        } else {
 	          viewer.modules.MergeEditor.focusOn(this.camFollowObject, 0, true /* ,false,dirAve */);
@@ -82471,11 +82480,11 @@
 	    for (var [model, keys] of this.poseKeys) {
 	      keys.length > 0 && (maxTime = Math.max(maxTime, keys[keys.length - 1].time));
 	    }
-	    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 [_model4, _keys5] of this.clipKeys) {
+	      _keys5.length > 0 && (maxTime = Math.max(maxTime, _keys5[_keys5.length - 1].time + _keys5[_keys5.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));
+	    for (var [_model5, _keys6] of this.pathKeys) {
+	      _keys6.length > 0 && (maxTime = Math.max(maxTime, _keys6[_keys6.length - 1].time + _keys6[_keys6.length - 1].dur));
 	    }
 	    this.duration = maxTime; //不算开始和结束动画的过渡时间的话
 
@@ -82614,8 +82623,8 @@
 	    for (var [model, keys] of this.clipKeys) {
 	      _loop3(model);
 	    }
-	    for (var [_model7, _keys8] of this.poseKeys) {
-	      data.poseKeys[_model7.name] = _keys8.map(key => {
+	    for (var [_model6, _keys7] of this.poseKeys) {
+	      data.poseKeys[_model6.name] = _keys7.map(key => {
 	        return {
 	          qua: key.qua.toArray(),
 	          pos: key.pos.toArray(),

src/sdk/cover/index.js

@@ -1516,7 +1516,7 @@ export const enter = ({ dom, mapDom, isLocal, lonlat, scenes, laserRoot, laserOS
                             } 
                         },
                         getSupportActions(){
-                            return  model.actions?.map(e=>e._clip.name)
+                            return model.actions?.map(e=>{return {name:e._clip.name, duration:e._clip.duration}) //model.actions?.map(e=>e._clip.name)
                         },
                         addAction(frame){// 添加模型动作
                             //console.log('addAction',frame)