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

import mitt from 'mitt'

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


export const enter = (dom, isLocal) => {
    
    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 })
        } 
    })
    viewer.addEventListener('webglError', e => {
        console.error('viewer webglError: ' + e)
        sceneBus.emit('webglError', { msg: e.msg })
    })
    
    window.THREE = THREE
    //isLocal = false 
    let autoLoads = []  
    let readyToAddModel 
    let maxLoadingCount = /* isLocal ? 1 :  */2; //正在加载模型的最大数目
    
    
    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().clone()
            const position = viewer.scene.view.position.clone() 
            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}, 'tag', null,{distance:o.distance} ).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 //没用到
            } 
            */
            
            console.log('enterSceneGuide',pathArr)
            
            let data = {
                duration: pathArr.slice(0,pathArr.length-1).reduce(function(total, currentValue ){return total+currentValue.time}, 0), //总时长(要去掉最后一个，因为已到终点，该点time无意义)
                points: pathArr,
                useDurSlice:true
            }
            let animation = editor.createAnimation(data)
            //注：最多只存在一条导览
             
             
            
            let bus = mitt()

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

            return {
                bus, 
                play() { 
                    MergeEditor.selectModel(null)
                    animation.play()
                },
                pause() {
                    animation.pause()
                },
                 
                clear() {
                    //删除
                    editor.removeAnimation(animation)
                },
            } 
            
        },
        
        //[path1, paht2], {  time, speed }   
        calcPathInfo(paths, info){ //传入的time， speed仅有一个。返回完整的 time, speed
             //这一版的control似乎无法在某个位置上改变角度，位置和角度一般都是一起变的，所以先不增加单位更换功能。
             let pos1 = new THREE.Vector3().copy(paths[0].position)
             let pos2 = new THREE.Vector3().copy(paths[1].position)
             let dis = pos1.distanceTo(pos2)
             if(info.time != void 0){
                  info.speed = dis / info.time
             }else{
                  info.time = dis / info.speed
             }
             return info
        },
        
        
        //scaleRange: { min, max }, opacityRange: { min, max }, bottomRange: { min, max } })
        
        addModel(props){ 
            
            let bus = mitt()  
            //console.log('addModel',props)
            props.isFirstLoad = props.bottom == void 0 //在编辑时用户添加的
            if(props.opacity == void 0)  props.opacity = 1
            props.scale /= 100
            
            if(!props.isFirstLoad){ 
                if(autoLoads.length == 0){ //首次加载
                    setTimeout(()=>{
                        let sizes = autoLoads.map(e=>e.size)
                        console.log('需要请求加载的模型大小为', sizes, '总大小', sizes.reduce(function(total, currentValue ){
                            let current = parseFloat(currentValue)
                            return total + (currentValue.includes('M') ? current : current / 1024)
                        }, 0))
                         
                        readyToAddModel = true  //准备开始加载
                        startLoad(autoLoads[0])
                    },30) 
                }
                autoLoads.push(props) 
            }else{
                readyToAddModel = true
            }
             
            
            
            let startLoad = (prop)=>{
                //if(autoLoads.filter(e=>e.loaded).length>1)return console.log('取消加载', prop), prop.onError()
                Potree.addModel(prop,  prop.done , prop.progressFun, prop.onError)
                prop.loading = true
                console.log('startLoad',getName(prop.url),  prop )
            }
            
            let spliceFromArr = (model,loaded)=>{
                //let autoLoads.find()
                props.loadFinish = true
                props.loading = false
                  
                if(loaded){
                    props.loaded = true
                    props.model = model
                }else{
                    props.error = true 
                }
               
                let haventLoad = autoLoads.filter(e=>!e.loading && !e.loadFinish);
                if( haventLoad[0]){
                    startLoad(haventLoad[0])
                     
                    //this.addModel(autoLoads[0])
                }else if(autoLoads.filter(e=>!e.loadFinish).length == 0 && autoLoads.filter(e=>e.loaded).length>0 && !props.isFirstLoad){//设置相机位置：当自动开始加载第一个模型时(其余的也跟着自动加载),等这批加载完后;  
                    let autoLoadsDone = autoLoads.filter(e=>e.loaded).map(e=>e.model)
                    console.log('所有模型加载完毕')
                    MergeEditor.focusOn(autoLoadsDone, 1000)
                }  
            }
            
            let model
            let done = (model_)=>{
                model = model_
                props.opacity < 100 && 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 * 100,
                        rotation: model.rotation.clone(),
                        bottom: model.btmHeight
                    })
                }) 
                spliceFromArr(model,true)
                bus.emit('loadDone')
                
                //console.log('loadDone' )
            }
            let progressFun = (progress)=>{
                bus.emit('loadProgress',progress)
            }
            
            let onError = function ( xhr ) {
                bus.emit('loadError', xhr)
                console.log('loadError!!!!!!!!!',  getName(props.url), props.size, xhr) 
                spliceFromArr(model,false)
            }
            
            if(props.type == "glb"){////////////////////////////test
                if(props.url.includes('coffeemat')){
                    props.url = '/lib/potree/resources/models/glb/coffeemat.glb' 
                                     
                }
                //props.url += '5'
                //props.url = 'http://localhost:5173/api/profile/datav1/1537680519838306304/data/glb/cloud_glb_24.glb'   
            }
            
            
            props.done = done; props.progressFun = progressFun; props.onError = onError
            
            
            if(readyToAddModel){
                   
                if(autoLoads.filter(e=>e.loading).length<maxLoadingCount ){
                    startLoad(props)
                }
                    
            }
            
            
            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]){
                            MergeEditor.transformControls.attach(model) //viewer.transformObject(model); //交换
                        }
                    }
                },
                changeScale(s){
                    if(model){
                        s /= 100
                        model.scale.set(s,s,s)
                        model.dispatchEvent("scale_changed")
                    }
                },
                changeOpacity(opacity){ 
                    if(opacity == void 0)opacity = 100
                    opacity/=100
                    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){
                        MergeEditor.transformControls.attach(model)
                        MergeEditor.transformControls.mode = 'rotate'
                        /* viewer.transformObject(model);
                        viewer.transformationTool.setModeEnable('rotation',true)
                        viewer.transformationTool.setModeEnable('translation',false) */
                    }
                }, 
                enterMoveMode(){
                    if(model){
                        
                        MergeEditor.transformControls.attach(model)
                        MergeEditor.transformControls.mode = 'translate'
                        /* viewer.transformObject(model);
                        viewer.transformationTool.setModeEnable('rotation',false)
                        viewer.transformationTool.setModeEnable('translation',true) */
                    }
                },
                leaveTransform(){ 
                    //viewer.transformObject(null); 
                    MergeEditor.transformControls.detach()
                },
                 
                destroy(){
                    model && MergeEditor.removeModel(model) 
                }
                 
            } 
            
            return result
        }, 
        
        
        
    }
   
 
      

    
    function getName(url){
        return url.split('/').pop()
    }
     
    
      
     
    return sdk 
}

export default enter