|
|
@@ -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
|
|
|
+ */
|
xzw