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 = window.location.href.includes('http://localhost:5173/') ? '../lib/':'./lib/'   //在深时本地版访问这个时是'./lib/'，但本地调试是前者
    
    Potree.settings.notAdditiveBlending = true
    
    const tagLimitDis = 8;

    Potree.settings.showCompass = true
    Potree.settings.compassDom = dom.querySelector('#direction')
    Potree.settings.maintainBtmZ = true //有离地高度，需要维持不变
    
    let {THREE} = Potree.mergeEditStart(dom)
    let MergeEditor = viewer.modules.MergeEditor
    let sceneBus = mitt()
    
    
    MergeEditor.transformControls.pivotOnBottom = !!isLocal //中心点居于模型bound底部，因固定离地高度，旋转时旋转中心在地面上就不会变位置
    
    
    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, hopeModelId ){//通过屏幕坐标获取真实坐标 . hopeModelId： 如果指定了模型，优先返回hopeModelId上的intersect
            console.log('getPositionByScreen',hopeModelId)
            hopeModelId = null
            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(hopeModelId != void 0){//隐藏其他的模型
                    let models = MergeEditor.getAllObjects()
                    models.forEach(model=>{
                        Potree.Utils.updateVisible(model, 'forPick', model.dataset_id == hopeModelId)
                    }) 
                }
                let intersect2 = Handler.onMouseMove(pos2d)
                if(hopeModelId != void 0){//恢复
                    let models = MergeEditor.getAllObjects()
                    models.forEach(model=>{
                        Potree.Utils.updateVisible(model, 'forPick', true)
                    }) 
                }
                if(intersect2 && intersect2.location){
                    intersect = intersect2
                }
            }
            if (pos2d && pos2d.inDrag) {  
                reGet() 
            } else {
                intersect = Handler.intersect
                if(intersect){
                    modelId = intersect.pointcloud ? intersect.pointcloud.dataset_id : intersect.object.dataset_id
                    if(hopeModelId != void 0 && modelId != hopeModelId){
                        reGet()
                    } 
                }
            }

            if (intersect && intersect.location) {
                modelId = intersect.pointcloud ? intersect.pointcloud.dataset_id : intersect.object.dataset_id
                /* if(hopeModelId != void 0 && modelId != hopeModelId){
                    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, canShelter/* , disToCameraLimit */){//通过模型局部坐标获取屏幕坐标 
            
            
            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 
            
            
            if(canShelter){ 
                if(viewer.inputHandler.ifBlockedByIntersect(worldPos, 0.1, true)) return {trueSide:false}; 
            }
            
            
            var viewport = viewer.mainViewport
            var camera = viewport.camera
            var dom = viewer.renderArea
            if(tagLimitDis != void 0){
                if(camera.position.distanceToSquared(worldPos) > Math.pow(tagLimitDis,2))return false
            } 
            
            
            
            
            //console.log('getScreenByPoint ' + pos3d.toArray())
            return Potree.Utils.getPos2d(worldPos, camera, dom, viewport)
        },
        
        screenshot: (width, height) => {
            //截图 
            var {getImagePromise, finishPromise} =  viewer.startScreenshot({ type: 'default',useRenderTarget:true}, width, height) 
            var deferred = $.Deferred();
            finishPromise.done(({dataUrl}) => {
               deferred.resolve(dataUrl)
            })
            return deferred.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){ 
            //props.url = Potree.resourcePath+'/models/1.glb'

            let bus = mitt()  
            //console.log('addModel',props)
            props.isFirstLoad = props.bottom == void 0 //在编辑时用户添加的
            if(props.opacity == void 0)  props.opacity = 1
            if(props.type == 'obj') props.type = 'glb'
            props.scale /= 100
            if(props.rotation){
                if(props.rotation._x == void 0 && props.rotation.x != void 0){
                    props.rotation = new THREE.Euler().setFromVector3(props.rotation)
                }
            }
            
            
            
            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 + ((typeof currentValue == 'number' || currentValue.includes('M')) ? current : current / 1024)
                        }, 0))
                         
                        readyToAddModel = true  //准备开始加载
                        startLoad(autoLoads[0])
                    },30) 
                }
                autoLoads.push(props) 
                readyToAddModel = false               
            }else{
                readyToAddModel = true
            }
             
            
            
            let startLoad = (prop)=>{
                //if(autoLoads.filter(e=>e.loaded).length>1)return console.log('取消加载', prop), prop.onError()
                
                //return prop.onError()
            
                Potree.addModel(prop,  prop.done , prop.progressFun, prop.onError)
                prop.loading = true
                console.log('-------开始加载 id:', prop.id, 'title:', prop.title, ', filename:', 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('所有模型加载完毕')
                    autoLoads.filter(e=>e.loaded && e.show).forEach(e=>e.model.visible = true)
                    
                    MergeEditor.focusOn(autoLoadsDone, 1000, true, true)
                    autoLoads.length = 0
                    
                }  
            }
            
            let model
            let done = (model_)=>{
                model = model_
                if(!props.isFirstLoad){
                    model.visible = false//先不显示，防止卡顿
                }
                props.opacity < 100 && result.changeOpacity(props.opacity) 
                
                model.addEventListener('changeSelect',(e)=>{
                    bus.emit('changeSelect',e.selected)
                }) 
                
                let lastState={ } 
                model.addEventListener('transformChanged',(e)=>{
                    //console.log('transformChanged',model.position,model.scale.x, model.rotation,model.btmHeight)
                    let msg = {}
                    if(!lastState.position || !model.position.equals(lastState.position)){
                        lastState.position = msg.position = model.position.clone() 
                    }
                    if(!lastState.rotation || !model.rotation.equals(lastState.rotation)){
                        lastState.rotation = msg.rotation = model.rotation.clone()
                    }
                    if(lastState.scale == void 0 || model.scale.x * 100 != lastState.scale){
                        lastState.scale = msg.scale = model.scale.x * 100
                    }
                    if(lastState.bottom == void 0 || model.btmHeight != lastState.bottom){
                        lastState.bottom = msg.bottom = model.btmHeight
                    }
                    msg = Potree.Common.CloneObject(msg)
                    console.log(msg)
                    bus.emit('transformChanged', msg )
                }) 
                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)
            }
            
        
            
            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){ 
                    props.show = show  //for autoLoads show model
                    if(model){ 
                        Potree.Utils.updateVisible(model, 'changeShow', show) 
                        viewer.dispatchEvent('content_changed') 
                    } 
                },
                changeSelect(state){
                    if(model){
                        MergeEditor.selectModel(model, state, true, true)
                        if(state && viewer.inputHandler.selection[0]){
                            MergeEditor.transformControls.attach(model) //viewer.transformObject(model); //交换
                        }
                        //console.log('changeSelect',  props.id, state)
                    }
                },
                changeScale(s){
                    if(model){
                        s /= 100
                        model.scale.set(s,s,s)
                        model.isPointcloud && model.changePointSize(Potree.config.material.realPointSize * s)  
                        model.dispatchEvent("scale_changed")
                    }
                },
                changeOpacity(opacity){ //见笔记：透明物体的材质设置
                    if(opacity == void 0)opacity = 100
                    opacity/=100
                    if(model){
                        MergeEditor.changeOpacity(model,opacity) 
                    }
                     
                },
                changeBottom(z){
                    //console.log('changeBottom',z)
                    model && MergeEditor.setModelBtmHeight(model,z)
                    model.dispatchEvent('transformChanged') //改了position */
                },
                
                changePosition(pos){//校准取消时执行
                   
                    //console.log('changePosition',pos.x, pos.y, pos.z)
                    model && model.position.copy(pos)
                    model.dispatchEvent({type:'position_changed'}) 
                }, 
                changeRotation(rot){//校准取消时执行 
                    
                    //console.log('changeRotation',rot.x, rot.y, rot.z)
                    model && model.rotation.setFromVector3(rot) 
                    model.dispatchEvent({type:'rotation_changed'})  
                },
                
                
                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) 
                    viewer.dispatchEvent('content_changed')
                }
                 
            } 
            
            return result
        }, 
        
        
        
    }
   
 
      

    
    function getName(url){
        return url.split('/').pop()
    }
     
    
    console.log('版本： 2023.3.24-0')
     
    return sdk 
}

export default enter