src/custom/modules/Animation/AnimationEditor.js

@@ -0,0 +1,735 @@
+import * as THREE from "../../../../libs/three.js/build/three.module.js";
+
+import math from '../../utils/math.js'
+import Tween from '../../utils/Tween.js'
+import {easing,  lerp} from '../../utils/transitions.js'
+
+//有的动画，如小狗，进来如果不play停在第一帧，mesh会错，爪子在前面；但如果都停在第一帧，动作有可能很奇怪
+
+const tweens = {}
+const maxClipFadeTime = Potree.settings.maxClipFadeTime//渐变时间 s
+/* const pathStates = new Map */
+//actions中可能包含没有动作的 如TPose
+
+//包括无动画的模型在内的各项属性的过渡
+
+const rot90Qua = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1,0,0),-Math.PI/2)
+
+export default class AnimationEditor extends THREE.EventDispatcher{
+    constructor(){
+        super()
+        
+        
+        this.poseKeys = new Map  //transform
+        this.descKeys = new Map  //字幕
+        this.pathKeys = new Map  //之前设置好的Path  , 优先级高于pose
+        this.clipKeys = new Map  //glb animation actions  
+
+
+        this.duration = 0 //动画时长
+        this.time = 0 //当前播放时间
+        this.cursorTime = 0 //时间轴指针时间
+        
+        this.keepDistance = true  //focus的物体和相机保持不变的距离
+        this.poseTransition = false //pose缓动
+        
+        
+        if(Potree.settings.isOfficial){
+            viewer.modules.MergeEditor.bus.addEventListener('changeSelect',()=>{ 
+                let targetObject = viewer.modules.MergeEditor.selected
+                    targetObject = this.ifContainsModel(targetObject) ? targetObject : null
+                this.setCameraFollow(targetObject)  
+            })
+        }
+        
+    }
+    
+    addKey(model, keyType, key ){
+        let keys = this[keyType+'Keys'].get(model)
+        if(!keys){
+            keys = []
+        }
+        
+        let index = keys.findIndex(e=>e.time>key.time)
+        if(index == -1){
+            index = keys.length
+        }
+        
+        
+        keys = [...keys.slice(0,index), key, ...keys.slice(index,keys.length)]
+        this[keyType+'Keys'].set(model,keys)
+        this.updateTimeRange()
+    }
+    
+    removeKey(model, keyType, key  ){
+        let keys = this[keyType+'Keys'].get(model)
+        if(!keys)return console.warn('removeKey没找到key')
+       
+        let index = keys.indexOf(key)
+        if(index > -1){ 
+            if(keyType == 'clip'){
+                key.action.stop()
+            }
+            keys.splice(index,1)
+            this.updateTimeRange()        
+        }  
+    }
+    
+    reOrderKey(model, keyType, key  ){
+        this.removeKey(model, keyType, key )
+        this.addKey(model, keyType, key )
+    }
+    
+    
+    at(time, delta, force){  
+        this.dispatchEvent({type:'atTime', time})   //该时间可以大于本动画持续时间
+        this.cursorTime = time
+        /* if(time > this.duration + maxClipFadeTime/2){  
+            for(let [model, keys] of this.clipKeys){
+                model.actions.forEach(a=>a.stop())
+            } 
+        } */
+         
+        let maxTime = this.duration+maxClipFadeTime/2
+        if(time >= maxTime) time = maxTime 
+        if(this.time == time && !force)return
+        this.time = time //真实值
+        
+        
+        let oldDisToCam = this.camFollowObject?.length == 1 && this.keepDistance && this.camFollowObject[0].boundCenter.distanceTo(viewer.mainViewport.view.position)
+       
+        
+        
+        let transitionRatio = 0.05 * delta * 60 //渐变系数，越小缓动程度越高，越平滑 //假设标准帧率为60fps，当帧率低时（delta大时） 降低缓动。速度快时缓动太高会偏移路径
+        let transitionRatio2 = 0.8 * delta * 60   
+       
+        
+        let posePathModels = [];
+        
+        
+        [this.poseKeys, this.pathKeys/* , this.clipKeys */].forEach((map)=>{
+            Array.from(map.keys()).forEach(model=>{
+                posePathModels.includes(model) || posePathModels.push(model)
+            })
+        })
+        /* 
+            路径>关键帧。但是如果每条路径开头和结尾以及过渡时没有关键帧，保持路径开头和结尾的姿态
+            
+         */
+        posePathModels.forEach(model=>{
+             
+            
+            let pathKeys = this.pathKeys.get(model) || []
+            let poseKeys = this.poseKeys.get(model) || []
+            
+            let atPath //是否在path中 至多只有一个 
+            let lastPath 
+            let nextPath  
+            
+            if(pathKeys.length){
+                pathKeys.find(key=>{
+                    if(key.path.points.length < 2) return
+                    let startToFade = key.time - maxClipFadeTime/2
+                    let endFade = key.time + key.dur + maxClipFadeTime/2
+                    atPath = time >= key.time && time <= key.time + key.dur
+                    if(atPath){
+                        atPath = key //找到一个就退出 
+                        return true
+                    }  
+                    if(key.time + key.dur < time) lastPath = key
+                    else if(key.time > time && !nextPath) nextPath = key
+                     
+                }) 
+            }
+            
+            
+            
+            
+            if(poseKeys.length){
+                tweens.scale = new Tween(poseKeys.map(e=>e.time), poseKeys.map(e=>e.scale)) 
+                model.scale.copy(tweens.scale.lerp(time)) 
+                 
+            }else{
+                /* if(pathKeys.length){
+                    model.quaternion.copy(model.defaultAniPose?.quaternion || new THREE.Quaternion()) //设置路径朝向前要先还原
+                } */
+            }
+            
+            
+            
+            if(atPath){//沿着curve行走，目视curve前方  （参照CameraAnimationCurve，搜quaFromCurveTan）  
+                let percent = THREE.Math.clamp((time - atPath.time) / atPath.dur, 0, 1)
+                let {position , quaternion} = this.getPoseAtPathKey(atPath, percent, model)  //模型文件先保证其center在脚底，如果要我手动将bound底部对齐路径高度再说
+                model.position.copy(position);
+                model.quaternion.copy(quaternion)
+           
+                model.atPath = atPath
+                
+            }else{
+                model.atPath = null
+                poseKeys = poseKeys.slice()
+                let addPathToPoseKey = (pathKey, percent)=>{ //把当前前后的path姿态加入帧
+                    let {position , quaternion} = this.getPoseAtPathKey(pathKey, percent, model)
+                    let fakeKey = {
+                        isPath : true,
+                        time: pathKey.time + pathKey.dur * percent,
+                        pos:position , qua:quaternion
+                    } 
+                    let index = poseKeys.findIndex(e=>e.time > fakeKey.time) 
+                    if(index == -1){
+                        index = poseKeys.length
+                    } 
+                    poseKeys = [...poseKeys.slice(0,index), fakeKey, ...poseKeys.slice(index,poseKeys.length)]
+                }
+                lastPath && addPathToPoseKey(lastPath, 1)
+                nextPath && addPathToPoseKey(nextPath, 0)
+                
+                if(poseKeys.length){  
+                    tweens.pos = new Tween(poseKeys.map(e=>e.time), poseKeys.map(e=>e.pos)) 
+                    model.position.copy(tweens.pos.lerp(time))
+                    tweens.qua = new Tween(poseKeys.map(e=>e.time), poseKeys.map(e=>e.qua))
+                    model.quaternion.copy(tweens.qua.lerp(time)) 
+                    /* let poseKeys2 = poseKeys.filter(e=>e.isPath)//妈呀为什么这么写我忘了
+                    if(poseKeys2.length ){
+                        tweens.qua = new Tween(poseKeys2.map(e=>e.time), poseKeys2.map(e=>e.qua))
+                        model.quaternion.copy(tweens.qua.lerp(time))
+                    }   */
+                }
+            } 
+            if(poseKeys.length || pathKeys.length){ 
+                model.dispatchEvent('position_changed')
+                model.dispatchEvent('rotation_changed') 
+            }
+        })
+        
+        
+        
+         
+        
+        
+        
+        
+        
+         
+        
+        for(let [model, keys] of this.clipKeys){
+            if(keys.length == 0) continue 
+             
+            let weights = keys.map((key,i)=>{ //计算每个动作权重（幅度）。  
+                
+                /* if(delta == void 0){//无缓动  但会造成和缓动时动作time不同
+                    return time >= key.time && time <= key.time + key.dur ? 1 : 0
+                } */
+                key.index_ = i
+                 
+                let fadeTimeStart = Math.min(maxClipFadeTime,  key.dur, (keys[i-1]?.dur || maxClipFadeTime  )) / 2 //过渡时间不超过当前和前一个的 half of dur
+                let fadeTimeEnd = Math.min(maxClipFadeTime,  key.dur, (keys[i+1]?.dur || maxClipFadeTime  )) / 2   //过渡时间不超过当前和后一个的 half of dur
+                 
+                
+                let startTime1 = key.time - fadeTimeStart 
+                let endTime1 = key.time + key.dur + fadeTimeEnd
+                let startTime2 = key.time + fadeTimeStart     
+                let endTime2 = key.time + key.dur - fadeTimeEnd 
+                
+                key.action.tempSW_ = {scale:0,weight:0,time: null,  sameLinks:[]},
+                key.tempTime_ = THREE.Math.clamp(time - key.time, 0, key.dur) //time - startTime1 //当前动作时间 
+                key.startTime1 = startTime1
+                key.endTime1 = endTime1
+                
+                
+                if(i==0 && time<startTime2){//开始前维持第一个动作 
+                    return 1
+                }else if(i == keys.length-1 && time > endTime2){//所有动作播完后维持最后一个动作
+                    return 1
+                }else{ 
+                    if(time < startTime1 || time > endTime1)return 0  //out bound 
+                  
+                    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的，在过渡 
+             
+            let animateActions = [] //在播的动作
+            keys.forEach((key,i)=>{ weights[i]>0 && !animateActions.includes(key.action) && (key.action.tempSW_ = {scale:0,weight:0,time: null, sameLinks:[]}, animateActions.push(key.action) )})
+            //万一前后是一个动作…… 所以用tempSW_计算总值
+            
+            keys.forEach((key,i)=>{ //要找到当前action之前所有不间断的所有key，他们之间要连续播放
+                if(animateActions.includes(key.action)){
+                    if(key.startTime1 < time){//已播部分的key  
+                        let last = key.action.tempSW_.sameLinks[key.action.tempSW_.sameLinks.length - 1]
+                        if(last){
+                            if( key.index_ == last.index_ + 1 && key.startTime1 <= last.endTime1 ){ //相连
+                                key.action.tempSW_.sameLinks.push(key)
+                            }else{
+                                key.action.tempSW_.sameLinks = [key] //clear
+                            }
+                        }else{
+                            key.action.tempSW_.sameLinks = [key]
+                        }
+                    }
+                }   
+            })
+         
+         
+            keys.forEach((key,i)=>{  
+                if(animateActions.includes(key.action)){ 
+                    let weight = weights[i] * key.weight    //权重乘以自身幅度
+                    if(weight>0){//最多两个
+                        key.action.play() 
+                        key.action.paused = true  //停在某帧 //如果没有点击该动作块的话 不停
+                        
+                        key.action.tempSW_.weight += weight  
+                        key.tempTime_ >= 0 && (key.action.tempSW_.scale = key.speed) //相同动作不允许叠加速度
+                       
+                         if(key.action.tempSW_.time == null){//如果两个动作相同 只需在第一个计算出总和
+                            let timeSum = 0
+                            key.action.tempSW_.sameLinks.forEach(key_ =>{
+                                timeSum +=  (key_.tempTime_ % (key_.action._clip.duration / key_.speed)) * key_.speed //相同动作可能速度不同,算出每个clip的时间  
+                            })
+                            key.action.tempSW_.time = timeSum % key.action._clip.duration   
+                        }
+                         
+                        //(老版本，过渡时播放时间会延长一点，有交集):
+                        //key.action.tempSW_.time == null && (key.action.tempSW_.time = key.tempTime_) //相同动作优先用前一个的时间
+                        //key.action.tempSW_.scale += key.speed // * weights[i] //乘以weight在开始和结束作为缓动效果好，但是不好计算实时time
+                        //speed time都没有交集，只有weight有，为了过渡
+                    }
+                }else{
+                    key.action.stop()   //不启动动画
+                    
+                }
+            }) 
+            
+            animateActions.forEach(action=>{
+                action.setEffectiveTimeScale(action.tempSW_.scale) //speed  只有没paused时有效 这里都paused的所以没用
+                action.setEffectiveWeight(action.tempSW_.weight ); 
+                action.time = action.tempSW_.time     //(action.tempSW_.time % (action._clip.duration / action.tempSW_.scale)) * action.tempSW_.scale  //只有paused时有效
+                //console.log('action', action._clip.name, action.time, action.weight, action.tempSW_.scale )
+                
+                 
+            })
+            
+            //model.mixer.timeScale = 1 ; 
+            
+        }  
+         
+        viewer.objs.children.forEach(obj=>{
+            if(!obj.actions?.length)return 
+            let clipState = obj.actions.map(action=>{ 
+                let played = action._mixer._isActiveAction( action );
+                let paused = action.paused
+                let time = action.time
+                let weight = action.weight  
+                return {played,paused,time,weight}
+            }) 
+            clipState = JSON.stringify(clipState)
+            if(obj.clipState != clipState){//动作是否改变
+                obj.traverse(e=>e.isSkinnedMesh && (e.boundingSphere = null)) //动画会导致bound改变，清空，raycast时重新计算bound，否则hover不到模型
+                obj.clipChanged = true
+            }
+            obj.clipState = clipState
+            	  
+        })
+        
+        
+        
+        {   
+            
+            if(this.camFollowObject && !viewer.scene.monitors.some(e=>e.isWatching)){//in front of model 
+                if(this.camFollowObject.length == 1){ 
+                    let model = this.camFollowObject[0] 
+                    if(viewer.images360.latestRequestMode == 'showPointCloud'){  
+                        if(this.camFaceToObject){
+                            let dis = 4;  
+                            let dir = new THREE.Vector3(0,0.1,1).normalize()//稍微朝上
+                            dir.multiplyScalar(dis).applyQuaternion(model.quaternion)
+                            let pos = new THREE.Vector3().addVectors(model.boundCenter, dir)
+                            viewer.mainViewport.view.position.copy(pos) 
+                            viewer.mainViewport.view.lookAt(model.boundCenter)
+                        }else if(this.keepDistance){ //不改镜头方向 保持一定角度。如果要改镜头方向，把lookAt提前
+                            viewer.mainViewport.view.position.subVectors(model.boundCenter, viewer.mainViewport.view.direction.clone().multiplyScalar(oldDisToCam))
+                            viewer.mainViewport.view.radius = oldDisToCam
+                        }else{
+                            viewer.mainViewport.view.lookAt(model.boundCenter)
+                        }
+                    }else{
+                        viewer.mainViewport.view.lookAt(model.boundCenter)
+                    }                    
+                }else{  
+                    viewer.modules.MergeEditor.focusOn(this.camFollowObject, 0, true/* ,false,dirAve */) 
+                }
+            } 
+        }
+        
+        
+        
+        
+        viewer.dispatchEvent('content_changed')
+       
+    }
+    
+    getPoseAtPathKey(key, percent, model){ 
+        let delta = 0.001
+        let percent2 = percent + delta
+        let curve = key.path.curve.clone()
+        if(key.reverse) curve.points.reverse()  
+        let position = curve.getPointAt(percent); 
+        let pathQua, quaternion
+      
+        if(percent2 <= 1){  
+            let position2 = curve.getPointAt(percent2);
+            pathQua = math.getQuaFromPosAim(position2, position)  
+        }else{
+            percent2 = percent - delta
+            let position2 = curve.getPointAt(percent2);
+            pathQua = math.getQuaFromPosAim(position, position2)  
+        }
+        
+        pathQua.multiplyQuaternions( pathQua, rot90Qua ); //这是当模型导进来就旋转正确时的quaternion
+        key.curQua_ = pathQua.clone() //记录下
+        if(model.quaAtPath){ 
+            quaternion = new THREE.Quaternion().multiplyQuaternions(pathQua, model.quaAtPath) 
+        }else{
+            quaternion = pathQua.clone()
+        }
+         
+        
+        //model && quaternion.multiplyQuaternions( quaternion, model.quaternion );        //应用当前已有的quaternion
+        //如果要将模型底部中心对准路径，需要先修改好模型scale ，然后boundingBox中心应用scale和qua, 加到position里
+        //目前两个人物模型刚好模型pivot在脚底，如果是其他物体甚至直接用curve的朝向不太对，没有明确朝向。除非所有模型都保持上路径前的朝向
+        //或者pos的z还用之前的
+        //产品说位置偏移不管它，因为路径可以隐藏和修改。只要记录相对旋转即可。
+        return {position, quaternion}
+    }
+    
+    
+    
+    
+    
+    getModelQuaAtPath(model){ //当前时间在路径上时，旋转模型后立即执行该函数，获取相对旋转值
+        if(!model.atPath)return
+        let qua = new THREE.Quaternion().multiplyQuaternions(model.atPath.curQua_.clone().invert(),  model.quaternion)
+         
+        //console.log('getModelQuaAtPath',qua)
+        model.quaAtPath = qua //相对旋转
+        return qua
+    }
+    
+    play({ time = -maxClipFadeTime/2}={}){//动画时长比duration多一个maxClipFadeTime，为了给开始和结束动画过渡
+        
+     
+        this.updateTimeRange() 
+        this.playing && this.pause()
+        
+      
+        let maxTime = this.duration+maxClipFadeTime/2
+        this.playing = true
+        
+        this.cursorTime = time
+        
+        this.onUpdate = (e)=>{ 
+            this.cursorTime += e.delta 
+            if(!Potree.settings.isOfficial && time > maxTime) this.cursorTime = maxTime 
+            this.at(this.cursorTime, e.delta) 
+            if(!Potree.settings.isOfficial && time > maxTime) {
+                this.dispatchEvent('stop')
+                for(let [model, keys] of this.clipKeys){
+                    model.actions.forEach(a=>a.stop())
+                }
+                this.pause()
+            }
+              
+        }
+        viewer.addEventListener("update_start", this.onUpdate);
+          
+    }  
+    
+    pause(){
+        this.playing = false 
+        viewer.removeEventListener("update_start", this.onUpdate); 
+        /* for(let [model, keys] of this.clipKeys){
+            model.actions.forEach(a=>a.stop())
+        } */ 
+        viewer.dispatchEvent('content_changed')
+        
+    }
+    
+    
+    setCameraFollow(camFollowObject){//for test
+        this.camFollowObject = camFollowObject
+        if(!camFollowObject)return
+        
+        //Potree.settings.displayMode = 'showPointCloud'
+        
+        if(!(this.camFollowObject instanceof Array)){//支持相机跟随多个物体，对着bound的中心
+            this.camFollowObject = [this.camFollowObject]
+        }
+        
+        this.camFollowObject = this.camFollowObject.map(object=>{
+            if(typeof object == 'string'){
+                return viewer.objs.children.find(e=>e.name == object)
+            }else{
+                return object
+            }
+        })
+        
+    }
+    
+    
+    updateTimeRange(){
+        let maxTime = 0
+        for(let [model, keys] of this.poseKeys){
+            keys.length>0 && (maxTime = Math.max(maxTime, keys[keys.length - 1].time))
+        }
+        
+        for(let [model, keys] of this.clipKeys){
+            keys.length>0 && (maxTime = Math.max(maxTime, keys[keys.length - 1].time + keys[keys.length - 1].dur))
+        }
+        
+        for(let [model, keys] of this.pathKeys){
+            keys.length>0 && (maxTime = Math.max(maxTime, keys[keys.length - 1].time + keys[keys.length - 1].dur))
+        }
+        this.duration = maxTime //不算开始和结束动画的过渡时间的话
+        
+        
+        /* for(let [model, keys] of this.clipKeys){
+            max = Math.max(maxTime, keys[keys.length - 1].time + keys[keys.length - 1].dur)
+        } */
+    }
+    
+    
+    /* removeModelCallback(model){
+        this.poseKeys.get
+    } */
+    
+    
+    /////////////////////////////////
+    
+    
+    addPoseKey({model,time,index }={}){ 
+        /* if(replace){ 
+            this.removeKey(model,'pose', index)
+        } */
+        let keys = this.poseKeys.get(model)
+        if(!keys){
+            keys = []  
+        }
+        let key = {
+            time,
+            qua: model.quaternion.clone(),
+            scale: model.scale.clone(),
+            pos: model.position.clone()
+        } 
+        if(index == void 0)index = keys.length 
+        keys = [...keys.slice(0,index), key, ...keys.slice(index,keys.length)]
+		this.poseKeys.set(model,keys)
+        return key
+    }
+    
+    
+     
+    addClipKey({model, time, index, dur, actionIndex, weight=1, speed=1/* , replace  */}={}){
+        
+        /* if(replace){
+            this.removeKey(model,'clip',index)
+        } */
+        let keys = this.clipKeys.get(model)
+        if(!keys){
+            keys = []  
+        }
+        let key = {
+            time,   //startTime
+            dur,    
+            action: model.actions[actionIndex],
+            speed, weight,
+        } 
+        if(index == void 0)index = keys.length 
+        keys = [...keys.slice(0,index), key, ...keys.slice(index,keys.length)]
+		this.clipKeys.set(model,keys)
+    } 
+    
+    
+    
+    addPathKey({model, time, index, dur, path/* , replace */ }={}){//what if path is deleted ? 
+        /* if(replace){
+            this.removeKey(model,'path',index)
+        } */
+        let keys = this.pathKeys.get(model)
+        if(!keys){
+            keys = []  
+        }
+        let key = {
+            time,   //startTime
+            dur,    
+            path,  
+        } 
+        if(index == void 0)index = keys.length 
+        keys = [...keys.slice(0,index), key, ...keys.slice(index,keys.length)]
+		this.pathKeys.set(model,keys)
+    } 
+    
+    addDescKey({model, time, index, dur, desc/* , replace */ }={}){
+        /* if(replace){
+            this.removeKey(model,'desc',index)
+        }  */       
+        let keys = this.descKeys.get(model)
+        if(!keys){
+            keys = []  
+        }
+        let key = {
+            time,   //startTime
+            dur,    
+            desc, 
+        } 
+        if(index == void 0)index = keys.length 
+        keys = [...keys.slice(0,index), key, ...keys.slice(index,keys.length)]
+		this.descKeys.set(model,keys)
+    } 
+    
+    
+    
+    
+    
+    save(){//for test, 注意保证每个模型名字不同
+        let data = {poseKeys:{}, clipKeys:{}}
+        for(let [model, keys] of this.clipKeys){
+            data.clipKeys[model.name] = keys.map(key=>{
+                return {
+                    actionIndex: model.actions.indexOf(key.action),
+                    time: key.time, dur:key.dur, weight:key.weight,  speed:key.speed
+                }
+            })
+        }
+        
+        for(let [model, keys] of this.poseKeys){
+            data.poseKeys[model.name] = keys.map(key=>{
+                return {
+                    qua: key.qua.toArray(), pos: key.pos.toArray(), scale:key.scale.toArray(),
+                    time: key.time,  
+                }
+            })
+        }
+        console.log(JSON.stringify(data))
+        return data 
+    }
+    
+    
+    buildFromData(data){
+        if(typeof data == 'string'){
+            data = JSON.parse(data)
+        }
+        for(let name in data.poseKeys){
+            let model = viewer.objs.children.find(e=>e.name == name)
+            if(!model){
+                console.warn('没找到pose模型',name)
+                continue
+            }
+            let keys = data.poseKeys[name].map(e=>{
+                return {
+                    qua: new THREE.Quaternion().fromArray(e.qua),
+                    pos: new THREE.Vector3().fromArray(e.pos),
+                    scale: new THREE.Vector3().fromArray(e.scale),
+                    time: e.time
+                }
+            })
+            this.poseKeys.set(model,keys)
+        }
+        
+        for(let name in data.clipKeys){
+            let model = viewer.objs.children.find(e=>e.name == name)
+            if(!model){
+                console.warn('没找到clip模型',name)
+                continue
+            }
+            let keys = data.clipKeys[name].map(e=>{
+                return {
+                    action: model.actions[e.actionIndex], 
+                    time: e.time, dur: e.dur, weight:e.weight, speed:e.speed
+                }
+            })
+            this.clipKeys.set(model,keys)
+        }
+    }
+    
+    
+    ifContainsModel(model){//动画帧里是否包含它
+        return [this.poseKeys, this.pathKeys, this.clipKeys].some((e)=>{
+            return e.has(model)
+        })
+    }
+    
+    
+}
+
+
+
+
+
+
+/* 
+function executeCrossFade( startAction, endAction, duration ) {
+    // Not only the start action, but also the end action must get a weight of 1 before fading
+    // (concerning the start action this is already guaranteed in this place)
+    if ( endAction ) {
+
+        setWeight( endAction, 1 );
+        endAction.time = 0;
+
+        if ( startAction ) {
+            // Crossfade with warping
+            startAction.crossFadeTo( endAction, duration, true );
+
+        } else {
+            // Fade in
+            endAction.fadeIn( duration );
+        }
+
+    } else {
+        // Fade out
+        startAction.fadeOut( duration );
+    }
+
+}
+
+
+function setWeight( action, weight ) {
+
+    action.enabled = true;
+    window.ani1 || action.setEffectiveTimeScale( 1 );
+    action.setEffectiveWeight( weight );
+
+} */
+
+ 
+
+/* autoActionSpeed(action){ //要获取这段时间走过的路程很难，还是延期吧. 而且一段动作要对应多个速度不同的位移，是不可能的。
+    return  dis / dur
+} */
+/* 
+
+ 动作自动计算步伐 幅度（weight）或 速度
+
+
+  timeScale * modelStepSizeRatio * weight = dis / dur
+  速度       每个模型的步长系数    幅度
+
+ 
+ 
+ 
+如果人的bone attach 物品，物品就被add到人身上，需要click出物品
+//测试：为人加物体， 需要先选中物品
+let obj = viewer.modules.MergeEditor.selected
+viewer.objs.children.find(e=>e.name == 'Man.glb').skeletonHelper.bones[34].attach(obj); //左手骨和物品绑定
+//viewer.objs.children.find(e=>e.name == 'Soldier.glb').skeletonHelper.bones[9].attach(obj); //右手骨和物品绑定
+obj.updateMatrixWorld() 
+obj.dispatchEvent({type:'position_changed',byControl:true  }) 
+obj.dispatchEvent({type:'rotation_changed',byControl:true  })
+ 
+ 
+物体带动骨骼自动做动作 setAniIK
+ */