potree-sdk/src/custom/modules/mergeModel/MergeEditor.js

 
import * as THREE from "../../../../libs/three.js/build/three.module.js";
import cameraLight from '../../utils/cameraLight.js' 

import math from "../../utils/math.js"
import Common from '../../utils/Common.js' 
import {LineDraw, MeshDraw} from "../../utils/DrawUtil.js"; 
import {transitions, easing, lerp} from '../../utils/transitions.js'
import SplitScreen from "../../utils/SplitScreen.js";
import InfiniteGridHelper from '../../objects/InfiniteGridHelper.js'
import Compass from "../../objects/tool/Compass.js";
import {TransformControls} from "../../objects/tool/TransformControls.js";
import History from "../../utils/History.js"

 
const texLoader = new THREE.TextureLoader() 
      texLoader.crossOrigin = "anonymous" 
  
const edgeStrengths = {
    pointcloud: 4,
    glb: 100
}
const viewportProps = [{
    left:0,
    bottom:0,
    width: 0.5,height:1,
    name : 'top',    
    axis:["x","y"],
    direction : new THREE.Vector3(0,0,-1), //镜头朝向 
    active: true,
    //相机位置在z轴正向
    limitBound: new THREE.Box3(new THREE.Vector3(-Infinity,-Infinity, 1),new THREE.Vector3(Infinity,Infinity,5000)), //在地面以上
    margin:{x:50, y:150} ,
},
{
    left:0.5,
    bottom:0,
    width: 0.5,height:1,
    name : 'right', 
    axis:["y","z"],
    direction : new THREE.Vector3(1,0,0), 
    active: true,
    //相机位置在x轴负向  右下角屏
    viewContainsPoints:[new THREE.Vector3(0,0,0)],
    margin:{x:300, y:250} ,
} ]
let cylinderSkyGeo, oldSkyGeo
 
 
let MergeEditor = {
    bus:new THREE.EventDispatcher(), 
     
    
    SplitScreen : new SplitScreen(),
    
    init(){  
    
    
        this.history = new History({ 
            applyData: (data)=>{ 
                if(data.object.parent /* && data.object == this.selected */){
                    data = Potree.Common.CloneObject(data) //避免使用后更改数据又被使用 
                    data.matrix.decompose( data.object.position, data.object.quaternion, data.object.scale );
                    data.object.boundCenter.copy(data.boundCenter)
                    data.object.dispatchEvent('changeByHistory') 
                    data.object.dispatchEvent('transformChanged')                    
                    viewer.dispatchEvent('content_changed')
                    
                    return true
                }  
            },
            getData:(object)=>{   
                return {
                    object,
                    matrix:  object.matrixWorld.clone(),
                    boundCenter: object.boundCenter.clone()
                }
            } 
        })  
        
    
        
        { 
        
            Potree.settings.notAdditiveBlending = true
        
            let ground = this.ground = new InfiniteGridHelper(1, 10000, new THREE.Color('#eee'), 10000, 0.2, 0.3)
            viewer.scene.scene.add(ground) 
            //再加两条线否则在正侧边看不到
            let line1 = LineDraw.createLine([new THREE.Vector3(-10000, 0, 0),new THREE.Vector3(10000, 0, 0) ], {color:'#aaa', })
            let line2 = LineDraw.createLine([new THREE.Vector3(0, -10000, 0),new THREE.Vector3(0, 10000, 0) ], {mat:line1.material})
            ground.renderOrder = Potree.config.renderOrders.model + 1//line1.renderOrder + 1  //要比模型低，否则模型透明时效果不对
            ground.add(line1) 
            ground.add(line2)
            ground.material.opacity = 0.9 //为了滞后渲染，否则被rt遮住
            ground.material.polygonOffset = true //多边形偏移(视觉上没有移动模型位置),防止闪烁
            ground.material.polygonOffsetFactor = 100 //多边形偏移因子
			ground.material.polygonOffsetUnits = 10 //多边形偏移单位  
            ground.material.depthWrite = false            
            //ground.material.depthTest = false
            line1.material.polygonOffset = true
            line1.material.polygonOffsetFactor = 130  
			line1.material.polygonOffsetUnits = 10  
            line1.material.depthWrite = false   
            //见笔记：透明物体的材质设置
        }
        
        let oriEdgeStrength = viewer.outlinePass.edgeStrength 
        {
            
            this.transformControls = new TransformControls(viewer.mainViewport.camera, viewer.renderArea,{
                dontHideWhenFaceCamera: true,
            });
            //this.transformControls.space = 'local'//为了在当前方向上平移
            this.transformControls.setSize(1.5)
            viewer.scene.scene.add(this.transformControls)
            this.transformControls._gizmo.hideAxis = {rotate:['e']}
            this.transformControls.setRotateMethod(2)
            
            
            //右屏
            this.transformControls2 = new TransformControls(viewer.mainViewport.camera, viewer.renderArea,{ 
                dontHideWhenFaceCamera: true,
            }); 
            this.transformControls2.setSize(1.5)
            viewer.scene.scene.add(this.transformControls2) 
            Potree.Utils.setObjectLayers(this.transformControls2, 'layer2' )  
             
             
            let mouseDown = (e)=>{
                 
                viewer.outlinePass.edgeStrength = 0//暂时消失线
                 
            }
            let mouseUp = (e)=>{
                 
                //this.updateEdgeStrength()
                viewer.outlinePass.edgeStrength = oriEdgeStrength
            }
            this.transformControls.addEventListener('mouseDown',mouseDown)
            this.transformControls2.addEventListener('mouseDown',mouseDown)
            this.transformControls.addEventListener('mouseUp',mouseUp)
            this.transformControls2.addEventListener('mouseUp',mouseUp)
            
            
            
            
            
            this.transformControls.addEventListener('mouseDown', ()=>{ //dragstart
                this.history.beforeChange(this.selected)
            })  
            this.transformControls.addEventListener('mouseUp',()=>{
                this.history.afterChange(this.selected)
            })

        }
        
        
        {
            
            this.secondCompass = new Compass(null)
            
        }
        
        viewer.setControls(viewer.orbitControls)
        //viewer.mainViewport.view.fixZWhenPan = true
        viewer.orbitControls.constantlyForward = true
        
        
        viewer.addEventListener('global_single_click',(e)=>{
            if(
                this.noNeedSelection  //如模型查看页
                || viewer.scene.cameraAnimations.some(c=>c.onUpdate) //正在播放
                || e.drag && e.drag.notPressMouse   //在加测量线
                || viewer.mainViewport.view.isFlying() //有其他校准
                || this.split           //分屏中
                || e.clickElement //触发别的点击事件，如测量时click marker  /* && e.clickElement != e.intersect.object */
            ){
                return
            }
            
            if(e.intersect){
                let object = e.intersect.object || e.intersect.pointcloud
                let objects = this.getAllObjects()
                if(objects.includes(object) && this.selected != object){ 
                    this.selectModel(object) 
                }else{
                    //if(!viewer.inputHandler.selection[0]){//正在平移和旋转，不允许取消
                        this.selectModel(null)
                    //}
                }                    
            }else{
                //if(!viewer.inputHandler.selection[0]){
                    this.selectModel(null)
                //}                
            }
        })  
        
        viewer.inputHandler.addEventListener('keydown', (e)=>{
            if((e.event.key).toLowerCase() == "h" ){ 
                this.fadeOutlineAuto = !this.fadeOutlineAuto
                this.showModelOutline(this.selected,!!this.selected)
            } 
        })
        //viewer.fxaaPass.enabled = false//viewer.ssaaRenderPass.enabled = false 
        viewer.outlinePass.enabled = true
        //Potree.settings.intersectWhenHover = false
        //Potree.Utils.updateVisible(viewer.reticule, 'force', false)
        viewer.composer.scaleRatio = 1
        viewer.composer.readTarget = false
        viewer.mainViewport.camera.near = 0.05; // too small will result in z-fighting
        
        viewer.addEventListener('updateModelBound', (e)=>{
            if(this.split){ 
                this.SplitScreen.updateCameraOutOfModel(/* this.selected && [this.selected] */) 
            } 
        })
        
        
        {//校准页面拖拽
            //左右屏都可以拖拽模型，旋转只能左屏
            let dragInfo  
            let drag = (e)=>{ 
                if(this.split &&  this.selected && this.transformState && (e.dragViewport.name == 'top' || this.transformState == 'translate')   ){ 
                    if(e.type == 'global_mousedown' ){ //开始
                        //if((e.intersect.object || e.intersect.pointcloud) == this.selected){
                        if(e.intersect.pointclouds.includes(this.selected) || e.intersect.allElements.some(e=>e.object == this.selected)){
                            
                            dragInfo = {}   
                            //if(this.selected.isPointcloud){ 
                                viewer.outlinePass.edgeStrength = 0//暂时消失线
                            //} 
                        }  
                    }
                         
                    if(e.type == 'global_drag' && dragInfo  ){ 
                        if(this.transformState == 'translate'){ 
                        
                            let moveVec = Potree.Utils.getOrthoCameraMoveVec(e.drag.pointerDelta, e.dragViewport.camera )//最近一次移动向量
                            this.selected.position.add(moveVec)
                            
                            this.selected.dispatchEvent("position_changed")
                        }else if(this.transformState == 'rotate'){
                            
                            let vec = new THREE.Vector3().subVectors(e.intersect.orthoIntersect || e.intersect.location, this.selected.boundCenter).setZ(0)
                            if(dragInfo.lastVec == void 0){//global_mousedown
                                dragInfo.lastVec = vec 
                                return
                            }
                            let angle = math.getAngle(dragInfo.lastVec, vec, 'z')   
                            dragInfo.lastVec = vec
                            
                            //this.selected.rotation.z += angle //局部
                            
                            
                            /* object.quaternion.copy( .setFromAxisAngle( new THREE.Vector3(0,0,1), angle ) );
                            object.quaternion.multiply( quaternionStart ).normalize(); */
                            let diffQua = new THREE.Quaternion().setFromAxisAngle( new THREE.Vector3(0,0,1), angle )
                            this.selected.quaternion.premultiply(diffQua) //世界
                            
                            
                            this.selected.dispatchEvent("rotation_changed")
                        }
                        
                        return {stopContinue:true}
                    } 
                }
                
            }
            
            viewer.addEventListener('global_mousedown',  drag) 
            viewer.addEventListener('global_drag', drag, {importance:10})
            viewer.addEventListener('global_mousemove', (e)=>{
                if(this.split && this.transformState && !e.drag && (e.hoverViewport.name == 'top' ||  this.transformState == 'translate')){
                    
                    /* if(this.lastHoverViewport != e.hoverViewport){
                        this.lastHoverViewport = e.hoverViewport
                        this.transformControls.view = e.hoverViewport.view
                        this.transformControls.camera = e.hoverViewport.camera
                        this.transformControls.hideAxis( this.transformState, e.hoverViewport.name == 'top' ? [z] : [x,y]);
                    } */
                    
                    
                    
                    
                    let mouseover =  e.intersect.pointclouds.includes(this.selected) || e.intersect.allElements.some(e=>e.object == this.selected)
                    //let mouseover = (e.intersect.object || e.intersect.pointcloud) == this.selected
                    if(mouseover){
                        if(this.transformState == 'translate'){
                            viewer.dispatchEvent({
                                type : "CursorChange", action : "add",  name:"movePointcloud" 
                            }) 
                        }else{
                            viewer.dispatchEvent({
                                type : "CursorChange", action : "add",  name:"rotatePointcloud" 
                            }) 
                        }
                    }else{
                        this.clearTranCursor()
                    }
                    
                } 
            })
            
            viewer.addEventListener('global_drop', (e)=>{
                dragInfo = null
                this.clearTranCursor()
                  
                //this.updateEdgeStrength()
                viewer.outlinePass.edgeStrength = oriEdgeStrength  
                
            })
        
        }
        
        
        /* viewer.addEventListener('background_changed',()=>{
          
        }) */
        
                   
        viewer.addEventListener('camera_changed',()=>{
            Common.intervalTool.isWaiting('updateMemoryUsage', ()=>{  
                 this.updateMemoryUsage()
            },  1000) 
        }) 
         
        
        viewer.addEventListener('setDisplay',this.updateMemoryUsage.bind(this))
    },
    
    
    clearTranCursor(){
        viewer.dispatchEvent({
            type : "CursorChange", action : "remove",  name:"movePointcloud" 
        })
        viewer.dispatchEvent({
            type : "CursorChange", action : "remove",  name:"rotatePointcloud" 
        })
    },
    
    enterSplit(){ 
        this.split = true
        if(this.selected) this.SplitScreen.focusCenter = this.selected.boundCenter //旋转中心。注意 boundCenter不能直接赋值，否则改变后focusCenter也要改
        else this.SplitScreen.focusCenter = null
        
        this.SplitScreen.splitStart(viewportProps)
        
        this.beforeSplit = {
            pointDensity: Potree.settings.pointDensity,
        }
        Potree.settings.pointDensity = 'fourViewports' //强制降低点云质量
         
        
        viewer.setControls(viewer.fpControls)  
         
        let rightViewport = viewer.viewports.find(e=>e.name == 'right')
        let topViewport = viewer.viewports.find(e=>e.name == 'top')
        topViewport.alignment = true
        rightViewport.rotateSide = true  
        rightViewport.skyboxFixPos = true
        rightViewport.skyboxMinZoom = 10
        rightViewport.skyboxRenderFun = ()=>{// 使cube的一面永远正向镜头。 因侧视图的camera是ortho类型，需要平视mesh才不会拉伸
            viewer.skybox.scene.children[0].rotation.copy(rightViewport.camera.rotation)
        }
        topViewport.skyboxRenderFun = ()=>{
            viewer.skybox.scene.children[0].rotation.set(0,0,0)
        }
         
        
        
        viewer.viewports[1].layersAdd('layer2') 
        viewer.viewports[0].layersAdd('layer1') 
        Potree.Utils.setObjectLayers(this.transformControls, 'layer1' ) 
        this.transformControls.view = viewer.viewports[0].view
        this.transformControls.camera = viewer.viewports[0].camera
        this.transformControls._gizmo.hideAxis = {translate:['z'], rotate:['x','y','z'] }
        this.transformControls2.view = viewer.viewports[1].view
        this.transformControls2.camera = viewer.viewports[1].camera
        this.transformControls2._gizmo.hideAxis = {translate:['x','y'], rotate:['x','y','z'] }
        

        this.secondCompass.changeViewport(viewer.viewports[0])
        this.secondCompass.setDomPos()
        this.secondCompass.setDisplay(true)   
        viewer.compass.changeViewport(viewer.viewports[1])
        viewer.compass.setDomPos()
        
        
        //this.changeSkyboxGeo(true)
    },
    
    
    leaveSplit(){
        this.split = false
        this.SplitScreen.unSplit()    
        viewer.setControls(viewer.orbitControls)
        
        Potree.settings.pointDensity = this.beforeSplit.pointDensity
        /* if(this.selected && this.selected.isPointcloud){ 
            this.showModelOutline(this.selected, true) 
            this.selected.material.activeAttributeName = "rgba"  
        } */
        this.transformControls.camera = viewer.viewports[0].camera
        this.transformControls.view = viewer.viewports[0].view 
        this.transformControls._gizmo.hideAxis = {rotate:['e']}
        Potree.Utils.setObjectLayers(this.transformControls, 'sceneObjects' )  //恢复
        
        
        viewer.compass.changeViewport(viewer.viewports[0]) //恢复 
        viewer.compass.setDomPos()
        this.secondCompass.setDisplay(false)
        
        
    },
    
    rotateSideCamera(angle){
        this.SplitScreen.rotateSideCamera(viewer.viewports.find(e=>e.name == 'right'), angle)
    },
    
    setTransformState(state){//校准时
        this.transformState = state  
        this.clearTranCursor()       
    },
     
    //---------------------------
    
    getAllObjects(){
        return viewer.objs.children.concat(viewer.scene.pointclouds)
    },
    
    getModel(id){
        let models = this.getAllObjects()
        return models.find(e=>e.dataset_id == id)
    },
    removeModel(model){
        if(this.selected == model) this.selectModel(null)
        let dispose = (e)=>{
            e.geometry && e.geometry.dispose() 
            e.material && e.material.dispose()
        }
        if(model.isPointcloud){
            dispose(model)
            viewer.scene.removePointCloud(model)
        }else{
            model.traverse(e=>{
                dispose(e) 
            })
            viewer.objs.remove(model)
            this.updateMemoryUsage()
        }   
        
        
        
    },
    
    selectModel(model, state=true, fitBound, by2d){
        if(!model) {
            model = this.selected
            state = false
        }
         
        if(state){
            if(this.selected){
                if(this.selected == model) return
                else{
                    let transToolAttached = !!this.transformControls.object
                    this.selectModel(this.selected, false, fitBound, by2d)
                    transToolAttached && this.transformControls.attach(model)
                }
            }
            this.selected = model
             
            MergeEditor.focusOn(model, 500, !!fitBound)     //通过在场景里点击模型的话，不focus
              
           
            this.showModelOutline(model)
             
            //this.updateEdgeStrength()
            
            //console.log('selectModel', model)
            
        }else{
            if(this.selected != model)return //model本来就没选中，不需要处理（防止2d先选中新的再取消旧的）
            this.showModelOutline(model, false)
             
            this.selected = null
            this.transformControls.detach()        //viewer.transformObject(null);
            //console.log('selectModel', null)
        } 
        
        
        
        if(!by2d && model){
            model.dispatchEvent({type:'changeSelect', selected : state})
        }
        
         

        
        
    },
    
    
    showModelOutline(model, state){ 
        if(this.fadeOutlineAuto){ 
            if(state === false){
                viewer.outlinePass.selectedObjects = []
                clearTimeout(this.timer)
                return
            }
            
            viewer.outlinePass.selectedObjects = [model]
            if(this.timer){
                clearTimeout(this.timer)
            }
            
            this.timer = setTimeout(()=>{
                viewer.outlinePass.selectedObjects = []
                viewer.dispatchEvent('content_changed') 
            }, 1000)
        }else{
            if(state === false){
                viewer.outlinePass.selectedObjects = []
            }else{
                viewer.outlinePass.selectedObjects = [model]
            } 
        }
        viewer.dispatchEvent('content_changed') 
    },
    
    /*updateEdgeStrength(){
        if(!this.selected)return 
         if(this.selected.isPointcloud){
            viewer.outlinePass.edgeStrength = edgeStrengths.pointcloud// / this.selected.material.opacity  
        }else{
            viewer.outlinePass.edgeStrength = edgeStrengths.glb
        }  
    },*/ 
    focusOn(objects, duration = 400, fitBound=true, dontLookUp){  
        if(!(objects instanceof Array)){
            objects = [objects]
        }
        let boundingBox = new THREE.Box3
        objects.forEach(object=>{
            boundingBox.union(object.boundingBox.clone().applyMatrix4(object.matrixWorld))
        })
         
        if(fitBound){
            viewer.focusOnObject({boundingBox}, 'boundingBox', duration, {dontLookUp, dontChangeCamDir:true}) 
        }else{ 
        
            /* 
            let position = viewer.inputHandler.intersect ? viewer.inputHandler.intersect.location : boundingBox.getCenter(new THREE.Vector3)
            position && viewer.focusOnObject({position},  'point', duration, {dontChangePos: true})
             */
            let position = viewer.inputHandler.intersect ? viewer.inputHandler.intersect.location : boundingBox.getCenter(new THREE.Vector3)
            if(!position)return
            
            
            /* let targetOld = viewer.mainViewport.view.getPivot()
            
            let projected1 = targetOld.clone().project(viewer.mainViewport.camera);
            let projected2 = position.clone().project(viewer.mainViewport.camera); //使用其z
			let targetNew = projected1.clone().setZ(projected2.z).unproject(viewer.mainViewport.camera); 
            viewer.mainViewport.view.lookAt(targetNew) */
            
            
            viewer.mainViewport.view.radius = viewer.mainViewport.camera.position.distanceTo(position)
            //为了不改画面，不调节方向了，只能调调radius，一定程度将target靠近model
        }  
    },
    
    
    moveBoundCenterTo(model,pos){ //使boundCenter在所要的位置 
        let diff = new THREE.Vector3().subVectors(pos, model.boundCenter) 
        model.position.add(diff); 
    },
    
    getBoundCenter(model){
        if(!model.boundCenter) model.boundCenter = new THREE.Vector3
        model.boundingBox.getCenter(model.boundCenter).applyMatrix4(model.matrixWorld) 
    },
    
    setModelBtmHeight(model, z ){  
        //无论模型怎么缩放、旋转，都使最低点为z
        if(z == void 0) z = model.btmHeight; //维持离地高度
        else model.btmHeight = z;
        
        if(model.btmHeight == void 0)return
        
        model.updateMatrixWorld()
        let boundingBox2 = model.boundingBox.clone().applyMatrix4(model.matrixWorld)
        let size = boundingBox2.getSize(new THREE.Vector3);
        let center = boundingBox2.getCenter(new THREE.Vector3);
        let hopeZ = z + size.z / 2  
        //model.position.z = z + size.z / 2 - center.z 
        model.position.z += (hopeZ - center.z)
    },
    
    computeBtmHeight(model){ //位移之后重新计算btmHeight
        model.updateMatrixWorld()
        let boundingBox2 = model.boundingBox.clone().applyMatrix4(model.matrixWorld)
        let size = boundingBox2.getSize(new THREE.Vector3);
        let center = boundingBox2.getCenter(new THREE.Vector3);
        model.btmHeight = center.z - size.z / 2 
    },
    
    
    maintainBoundXY(model){ //在旋转和缩放后，立即执行这个函数，使boundCenter保持原位
         
        model.updateMatrixWorld()
        let center1 = model.boundCenter.clone();//还未更新的 
        this.getBoundCenter(model)//更新
        let center2 = model.boundCenter.clone();
        let diff = new THREE.Vector2().subVectors(center1,center2); 
        model.position.x += diff.x;
        model.position.y += diff.y;
        model.boundCenter.copy(center1)
    }, 
     
    
    
    maintainBoundCenter(model){
        model.updateMatrixWorld()
        let center1 = model.boundCenter.clone();//还未更新的 
        this.getBoundCenter(model)//更新
        let center2 = model.boundCenter.clone();
        let diff = new THREE.Vector3().subVectors(center1,center2); 
        model.position.add(diff)
        model.boundCenter.copy(center1)
    },
    
    modelTransformCallback(model){
        
        model.updateMatrixWorld() 
        if(model.matrixWorld.equals(model.lastMatrixWorld))return
        viewer.scene.measurements.forEach(measure=>{
            let changed
            measure.points_datasets.forEach((dataset_id,i)=>{
                if(dataset_id == model.dataset_id){
                    changed = true
                    measure.points[i] = Potree.Utils.datasetPosTransform({fromDataset:true,datasetId:dataset_id, position:measure.dataset_points[i].clone()})
                    measure.updateMarker(measure.markers[i], measure.points[i])
                   
                }
            })
            if(changed){//仿transformByPointcloud
                measure.getPoint2dInfo(measure.points)
                measure.update() 
                measure.setSelected(false)//隐藏edgelabel  
            }
        }) 
        
        model.lastMatrixWorld = model.matrixWorld.clone()
        viewer.dispatchEvent('content_changed')
        viewer.mapViewer && Potree.settings.showObjectsOnMap && viewer.mapViewer.dispatchEvent('content_changed')
    },
    
    
    changeOpacity(model, opacity){
         
        let isRoot = model.dataset_id != void 0  //是否是最外层 
             
    
        if(model.isPointcloud){ 
            model.changePointOpacity(opacity) 
            //MergeEditor.updateEdgeStrength()
        }else{
            //model.traverse(e=>e.material && setOp(e, opacity))
            model.traverse(mesh=>{ 
                if(mesh.material){ 
                    if(mesh.material.originOpacity == void 0 ){
                        mesh.material.originOpacity = mesh.material.opacity
                    }
                    mesh.material.opacity = mesh.material.originOpacity * opacity
                    
                    if(mesh.material.opacity<1){
                        mesh.material.transparent = true  
                        /* if(model.isPointcloud){
                            mesh.changePointOpacity(realOpacity)  
                        }else{
                            mesh.material.opacity = realOpacity
                        } */
                        
                        mesh.renderOrder = Potree.config.renderOrders.model+1 
                        //mesh.material.depthWrite = false
                    }else{
                        mesh.material.transparent = false
                        mesh.renderOrder = Potree.config.renderOrders.model
                        //mesh.material.depthWrite = true
                    }
                    mesh.material.depthWrite = mesh.material.opacity>0.3
                }
            })
        }
            
              
        isRoot && (model.opacity = opacity)//记录在最外层
        viewer.dispatchEvent('content_changed')
        
    },
    
    modelAdded(model){
        model.addEventListener('isVisible',(e)=>{ 
            if(e.reason == "overlinePass")return
            //console.log(e)
            viewer.addEventListener('update',()=>{ //下一次更新结束后
                this.updateMemoryUsage()
            },{once:true})  
        })
        this.updateMemoryUsage()
    },
    
    
    
    updateMemoryUsage(){
        
        //obj暂时不管其贴图大小, 因为顶点造成的不仅是内存还有卡顿所以先只看顶点
        const maxMemory = Potree.config.tiles3DMaxMemory + 100 //M  实际估计是这个的10倍
        const eachObjPosWeight = 100/1000/1000  //M  每个顶点pos是3*4个字节？法线3*4和uv2*4  其实还有贴图 
        const eachCloudPointWeight = 12/1000/1000 //M 每个点 pos + 颜色 + 法线 大概  
        const eachVisiCPointWeight = eachCloudPointWeight * 5    // 或 maxMemory / (6*1000*1000) 大概值接近 (再除以一个数是因为显示的要比内存中的耗更多资源
        const eachGltfPosWeight = 100/1000/1000  //M  每个顶点pos是3*4个字节？法线3*4和uv2*4  其实还有贴图 
        let posCount=0

        
        viewer.objs.children.forEach(e=>{
            if(e.fileType == 'glb' || e.fileType == 'obj'){
                e.traverse((mesh)=>{
                    if(mesh.geometry){
                        posCount += mesh.geometry.attributes.position.count
                    } 
                })
            }else if(e.fileType == '3dTiles'){
                  
            }
        })
        
        //获取点云的内存限制
        let objWeight = posCount*eachObjPosWeight
        let laserWeight = Potree.numVisiblePoints  * eachCloudPointWeight //点云实际显示所占大小
        let laserMemoryWeight =  Potree.lru.numPoints * eachCloudPointWeight   //点云所使用内存大小
        let tiles3DWeight = viewer.tiles3dVisiVCount * eachGltfPosWeight //M   3dTiles所占内存大小
        let tiles3DMemoryWeight = viewer.tiles3dMemoryUsage / 1000 / 1000  //M   3dTiles显示的所占内存大小
        
        /* let min = 0.1, max = 6, minP = 100, maxP = 1000000; 
        let ratio = Math.round(math.linearClamp(score, minP, maxP, max, min ));  */
	    let rest = maxMemory - objWeight - tiles3DWeight         
        Potree.pointBudget = Math.max(30000, Math.round(rest/eachVisiCPointWeight)) 
        
        //获取3dTiles的内存限制 
        let tiles3DMaxMemory = maxMemory - Math.round(objWeight + laserWeight)
        Potree.settings.tiles3DMaxMemory = THREE.Math.clamp(tiles3DMaxMemory , 30, Potree.config.tiles3DMaxMemory )
        
        
        
        //还存在的问题：仍然有隐患，因为没用到真实缓存的大小： tiles3DMemoryWeight  laserMemoryWeight， 它们比真实可见的要多。不使用是因为它们无法反应出实际需要的内存量，缓存是只增不减
        //obj等普通mesh限制不了
        
        
        //console.log('objWeight',objWeight.toFixed(1), 'laserMemoryWeight',laserMemoryWeight.toFixed(1), 'tiles3DWeight',tiles3DWeight.toFixed(1),  'pointBudget',Potree.pointBudget, 'tiles3DMaxMemory',tiles3DMaxMemory)
        
        
        //总内存 = 内存占用空间+图片缓存 ， obj的缓存比较多在图片中
        
        
    },
    
    
    setGroundPlaneImg(src,scale){//设置地面图
        
        this.goundScale = scale
        let oldSrc = this.curGroundImgSrc
        this.curGroundImgSrc = src
        const ratio = 0.04
        
        
        if(src){
            if(oldSrc == src && this.groundPlane.material.map.image){ //仅修改大小
                const s = ratio * this.goundScale
                let {width, height} = this.groundPlane.material.map.image
                this.groundPlane.scale.set(width*s, height*s)  
                viewer.dispatchEvent('content_changed')
                
                return
            }
            
            let map = texLoader.load(src,(tex)=>{
                if(this.curGroundImgSrc == src){
                    const s = ratio * this.goundScale
                    this.groundPlane.scale.set(tex.image.width*s, tex.image.height*s)  
                    viewer.dispatchEvent('content_changed')
                } 
            })
            Potree.Utils.makeTexDontResize(map)          
            if(!this.groundPlane){
                this.groundPlane = new THREE.Mesh(new THREE.PlaneBufferGeometry(1,1,1), new THREE.MeshBasicMaterial({
                    map,  
                    side : 2,
                    
                }))
                viewer.scene.scene.add(this.groundPlane)
                this.groundPlane.position.z = -1
            }else{
                this.groundPlane.material.map = map
            }
            
            Potree.Utils.updateVisible(this.groundPlane,'show',true )
        }else{
            this.groundPlane && Potree.Utils.updateVisible(this.groundPlane,'show',false )
        }  
    }
    
}   
    
    
    
  
    
    
export default MergeEditor  
    
    
/*  

note:

要注意getHoveredElements只在getIntersect时才使interactables包含加载的model， 也就是model上不能有使之成为interactables的事件，否则在鼠标hover到模型上开始转动的一瞬间很卡。





*/