@aibee/owlly 1.0.25

package/lib/src/owlly/element/panorama-group.js

@@ -0,0 +1,967 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Externals } from '../stage/externals';
+import { Element, ElementFrameContext, } from './element';
+import { Panorama, } from './panorama';
+import { CubeTextureCache } from '../utils/cube-texture-cache';
+import { EventHub } from '../utils/event-hub';
+import { FloorModel } from './floor-model';
+import { OwllyEvents, Events } from '../utils/events';
+import { BasicTools } from '../utils/basic-tools';
+/** 全景点位显示模式
+ * 点位的显示/隐藏状态通过[setIndicatorVisibility]方法设置，
+ * 但是最终是否显示、以何外观显示，则是结合PanoramaGroup在当前View的显示模式来决定
+ * @param AlwaysHide 不论显示/隐藏的设置如何，都不显示
+ * @param AlwaysShow 不论显示/隐藏的设置如何，都不显示。该模式主要用于俯视全局视图用
+ * @param Editing 编辑模式，隐藏/显示状态的点位用不同的外观显示
+ * @param Show 按显示/隐葳的状态设置决定是否显示
+*/
+var IndicatorDisplayMode;
+(function (IndicatorDisplayMode) {
+    IndicatorDisplayMode[IndicatorDisplayMode["AlwaysHide"] = 0] = "AlwaysHide";
+    IndicatorDisplayMode[IndicatorDisplayMode["AlwaysShow"] = 1] = "AlwaysShow";
+    IndicatorDisplayMode[IndicatorDisplayMode["Editing"] = 2] = "Editing";
+    IndicatorDisplayMode[IndicatorDisplayMode["Show"] = 3] = "Show";
+})(IndicatorDisplayMode || (IndicatorDisplayMode = {}));
+/**
+ * 全景图组
+ * @noInheritDoc
+ */
+class PanoramaGroup extends Element {
+    /**
+     * @param modelElement 模型对象，通常应该是FloorModel
+     * @param groundParams 地面参数对象，若有则在计算地面高度时忽略modelElement，优先使用它
+     * @param indicatorImageURL 显示状态全景点地面标识的图片URL
+     * @param invisibleIndicatorImageURL 编辑模式下隐藏状态全景点地面标识的图片URL
+     * @param indicatorWidth 全景点地面标识宽度
+     * @param indicatorHeight 全景点地面标识高度
+     * @example
+     * ``` typescript
+     * panoMgr = new PanoramaGroup(panoramaDataList, 2, {
+     *  floorModel,
+     *  groundParams,
+     * });
+     * stage.bindElement(panoMgr);
+     */
+    constructor(panoramaDataList, options, initializeAllPanoramas) {
+        super();
+        const { THREE } = Externals.getInstance();
+        this.initialized = false;
+        // this.currentPanorama = null;
+        const { modelElement, groundParams, indicatorImageURL, invisibleIndicatorImageURL, indicatorWidth, indicatorHeight, indicatorPositionMap, globalScale, } = options || { globalScale: 1 };
+        this.currentPanoramaID = -1;
+        this.panoramaMap = new Map();
+        this.indicatorMap = new Map();
+        this.indicatorVisibilityMap = new Map();
+        this.indicatorHiddenMap = new Map();
+        this.indicatorPositionMap = indicatorPositionMap ? indicatorPositionMap : new Map();
+        this.inSightIndicators = [];
+        this.indicatorWidth = indicatorWidth || (2 * PanoramaGroup.IndicatorRadius);
+        this.indicatorHeight = indicatorHeight || (2 * PanoramaGroup.IndicatorRadius);
+        this.maxWorldDistance = 13;
+        this.globalScale = globalScale || 1;
+        this.group = new THREE.Group();
+        this.add(this.group);
+        this.viewConfigurations = new Map();
+        this.eventListeners = {
+            onFloorModelLoaded: (element) => {
+                if (element !== this.modelElement)
+                    return;
+                this.updateIndicatorsPositions();
+            },
+        };
+        this.groundParams = groundParams;
+        this.bindModelElement(modelElement);
+        const vertexShader = [
+            'varying vec2 vUv;',
+            'void main(){',
+            '   vUv = uv;',
+            '   gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);',
+            '}',
+        ].join('\n');
+        const fragmentShader = [
+            'uniform sampler2D map;',
+            'uniform float opacity;',
+            'uniform vec4 blendColor;',
+            'varying vec2 vUv;',
+            'void main(){',
+            '   vec4 texColor = texture2D(map, vUv);',
+            '   gl_FragColor = vec4((texColor * (1.0 - blendColor.a) + blendColor * blendColor.a).rgb, texColor.a * opacity);',
+            '}',
+        ].join('\n');
+        this.indicatorShaderUniforms = {
+            map: {
+                type: 't',
+                value: null,
+            },
+            blendColor: {
+                type: 'v4',
+                value: new THREE.Vector4(0, 0, 0, 0),
+            },
+            opacity: { value: 1 },
+        };
+        this.invisibleIndicatorShaderUniforms = {
+            map: {
+                type: 't',
+                value: null,
+            },
+            blendColor: {
+                type: 'v4',
+                value: new THREE.Vector4(1.0, 0.0, 0.0, 0.5),
+            },
+            opacity: { value: 1 },
+        };
+        this.indicatorMaterials = new Map();
+        let indicatorMaterial;
+        let indicatorGeometry;
+        if (indicatorImageURL) {
+            indicatorGeometry = new THREE.PlaneBufferGeometry(this.indicatorWidth, this.indicatorHeight);
+            indicatorMaterial = new THREE.ShaderMaterial({
+                // 设置透明属性，这样透过全景图就能看到标签
+                transparent: true,
+                vertexShader,
+                fragmentShader,
+                uniforms: this.indicatorShaderUniforms,
+                side: THREE.DoubleSide,
+                depthTest: false,
+                depthWrite: false,
+                name: 'indicatorMaterial',
+            });
+            this.indicatorImageURL = indicatorImageURL;
+            new THREE.TextureLoader().load(indicatorImageURL, (texture) => {
+                this.indicatorShaderUniforms.map.value = texture;
+            });
+        }
+        else {
+            indicatorGeometry = new THREE.CircleGeometry(this.indicatorWidth / 2, 32);
+            indicatorMaterial = new THREE.MeshBasicMaterial({ transparent: true });
+            indicatorMaterial.side = THREE.DoubleSide;
+            indicatorMaterial.depthTest = false;
+            indicatorMaterial.depthWrite = false;
+            indicatorMaterial.color = new THREE.Color(0xffffff);
+        }
+        let invisibleIndicatorMaterial;
+        const invisibleIndicatorImageURL1 = invisibleIndicatorImageURL || indicatorImageURL;
+        if (invisibleIndicatorImageURL1) {
+            invisibleIndicatorMaterial = new THREE.ShaderMaterial({
+                // 设置透明属性，这样透过全景图就能看到标签
+                transparent: true,
+                vertexShader,
+                fragmentShader,
+                uniforms: this.invisibleIndicatorShaderUniforms,
+                side: THREE.DoubleSide,
+                depthTest: false,
+                depthWrite: false,
+                name: 'invisibleIndicatorMaterial',
+            });
+            new THREE.TextureLoader().load(invisibleIndicatorImageURL1, (texture) => {
+                this.invisibleIndicatorShaderUniforms.map.value = texture;
+            });
+        }
+        else {
+            invisibleIndicatorMaterial = new THREE.MeshBasicMaterial();
+            invisibleIndicatorMaterial.side = THREE.DoubleSide;
+            invisibleIndicatorMaterial.depthTest = false;
+            invisibleIndicatorMaterial.depthWrite = false;
+            invisibleIndicatorMaterial.color = new THREE.Color(0xff0000);
+        }
+        const indicator = new THREE.Mesh(indicatorGeometry, indicatorMaterial);
+        this.setIndicatorMeshPrototype(indicator);
+        this.setIndicatorMaterial(indicatorMaterial, IndicatorDisplayMode.Editing, true);
+        this.setIndicatorMaterial(invisibleIndicatorMaterial, IndicatorDisplayMode.Editing, false);
+        this.setIndicatorMaterial(indicatorMaterial, IndicatorDisplayMode.Show, true);
+        this.panoramaDatas = new Map();
+        panoramaDataList.forEach((item) => {
+            this.panoramaDatas.set(item.pid, item);
+        });
+        this.panoramaCreatingTasks = new Map();
+        if (initializeAllPanoramas === true) {
+            panoramaDataList.forEach((item) => {
+                this.getPanoramaByPID(item.pid);
+            });
+        }
+        if (this.modelElement instanceof FloorModel) {
+            if (this.modelElement.isModelLoaded()) {
+                this.updateIndicatorsPositions();
+            }
+        }
+        // console.info('#Async# All this.asyncLoadingTasks done', this.asyncLoadingTasks);
+        EventHub.on(OwllyEvents.ELEMENT_LOADED, this.eventListeners.onFloorModelLoaded);
+        this.initialized = false;
+        this.needUpdate = false;
+    }
+    dispose(exceptForCubeTextureOfPID) {
+        super.dispose();
+        EventHub.off(OwllyEvents.ELEMENT_LOADED, this.eventListeners.onFloorModelLoaded);
+        if (this.panoramaMap) {
+            this.panoramaMap.forEach((pano) => {
+                // console.info('#PanoCtrl# 5 Will remove pano:', pano.position);
+                this.group.remove(pano);
+                if (exceptForCubeTextureOfPID !== pano.pid) {
+                    CubeTextureCache.sharedInstance.recycleCubeTexture(pano.textureURLs);
+                }
+                pano.dispose();
+            });
+            this.panoramaMap.clear();
+        }
+        if (this.indicatorMap) {
+            this.indicatorMap.forEach((indicator) => {
+                this.group.remove(indicator);
+            });
+            this.indicatorMap.clear();
+        }
+        if (this.boundBox) {
+            this.group.remove(this.boundBox);
+            this.boundBox.geometry.dispose();
+        }
+        this.remove(this.group);
+    }
+    /**
+     * @ignore
+     */
+    update() {
+        const frameContext = new ElementFrameContext(this);
+        if (!this.initialized) {
+            this.initialized = true;
+            frameContext.needUpdate = true;
+        }
+        else if (this.needUpdate) {
+            const pidPositionMap = this.getPIDPositionMap(this.inSightIndicators);
+            pidPositionMap.forEach((p, pid) => {
+                const position = this.indicatorPositionMap.get(pid);
+                if (!position) {
+                    if (this.groundParams || this.modelElement instanceof FloorModel) {
+                        let precisePosition;
+                        // console.log('## PanoramaGroup.update() will update indicator position');
+                        if (this.groundParams && this.groundParams.groundPlane) {
+                            precisePosition = FloorModel.intersectWithGroundPlane(p, this.groundParams);
+                        }
+                        else {
+                            const model = this.modelElement;
+                            precisePosition = model.intersectGround(p);
+                        }
+                        if (precisePosition) {
+                            this.indicatorPositionMap.set(pid, precisePosition);
+                        }
+                    }
+                }
+            });
+            this.inSightIndicators.forEach((pid) => {
+                // this.indicatorPositionMap.forEach((indicatorPosition: Vector3, pid: number) => {
+                // this.panoramaMap.forEach((pano: Panorama, pid: number) => {
+                let indicator = this.indicatorMap.get(pid);
+                if (!indicator) {
+                    indicator = this.indicatorMeshPrototype.clone();
+                    this.indicatorMap.set(pid, indicator);
+                    this.group.add(indicator);
+                    const panoData = this.panoramaDatas.get(pid);
+                    if (panoData && panoData.position) {
+                        indicator.position.copy(panoData.position);
+                    }
+                }
+                const position = this.indicatorPositionMap.get(pid);
+                if (position) {
+                    indicator.position.copy(position);
+                }
+            });
+            this.needUpdate = false;
+            frameContext.needUpdate = true;
+        }
+        else {
+            this.panoramaMap.forEach((pano) => {
+                const subFrameContext = pano.update();
+                if (subFrameContext.needUpdate) {
+                    frameContext.needUpdate = true;
+                }
+            });
+        }
+        if (this.initialized && !this.parent) {
+            frameContext.shouldPlaceElement = true;
+        }
+        return frameContext;
+    }
+    /**
+     * 绑定模型Element对象（用于创建天空包围盒供全景切换时使用）
+     * @param modelElement 模型Element对象
+     */
+    bindModelElement(modelElement) {
+        if (modelElement) {
+            this.modelElement = modelElement;
+        }
+        if (this.boundBox) {
+            this.group.remove(this.boundBox);
+            this.boundBox = null;
+        }
+        this.getModelBoundBox();
+    }
+    static getBoundBox(rootObj) {
+        if (!rootObj)
+            return null;
+        const { THREE } = Externals.getInstance();
+        const box = new THREE.Box3().setFromObject(rootObj);
+        const size = box.getSize(new THREE.Vector3());
+        const sideLength = Math.max(size.x, size.y, size.z); // 外扩10个单位
+        // const minX = -sideLength;
+        // const maxX = sideLength;
+        // const minY = -sideLength;
+        // const maxY = sideLength;
+        // const minZ = -sideLength;
+        // const maxZ = sideLength;
+        // const boundBox = new THREE.Mesh(new THREE.BoxBufferGeometry(maxX - minX, maxY - minY, maxZ - minZ));
+        // boundBox.position.set((maxX + minX) / 2, (maxY + minY) / 2, (maxZ + minZ) / 2);
+        const boundBox = new THREE.Mesh(new THREE.BoxBufferGeometry(sideLength, sideLength, sideLength));
+        boundBox.position.copy(box.max.clone().add(box.min).multiplyScalar(0.5));
+        return boundBox;
+    }
+    getModelBoundBox() {
+        if (this.boundBox)
+            return;
+        this.boundBox = PanoramaGroup.getBoundBox(this.modelElement);
+        if (this.boundBox) {
+            this.boundBox.visible = true;
+            // 设置天空盒不被视锥裁剪，这样天空盒资源就能直接加载到GPU里面
+            this.boundBox.frustumCulled = false;
+            this.boundBox.renderOrder = 100;
+            this.group.add(this.boundBox);
+        }
+    }
+    setBoundBoxAppearance(material) {
+        this.getModelBoundBox();
+        if (!this.boundBox)
+            return;
+        this.boundBox.material = material;
+        this.needUpdate = true;
+    }
+    setBoundBoxVisible(visible) {
+        if (!this.boundBox)
+            return;
+        this.boundBox.visible = visible;
+    }
+    /**
+     * 加载指定全景图并加入场景（显示要通过PanoramaController）
+     * @param panorama 要加载的全景图
+     */
+    presentPanorama(panorama, hdTiles, ldTiles) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // await panorama.updateTexture();// /!!!#TiledCube#
+            if (!panorama.legacyMode) {
+                yield panorama.updateFaceGridsTextures(hdTiles, ldTiles);
+                this.needUpdate = true;
+            }
+            // console.info('#TiledCube# presentPanorama updated tiles:', ldTiles);
+            // if (this.currentPanorama) {
+            //   // this.group.remove(this.currentPanorama);
+            //   this.currentPanorama.visible = false;
+            // }
+            // this.currentPanorama = panorama;
+            // this.group.add(panorama);
+            // panorama.visible = true;
+        });
+    }
+    /**
+     * 加载指定PID的全景图并加入场景（显示要通过PanoramaController）
+     * @param pid 要加载的全景图ID
+     */
+    presentPanoramaOfPID(pid, hdTiles, ldTiles) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pano = yield this.getPanoramaByPID(pid);
+            if (pano) {
+                yield this.presentPanorama(pano, hdTiles, ldTiles);
+            }
+            this.currentPanoramaID = pid;
+            this.emit(Events.PANORAMA_PRESENTED, pid);
+        });
+    }
+    /**
+     * 获取一组全景点的立方体贴图，若没命中则异步加载
+     * @param pids 全景点ID数组
+     * @param waitForReadyCount 指定函数必须在pids中的前多少个全景点立方体贴图获取到以后才能返回
+     * 比如在即将显示一个全景点时，指定必须等指定全景点的立方体贴图获取到后才能返回，而其周围全景点可以同时预加载但不用等
+     */
+    preloadCubeTexturesOfPIDs(pids, waitForReadyCount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const textureURLsArray = pids.map((pid) => {
+                const panoData = this.panoramaDatas.get(pid);
+                if (panoData) {
+                    return panoData.textureURLs;
+                }
+                return undefined;
+            });
+            return CubeTextureCache.sharedInstance.preloadCubeTextures(textureURLsArray, waitForReadyCount);
+        });
+    }
+    visibleRadiusOfView(view) {
+        if (!view)
+            return PanoramaGroup.DefaultVisibleRadius;
+        const conf = this.viewConfigurations.get(view);
+        if (conf && conf.visibleRadius)
+            return conf.visibleRadius;
+        return PanoramaGroup.DefaultVisibleRadius;
+    }
+    allPanoramas() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const created = Array.from(this.panoramaMap.values());
+            const pending = yield Promise.all(Array.from(this.panoramaCreatingTasks.values()));
+            return created.concat(pending);
+        });
+    }
+    getAllPanoramas() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.initializePanoramasIfNecessary('all');
+        });
+    }
+    panoramaIDsAround(centerPID, view) {
+        const rootNode = this.panoramaDatas.get(centerPID);
+        if (!rootNode || !rootNode.position) {
+            return null;
+        }
+        const ret = [centerPID];
+        const visibleRadius = this.visibleRadiusOfView(view);
+        const neighbours = rootNode.neighbourPanoramaIDs.map((pid) => this.panoramaDatas.get(pid));
+        // console.info(`#Async# neighbours(${neighbours.length})`, neighbours);
+        neighbours.forEach((neighbour) => {
+            if (neighbour && neighbour.position) {
+                const distance = rootNode.position.distanceTo(neighbour.position);
+                if (distance <= visibleRadius) {
+                    ret.push(neighbour.pid);
+                }
+            }
+        });
+        // const bfsQueue: Panorama[] = [rootNode];
+        // const touched: Set<number> = new Set();
+        // touched.add(rootNode.pid);
+        // let start = 0;
+        // while (start < bfsQueue.length) {
+        //   const node: Panorama = bfsQueue[start];
+        //   node.neighbourPanoramaIDs.forEach((pid: number) => {
+        //     if (touched.has(pid)) {
+        //       return;
+        //     }
+        //     touched.add(pid);
+        //     const neighbour: Panorama|undefined = this.panoramaMap.get(pid);
+        //     if (neighbour) {
+        //       bfsQueue.push(neighbour);
+        //       if (node === rootNode) {
+        //         const distance = node.position.distanceTo(neighbour.position);
+        //         if (distance <= visibleRadius) {
+        //           ret.push(neighbour.pid);
+        //         }
+        //       }
+        //     }
+        //   });
+        //   start += 1;
+        // }
+        // console.info(`## panoramaIDsAround(${centerPID})=`, ret);
+        return ret;
+    }
+    /**
+     * 设置当前位于的全景点位。将加载指定全景点并预加载其相邻全景点
+     * @param {number} currentPID 全景点位ID
+     */
+    presentPanoramaAround(currentPID, hdTiles, ldTiles, view) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const panoIDs = this.panoramaIDsAround(currentPID, view);
+            if (panoIDs) {
+                // await this.preloadCubeTexturesOfPIDs(panoIDs.slice(1, panoIDs.length), 0);
+                yield this.presentPanoramaOfPID(currentPID, hdTiles, ldTiles);
+            }
+        });
+    }
+    /** @ignore */
+    getPIDPositionMap(pids) {
+        const ret = new Map();
+        pids.forEach((value) => {
+            const panoData = this.panoramaDatas.get(value);
+            if (panoData) {
+                ret.set(value, panoData.position);
+            }
+        });
+        return ret;
+    }
+    getIndicatorPosition(pid) {
+        return this.indicatorPositionMap.get(pid);
+    }
+    /**
+     * 显示指定全景点位标签
+     * @param pidPositionMap 从PID映射到全景点位位置的Map
+     */
+    presentPanoramaIndicators(pidPositionMap) {
+        if (!this.modelElement)
+            return;
+        this.inSightIndicators = [];
+        const { THREE } = Externals.getInstance();
+        pidPositionMap.forEach((position, pid) => {
+            if (this.groundParams || this.modelElement instanceof FloorModel) {
+                const savedPosition = this.indicatorPositionMap.get(pid);
+                if (!savedPosition) {
+                    let p;
+                    // console.log('## PanoramaGroup.presentPanoramaIndicators() will update indicator position');
+                    if (this.groundParams && this.groundParams.groundPlane) {
+                        p = FloorModel.intersectWithGroundPlane(position, this.groundParams);
+                    }
+                    else {
+                        const model = this.modelElement;
+                        p = model.intersectGround(position);
+                    }
+                    if (p) {
+                        this.indicatorPositionMap.set(pid, p.add(new THREE.Vector3(0, 0, PanoramaGroup.IndicatorOffsetZ)));
+                    }
+                }
+            }
+            this.inSightIndicators.push(pid);
+        });
+        this.needUpdate = true;
+    }
+    updateIndicatorsPositions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { THREE } = Externals.getInstance();
+            this.panoramaMap.forEach((pano, pid) => {
+                const savedPosition = this.indicatorPositionMap.get(pid);
+                if (savedPosition)
+                    return;
+                const { position } = pano;
+                let p;
+                // console.log('## PanoramaGroup.presentPanoramaIndicators() will update indicator position');
+                if (this.groundParams && this.groundParams.groundPlane) {
+                    p = FloorModel.intersectWithGroundPlane(position, this.groundParams);
+                }
+                else {
+                    const model = this.modelElement;
+                    p = model.intersectGround(position);
+                }
+                if (p) {
+                    this.indicatorPositionMap.set(pid, p.add(new THREE.Vector3(0, 0, PanoramaGroup.IndicatorOffsetZ)));
+                }
+            });
+            const pidPositionMap = yield this.getPIDPositionMap(this.inSightIndicators);
+            this.presentPanoramaIndicators(pidPositionMap);
+        });
+    }
+    /**
+     * 显示指定全景点及其相邻全景点上的标签
+     * @param pid “中心”全景点ID，一般指摄像机当前所在的全景点PID
+     */
+    presentPanoramaIndicatorsAround(pid, view) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pids = this.panoramaIDsAround(pid, view);
+            if (pids) {
+                const pidPositionMap = yield this.getPIDPositionMap(pids);
+                this.presentPanoramaIndicators(pidPositionMap);
+            }
+        });
+    }
+    getIndicatorVisibility(pid) {
+        const visibility = this.indicatorVisibilityMap.get(pid);
+        if (undefined === visibility)
+            return true;
+        return visibility;
+    }
+    /**
+     * 设置指定全景点位的显示/隐藏状态
+     * @param visibility 显示/隐藏状态
+     * @param pid 可选，可以是全景图点位PID数组，也可以是单个PID,
+     * 若不设置则应用到本PanoramaGroup的所有全景点位上
+     */
+    setIndicatorVisibility(visibility, pid) {
+        let pidArray;
+        if (pid === undefined) {
+            pidArray = [];
+            this.indicatorMap.forEach((value, key) => {
+                pidArray.push(key);
+            });
+        }
+        else if (Array.isArray(pid)) {
+            pidArray = pid;
+        }
+        else {
+            pidArray = [pid];
+        }
+        pidArray.forEach((value) => {
+            this.indicatorVisibilityMap.set(value, visibility);
+            const indicator = this.indicatorMap.get(value);
+            if (indicator) {
+                this.group.remove(indicator);
+                this.indicatorMap.delete(value);
+            }
+        });
+        this.needUpdate = true;
+    }
+    setIndicatorHidden(hidden, pid) {
+        let pidArray;
+        if (pid === undefined) {
+            pidArray = [];
+            this.indicatorMap.forEach((value, key) => {
+                pidArray.push(key);
+            });
+        }
+        else if (Array.isArray(pid)) {
+            pidArray = pid;
+        }
+        else {
+            pidArray = [pid];
+        }
+        pidArray.forEach((value) => {
+            this.indicatorHiddenMap.set(value, hidden);
+            const indicator = this.indicatorMap.get(value);
+            if (indicator) {
+                this.group.remove(indicator);
+                this.indicatorMap.delete(value);
+            }
+        });
+        this.needUpdate = true;
+    }
+    /**
+     * 与全景点标志作相交测试
+     * 若有任一个全景点标志与射线相交则返回最近一个的相应PID
+     * 若没有则返回-1
+     * @param rayOrigin 射线起点
+     * @param rayDirection 射线方向
+     */
+    intersectIndicators(rayOrigin, rayDirection) {
+        let results = [];
+        const v = rayDirection.normalize();
+        const radius = Math.min(this.indicatorHeight, this.indicatorWidth) / 2;
+        this.indicatorMap.forEach((indicator, pid) => {
+            const p = indicator.position;
+            if (Number.isNaN(p.x))
+                return;
+            const u = p.clone().sub(rayOrigin);
+            const uDotV = u.dot(v);
+            if (uDotV > 0) {
+                const uOnV = v.clone().multiplyScalar(uDotV);
+                const distance = u.sub(uOnV).length();
+                if (distance <= radius) {
+                    results.push({
+                        pid,
+                        distance,
+                    });
+                }
+            }
+        });
+        if (results.length > 0) {
+            results = results.sort((a, b) => {
+                if (a.distance < b.distance)
+                    return -1;
+                if (a.distance > b.distance)
+                    return 1;
+                return 0;
+            });
+            return results[0].pid;
+        }
+        return -1;
+    }
+    intersectIndicatorsOnScreen(screenPosition, radius, { screenWidth, screenHeight }, camera) {
+        const indicatorsEntries = Array.from(this.indicatorMap);
+        const indicators = indicatorsEntries.map(([, mesh]) => mesh);
+        const intersection = BasicTools.getMouseIntersectionOnScreen(indicators, screenPosition, { screenWidth, screenHeight }, radius, camera, indicators, this.maxWorldDistance);
+        if (intersection) {
+            const target = indicatorsEntries.find(([, mesh]) => mesh === intersection);
+            if (target)
+                return target[0];
+        }
+        return -1;
+    }
+    /**
+     * 添加全景点
+     * @param {Panorama} pano 全景图对象
+     */
+    putPanorama(pano) {
+        const oldNode = this.panoramaMap.get(pano.pid);
+        if (oldNode) {
+            // console.info('#PanoCtrl# 4 Will remove pano:', oldNode.position);
+            this.group.remove(oldNode);
+            oldNode.dispose();
+        }
+        this.panoramaMap.set(pano.pid, pano);
+        // pano.visible = false;
+        this.group.add(pano);
+        this.needUpdate = true;
+    }
+    /**
+     * 指定预构建全景对象的顺序策略
+     * @param preInitStrategy 多义参数，表示具体的创建顺序
+     * 当为'all'时，直接按构造函数中panoramaDataList的顺序创建全部全景对象
+     * 当为一个整数值时，表示一个全景PID，将按全景点邻接关系以广度优先搜索的顺序创建全景对象
+     * 当为一个整数数组时，以数组指定的PID顺序依次创建
+     */
+    initializePanoramasIfNecessary(preInitStrategy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let pids = [];
+            if (Array.isArray(preInitStrategy)) {
+                pids = preInitStrategy;
+            }
+            else if (preInitStrategy === 'all') {
+                pids = Array.from(this.panoramaDatas.keys());
+            }
+            else {
+                const pid0 = preInitStrategy;
+                pids.push(pid0);
+                const visited = new Set();
+                visited.add(pid0);
+                const bfsQueue = [pid0];
+                while (bfsQueue.length > 0) {
+                    const pid = bfsQueue.splice(0, 1)[0];
+                    const pano = this.panoramaDatas.get(pid);
+                    if (pano) {
+                        pano.neighbourPanoramaIDs.forEach((neighbourPID) => {
+                            if (!visited.has(neighbourPID)) {
+                                visited.add(neighbourPID);
+                                bfsQueue.push(neighbourPID);
+                                pids.push(neighbourPID);
+                            }
+                        });
+                    }
+                }
+            }
+            const promises = pids.map((pid) => this.getPanoramaByPID(pid));
+            return Promise.all(promises);
+        });
+    }
+    /**
+     * 获得指定ID的全景点对象
+     * @param pid 全景点ID
+     */
+    getPanoramaByPID(pid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ret = this.panoramaMap.get(pid);
+            if (ret) {
+                return ret;
+            }
+            const creatingTask = this.panoramaCreatingTasks.get(pid);
+            if (creatingTask) {
+                return creatingTask;
+            }
+            const item = this.panoramaDatas.get(pid);
+            if (!item) {
+                return undefined;
+            }
+            const task = new Promise((resolve) => {
+                const panorama = new Panorama(item.pid, item.seqID, item.textureURLs, [2, 2], item.neighbourPanoramaIDs, item.highTextureURLs, item.useLowTextureURLsOnly, item.tiledTextureURLRoot, item.position, item.quaternion, !!item.legacyMode);
+                panorama.scale.set(this.globalScale, this.globalScale, this.globalScale);
+                this.putPanorama(panorama);
+                this.panoramaCreatingTasks.delete(item.pid);
+                // console.info(`#Async# Tasks#${item.pid} done`);
+                resolve(panorama);
+            });
+            this.panoramaCreatingTasks.set(item.pid, task);
+            return task;
+        });
+    }
+    /**
+     * 立刻获得指定ID的全景点对象
+     * @param pid 全景点ID
+     */
+    getPanoramaByPIDInstant(pid) {
+        const ret = this.panoramaMap.get(pid);
+        return ret || null;
+    }
+    /**
+     * @ignore
+     * @param rayDirection
+     */
+    getNeghbourPanoClosestToRay(rayDirection) {
+        if (this.currentPanoramaID === -1)
+            return -1;
+        const pano = this.panoramaMap.get(this.currentPanoramaID);
+        if (!pano)
+            return -1;
+        if (!pano.neighborPanoramaIDs || pano.neighborPanoramaIDs.length === 0)
+            return -1;
+        const AngleDegreeThreshold = 12.0;
+        const direction = rayDirection.clone().normalize();
+        let maxCos = -1.0;
+        let ret = -1;
+        pano.neighborPanoramaIDs.forEach((pid) => {
+            const neighbour = this.panoramaMap.get(pid);
+            if (!neighbour)
+                return;
+            const cosin = neighbour.position.clone().sub(pano.position).normalize().dot(direction);
+            if (cosin > maxCos) {
+                maxCos = cosin;
+                ret = pid;
+            }
+        });
+        if (maxCos >= Math.cos(Math.PI * AngleDegreeThreshold / 180.0)) {
+            return ret;
+        }
+        return -1;
+    }
+    updateIndicatorGeometry() {
+        const { THREE } = Externals.getInstance();
+        let indicatorGeometry;
+        if (this.indicatorImageURL) {
+            indicatorGeometry = new THREE.PlaneBufferGeometry(this.indicatorWidth, this.indicatorHeight);
+        }
+        else {
+            indicatorGeometry = new THREE.CircleGeometry(this.indicatorWidth / 2, 32);
+        }
+        const indicatorSet = new Set();
+        Array.from(this.indicatorMap).forEach(([, mesh]) => {
+            indicatorSet.add(mesh.geometry);
+            mesh.geometry = indicatorGeometry;
+        });
+        Array.from(indicatorSet).forEach((geometry) => {
+            geometry.dispose();
+        });
+        this.indicatorMeshPrototype.geometry = indicatorGeometry;
+        const indicator = new THREE.Mesh(indicatorGeometry, this.indicatorMeshPrototype.material);
+        this.setIndicatorMeshPrototype(indicator);
+    }
+    /**
+     * 改变地面全景点标识的尺寸
+     * @param width 宽度
+     * @param height 高度
+     */
+    setIndicatorSize(width, height) {
+        this.indicatorWidth = width;
+        this.indicatorHeight = height;
+        this.updateIndicatorGeometry();
+    }
+    setIndicatorImageURL(url) {
+        const { THREE } = Externals.getInstance();
+        new THREE.TextureLoader().load(url, (texture) => {
+            const vertexShader = [
+                'varying vec2 vUv;',
+                'void main(){',
+                '   vUv = uv;',
+                '   gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);',
+                '}',
+            ].join('\n');
+            const fragmentShader = [
+                'uniform sampler2D map;',
+                'uniform float opacity;',
+                'uniform vec4 blendColor;',
+                'varying vec2 vUv;',
+                'void main(){',
+                '   vec4 texColor = texture2D(map, vUv);',
+                '   gl_FragColor = vec4((texColor * (1.0 - blendColor.a) + blendColor * blendColor.a).rgb, texColor.a * opacity);',
+                '}',
+            ].join('\n');
+            let currentMaterial = this.getIndicatorMaterial(IndicatorDisplayMode.Editing, true);
+            let newMaterial = new THREE.ShaderMaterial({
+                // 设置透明属性，这样透过全景图就能看到标签
+                transparent: true,
+                vertexShader,
+                fragmentShader,
+                uniforms: this.indicatorShaderUniforms,
+                side: THREE.DoubleSide,
+                depthTest: false,
+                depthWrite: false,
+                name: 'indicatorMaterial',
+            });
+            this.setIndicatorMaterial(newMaterial, IndicatorDisplayMode.Editing, true);
+            currentMaterial.dispose();
+            currentMaterial = this.getIndicatorMaterial(IndicatorDisplayMode.Show, true);
+            this.setIndicatorMaterial(newMaterial, IndicatorDisplayMode.Show, true);
+            currentMaterial.dispose();
+            newMaterial = new THREE.ShaderMaterial({
+                transparent: true,
+                vertexShader,
+                fragmentShader,
+                uniforms: this.invisibleIndicatorShaderUniforms,
+                side: THREE.DoubleSide,
+                depthTest: false,
+                depthWrite: false,
+                name: 'invisibleIndicatorMaterial',
+            });
+            this.indicatorShaderUniforms.map.value = texture;
+            this.invisibleIndicatorShaderUniforms.map.value = texture;
+            this.setIndicatorMaterial(newMaterial, IndicatorDisplayMode.Editing, false);
+            if (!this.indicatorImageURL) {
+                this.setIndicatorMeshPrototype(new THREE.Mesh(new THREE.PlaneBufferGeometry(this.indicatorWidth, this.indicatorHeight), newMaterial));
+            }
+            this.indicatorImageURL = url;
+            this.needUpdate = true;
+            this.updateIndicatorGeometry();
+        });
+    }
+    /**
+     * 查询当前设置的地面全景点标识尺寸
+     * @returns number数组，依次是width, height
+     */
+    getIndicatorSize() {
+        return [this.indicatorWidth, this.indicatorHeight];
+    }
+    setIndicatorMeshPrototype(mesh) {
+        this.indicatorMeshPrototype = mesh;
+        this.panoramaMap.forEach((pano, pid) => {
+            const indicator = this.indicatorMap.get(pid);
+            if (indicator) {
+                this.group.remove(indicator);
+                this.indicatorMap.delete(pid);
+            }
+        });
+        mesh.renderOrder = 300;
+        this.needUpdate = true;
+    }
+    /**
+     * 设定全景点位标签的原型对象，每个全景点位的标签会以该原型对象为母本clone出来
+     * @param prototypeObject 点位标签原型Object3D对象
+     * @param mode 点位的展示模式
+     * @param visibility 点位的显隐状态设置
+     */
+    setIndicatorMaterial(material, mode, visibility) {
+        let map1 = this.indicatorMaterials.get(mode);
+        if (!map1) {
+            map1 = new Map();
+            this.indicatorMaterials.set(mode, map1);
+        }
+        map1.set(visibility, material);
+        this.needUpdate = true;
+    }
+    getIndicatorMaterial(mode, visibility) {
+        let map1 = this.indicatorMaterials.get(mode);
+        if (!map1) {
+            map1 = new Map();
+            this.indicatorMaterials.set(mode, map1);
+        }
+        return map1.get(visibility);
+    }
+    /**
+     * 配置全景图组在不同view中的显示状态
+     * @param configuration 全景图组配置，见[[PanoramaGroupViewConfiguration]]
+     */
+    addGroupViewConfiguration(configuration) {
+        const conf0 = this.viewConfigurations.get(configuration.targetView);
+        if (conf0) {
+            if (configuration.showBoundBox === undefined && conf0.showBoundBox !== undefined) {
+                configuration.showBoundBox = conf0.showBoundBox;
+            }
+            if (configuration.visibleRadius === undefined && conf0.visibleRadius !== undefined) {
+                configuration.visibleRadius = conf0.visibleRadius;
+            }
+            if (configuration.indicatorDisplayMode === undefined && conf0.indicatorDisplayMode !== undefined) {
+                configuration.indicatorDisplayMode = conf0.indicatorDisplayMode;
+            }
+        }
+        this.viewConfigurations.set(configuration.targetView, configuration);
+        this.needUpdate = true;
+        // /!!!For Debug #Async#
+        // this.setBoundBoxVisible(configuration.showBoundBox!);
+    }
+    /**
+     * 配置组中所有全景图在不同view中的显示状态
+     * @param configuration 全景图显示配置
+     */
+    addViewConfiguration(configuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const panos = yield this.allPanoramas();
+            panos.forEach((p) => { p.addViewConfiguration(configuration); });
+        });
+    }
+    setMaxWorldDistance(distance) {
+        this.maxWorldDistance = distance;
+    }
+}
+PanoramaGroup.DefaultVisibleRadius = 10;
+PanoramaGroup.IndicatorRadius = 0.1;
+PanoramaGroup.IndicatorOffsetZ = 0.1;
+export { PanoramaGroup, IndicatorDisplayMode, };
+//# sourceMappingURL=panorama-group.js.map