fuse-code/src/sdk/cover/index.js

import mitt from 'mitt'

import axios from 'axios' //{ axios } from '@/api'


export const enter = (dom) => {
    
    Potree.settings.isOfficial = true //标记为正式、非测试版本 
    //Potree.fileServer = axios 
    Potree.settings.libsUrl = '../lib/'
    
    
    let {THREE} = Potree.mergeEditStart(dom)
    let MergeEditor = viewer.modules.MergeEditor
    let sceneBus = mitt()
    
    viewer.addEventListener('camera_changed', e => {
        var camera = e.viewport.camera
        var pos = camera.position
        if (e.viewport.name == 'MainView') {
            sceneBus.emit('cameraChange', { x: pos.x, y: pos.y, z: pos.z, rotate: camera.rotation })
        } 
    })
    
    
     
  
    let sdk = {
        sceneBus,
        getPositionByScreen(pos2d, mustModelId ){//通过屏幕坐标获取真实坐标 . mustModelId： 如果指定了模型，modelId必须为mustModelId才有效
            let worldPos, localPos, modelId,  intersect
            let Handler = viewer.inputHandler
            
            let reGet = ()=>{//不使用当前鼠标所在位置的intersect，单独算
                pos2d.clientX = pos2d.x
                pos2d.clientY = pos2d.y
                pos2d.onlyGetIntersect = true
                pos2d.whichPointcloud = true
                if(mustModelId != void 0){//隐藏其他的模型
                    let models = MergeEditor.getAllObjects()
                    models.forEach(model=>{
                        viewer.updateVisible(model, 'forPick', model.dataset_id == mustModelId)
                    }) 
                }
                intersect = Handler.onMouseMove(pos2d)
                if(mustModelId != void 0){//恢复
                    let models = MergeEditor.getAllObjects()
                    models.forEach(model=>{
                        viewer.updateVisible(model, 'forPick', true)
                    }) 
                }
            }
            if (pos2d && pos2d.inDrag) {  
                reGet() 
            } else {
                intersect = Handler.intersect
                if(intersect){
                    modelId = intersect.pointcloud ? intersect.pointcloud.dataset_id : intersect.object.dataset_id
                    if(mustModelId != void 0 && modelId != mustModelId){
                        reGet()
                    } 
                }
            }

            if (intersect && intersect.location) {
                modelId = intersect.pointcloud ? intersect.pointcloud.dataset_id : intersect.object.dataset_id
                if(mustModelId != void 0 && modelId != mustModelId){
                    return null
                } 
                worldPos = intersect.location.clone()
                localPos = Potree.Utils.datasetPosTransform({ toDataset: true, datasetId:modelId, position:worldPos })
            } else return null
            
            return { worldPos, modelId, localPos }
        },
        
        
        
         
        
        
        getScreenByPosition(pos3d, modelId){//通过模型局部坐标获取屏幕坐标 
            let isLocal = modelId != void 0 
            pos3d = new THREE.Vector3().copy(pos3d)
            let worldPos = isLocal ? Potree.Utils.datasetPosTransform({ fromDataset: true, datasetId: modelId, position:pos3d}) : pos3d
            if(!worldPos)return
            var viewport = viewer.mainViewport
            var camera = viewport.camera
            var dom = viewer.renderArea
            //console.log('getScreenByPoint ' + pos3d.toArray())
            return Potree.Utils.getPos2d(worldPos, camera, dom, viewport)
        },
        
        screenshot: (width, height) => {
            //截图 
            var promise = viewer.startScreenshot({ type: 'default' }, width, height)
            promise.done(() => {
 
            })
            return promise
        },
        getPose() {//获取当前点位和朝向
            const camera = viewer.scene.getActiveCamera()
            const target = viewer.scene.view.getPivot()
            const position = viewer.scene.view.position 
            console.log('getPose',position, target)
            return { position, target }
        },
        comeTo(o = {}) {
            console.log('comeTo',o.position, o.target)
            //飞到某个点  
            if(o.modelId){ 
                ['position','target'].forEach(e=>{
                    if(o[e]){
                        o[e] = Potree.Utils.datasetPosTransform({ fromDataset: true, datasetId: o.modelId, position:o[e]})
                    }
                }) 
            }
            
            if(o.distance){
                let position = o.target || o.position
                return viewer.focusOnObject({ position, distance:o.distance }, 'tag').promise
            }
            let deferred = $.Deferred()
            
            viewer.scene.view.setView($.extend({},o, {
                duration: o.dur,
                callback:()=>{
                    o.callback && o.callback()
                    deferred.resolve(true)
                }
            }))
            return deferred.promise()
        },
        /* getPose(o={}) {
            //获取相对于第一个数据集的初始画面。（当数据集校准后，如果初始画面设置在被修改的数据集上，且该数据集非初始数据集的话，还是会偏移的）
            var deferred = o.deferred || $.Deferred();
            console.log('getPose')
            if(viewer.mainViewport.view.isFlying()){ 
                let f = ()=>{
                    this.getPose(o)
                    viewer.mainViewport.view.removeEventListener('flyingDone', f)
                } 
                viewer.mainViewport.view.addEventListener('flyingDone', f) //once 
                o.deferred = deferred
                return deferred.promise()
            }
            
            var camera = viewer.scene.getActiveCamera()
            var rotation = camera.rotation
            var pos_In_dataset = Potree.Utils.datasetPosTransform({ toDataset: true, position: camera.position.clone(), datasetId: Potree.settings.originDatasetId })
            var rot_In_dataset = Potree.Utils.datasetRotTransform({ toDataset: true, rotation, getRotation: true, datasetId: Potree.settings.originDatasetId }) //拿第一个数据集

            var view = viewer.scene.view.clone()
            view.rotation = rot_In_dataset //获取yaw pitch

            var pose = {
                //displayMode: Potree.settings.displayMode,
                position: pos_In_dataset,
                yaw: view.yaw,
                pitch: view.pitch,
                displayMode : Potree.settings.displayMode,
                panoSid: viewer.images360.currentPano.sid
            }
            //return pose
            
            setTimeout(()=>{
                deferred.resolve(pose)
                console.log('getPose resolve',pose)
            },1)
            
            
            return deferred.promise()
            
            
        },
        

        setPose(o = {}, duration=0) {
            //设置相机位置和朝向 
            var deferred = o.deferred || $.Deferred();
            console.warn('setPose 初始画面', o)
            var quaternion 
            let view = viewer.scene.view.clone()
              
            if(viewer.mainViewport.view.isFlying()){ 
                let f = ()=>{
                    this.setPose(o, duration)
                    viewer.mainViewport.view.removeEventListener('flyingDone', f)
                } 
                viewer.mainViewport.view.addEventListener('flyingDone', f) //once 
                o.deferred = deferred
                return deferred.promise()
            }
            
            var getQuaternion = ()=>{  
                view.pitch = o.pitch
                view.yaw = o.yaw
 
                quaternion = Potree.Utils.datasetRotTransform({ fromDataset: true, rotation: view.rotation, getQuaternion: true, datasetId: Potree.settings.originDatasetId }) //拿第一个数据集
                   
            }
            
             
            
            viewer.images360.cancelFlyToPano()//防止旧的在之后继续执行
            let pano 
            if(o.panoSid != void 0){//好像都不存这个
                pano = viewer.images360.panos.find(e=>e.sid == o.panoSid)
                if(pano == void 0)return deferred.reject('没有找到该panoSid').promise()
                getQuaternion() 
                viewer.images360.flyToPano({pano, duration, quaternion},()=>{
                    deferred.resolve()
                })
            }else{
                if(Potree.settings.displayMode == 'showPanos'){
                    return   deferred.reject('全景模式下不允许设置位置').promise()
                }
                
                
                let position = Potree.Utils.datasetPosTransform({ fromDataset: true, position: o.position, datasetId: Potree.settings.originDatasetId })
                //view.position.copy(position)
                getQuaternion()   
                
                pano = viewer.images360.panos.find(e=>Potree.math.closeTo(e.position, position))
                
                if(pano){//如果原来在某pano上最好也使currentPano为此pano，否则isAtPano会返回false
                    viewer.images360.flyToPano({pano, duration, quaternion},()=>{
                        deferred.resolve()
                    })
                }else{
                    
                    viewer.scene.view.setView({position,quaternion,duration, callback:()=>{ 
                        //setTimeout(()=>{
                            deferred.resolve()
                            console.log('setPose resolve')
                        //},1) 
                    } })  
                    viewer.mapViewer.moveTo(position, null, duration)  //初始位置在地图居中
                    
                }
                
                
                  
            }
              
            
            
            
            return deferred.promise()
        },
        */
     
        
        enterSceneGuide(pathArr){//导览  (不需要修改参数)
            let editor = viewer.modules.CamAniEditor
            console.log('pathArr',pathArr)
        
            /* type SceneGuidec = {
              position: {x,y,z}
              target: {x,y,z}
              time: number
              speed: number
            }
            sceneGuide = enterSceneGuide(sceneGuidePaths)
  
              let posTran = function (position, target) {
                position = Potree.Utils.datasetPosTransform({ fromDataset: true, position: position, datasetId: Potree.settings.originDatasetId })
                target = Potree.Utils.datasetPosTransform({ fromDataset: true, position: target, datasetId: Potree.settings.originDatasetId })
                return { position, target }
            } 
            if (data) {
                data.points.forEach(e => {
                    //let { position, target } = posTran(e.position, e.target)
                    e.position = position
                    e.target = target
                })
            }*/
            let data = {
                duration: pathArr.reduce(function(total, currentValue ){return total+currentValue.time}, 0),
                points: pathArr
            }
            let animation = editor.createAnimation(data)
            //注：最多只存在一条导览
            animation.useDurSlice = true 
             
            
            let bus = mitt()

            //播放完成
            animation.addEventListener('playDone', () => {
                bus.emit('playComplete')
            })
            //切换点
            animation.addEventListener('updateCurrentIndex', e => {
                bus.emit('changePoint', e.currentIndex + 1)
            })

            return {
                bus,
                /* addPoint(index, position_, target_) {
                    let { position, target } = posTran(position_, target_)
                    animation.createControlPoint(index, { position, target })
                    animation.changeCallback()
                },
                deletePoint(index) {
                    animation.removeControlPoint(index)
                    animation.changeCallback()
                }, */
                play() {
                    /* var modeOld = Potree.settings.displayMode;
                    Potree.settings.displayMode = 'showPointCloud' */
                    animation.play()
                },
                pause() {
                    animation.pause()
                },
                /*setDuration(dur) {
                    animation.setDuration(dur)
                }, */
                clear() {
                    //删除
                    editor.removeAnimation(animation)
                },
            } 
            
        },
        
        
        addModel(props){ 
            let bus = mitt()  
            console.log('addModel',props)
            
            
            let model
            let done = (model_)=>{
                model = model_
                props.opacity != void 0 && result.changeOpacity(props.opacity) 
                
                model.addEventListener('changeSelect',(e)=>{
                    bus.emit('changeSelect',e.selected)
                }) 
                model.addEventListener('transformChanged',(e)=>{
                    bus.emit('transformChanged', {
                        position : model.position.clone(),
                        scale: model.scale.x,
                        rotation: model.rotation.clone(),
                        bottom: model.btmHeight
                    })
                })
                
                
                bus.emit('loadDone')
                console.log('loadDone' )
            }
            let progressFun = (progress)=>{
                bus.emit('loadProgress',progress)
            }
            if(props.type == "glb"){////////////////////////////test
                props.url = '/lib/potree/resources/models/glb/coffeemat.glb'  
            }
            Potree.addModel(props,  done , progressFun)
            
            let result = {  
                bus,
                changeShow(show){ 
                    if(model){
                        viewer.updateVisible(model, 'changeShow', show)
                    } 
                },
                changeSelect(state){
                    if(model){
                        MergeEditor.selectModel(model, state, true, true)
                        if(state && viewer.inputHandler.selection[0]){
                            viewer.transformObject(model); //交换
                        }
                    }
                },
                changeScale(s){
                    if(model){
                        model.scale.set(s,s,s)
                        model.dispatchEvent("scale_changed")
                    }
                },
                changeOpacity(opacity){
                    if(model){
                        if(model.isPointcloud){
                            model.material.opacity = opacity
                        }else{
                            model.traverse(e=>e.material && (e.material.opacity = opacity))
                        }
                    }
                     
                },
                changeBottom(z){
                    model && MergeEditor.setModelBtmHeight(model,z)
                },
                enterRotateMode(){
                    if(model){
                        viewer.transformObject(model);
                        viewer.transformationTool.setModeEnable('rotation',true)
                        viewer.transformationTool.setModeEnable('translation',false)
                    }
                }, 
                enterMoveMode(){
                    if(model){
                        viewer.transformObject(model);
                        viewer.transformationTool.setModeEnable('rotation',false)
                        viewer.transformationTool.setModeEnable('translation',true)
                    }
                },
                leaveTransform(){ 
                    viewer.transformObject(null); 
                },
                 
                destroy(){
                    MergeEditor.removeModel(model) 
                }
                 
            } 
            
            return result
        } 
            
    
        
    }
   
 
      

    
    
     
    
      
     
    return sdk 
}

export default enter