Sinopec-Anxin/src/app/babylon/view/building-window/building-window.ts

import { AbstractMesh, Material, PBRMaterial, Texture, Animatable } from "@babylonjs/core";
import { PlanComponent } from "src/app/pages/plan/plan.component";
import { ConfigManager } from "../../controller/config-manager";
import { DataManager } from "../../controller/data-manager";
import { EventManager } from "../../controller/event-manager/event-manager";
import { Event_LoadingChange } from "../../controller/event-manager/events/event-loading-change";
import { InfoManager } from "../../controller/info-manager";
import { ModeManager, ModeType } from "../../controller/mode-manager";
import { SceneManager } from "../../controller/scene-manager";
import { ServeManager } from "../../controller/serve-manager";
import { BuildingStatus } from "../../controller/status/building-status";
import { StatusManager } from "../../controller/status/status-manager";
import { ArcRotateCameraData } from "../../model/data/camera-data";
import { BuildingData, BuildingData_ChemicalPlant, BuildingData_Environment, BuildingData_Normal, BuildingType } from "../../model/data/institution/building/building-data";
import { JYZInfoMoudleType, JYZShowData } from "../../model/data/institution/jyz-show-data";
import { ModelType } from "../../model/data/model-data/model-data";
import { FacilityPosType, FacilityType, ModelData_facility } from "../../model/data/model-data/model-data-facility";
import { ModelEditData } from "../../model/data/model-data/model-edit-data";
import { BuildingInfo } from "../../model/info/building/building-info";
import { BuildingInfo_ChemicalPlant } from "../../model/info/building/building-info-chemicalplant";
import { BuildingInfo_Environment } from "../../model/info/building/building-info-environment";
import { BuildingInfo_Normal } from "../../model/info/building/building-info-normal";
import { ModelInfo_building } from "../../model/info/model/model-info-building";
import { FacilityInfoByType, ModelInfo_facility } from "../../model/info/model/model-info-facility";
import { BabylonTool } from "../../tool/babylon-tool";
import { GizmoTool } from "../../tool/gizmo-tool";
import { TsTool } from "../../tool/ts-tool";
import { FacilityInfoInSceneWindow } from "../facilityinfoinscene-window/facilityinfoinscene-window";
import { MarkWindow } from "../mark-window/mark-window";
import { UIBase } from "../window-base/ui-base";
import { BuildingUIItem } from "./building-ui-item";

//建筑界面
export class BuildingWindow extends UIBase {


    /**
     * uv动画材质的特殊命名
     */
    readonly c_MAT_UV = "MAT_UV";

    static instance: BuildingWindow;

    buldingStatus: BuildingStatus;

    buildingUIItems: BuildingUIItem[] = [];//所有建筑UI

    currentBuidngItem: BuildingUIItem; //当前正在操作的建筑

    three: PlanComponent;//前端组件


    cameraAnim: Animatable;//相机动画


    //#region 与前端对接部分

    /**
     * UI上添加一个建筑item
     * @param buildingData 建筑data数据
     * @param index 序号
     * @param onSuccess 成功的回调
     */
    createOneBuildingItem(buildingData: BuildingData_Normal | BuildingData_Environment | BuildingData_ChemicalPlant, index: number, onSuccess?: (buildingUIItem: BuildingUIItem, index: number) => void) {
        let buildingInfo: BuildingInfo_Normal | BuildingInfo_Environment | BuildingInfo_ChemicalPlant;
        switch (buildingData.buildingType) {
            case BuildingType.Normal:
                buildingInfo = new BuildingInfo_Normal(buildingData as BuildingData_Normal, null);
                break;
            case BuildingType.Environment:
                buildingInfo = new BuildingInfo_Environment(buildingData, null);
                break;
            case BuildingType.ChemicalPlant:
                buildingInfo = new BuildingInfo_ChemicalPlant(buildingData, null);
                break;
        }
        // console.log("初始化建筑info");
        // console.log(buildingInfo.buildingData);
        let uiItem = this.addBuildingItem(buildingInfo);

        if (buildingData.outdoorData != null && buildingData.outdoorData.modelData != null && buildingData.outdoorData.modelData.resName != null) {
            this.updateBuildingModel(buildingInfo, true, () => {
                // buildingInfo.initFacility();
                BuildingStatus.enterSuccessObservable.notifyObservers(uiItem);
                if (onSuccess) {
                    onSuccess(uiItem, index);
                }
            })
        }
    }

    //删除建筑
    deleteBuilding(buidlingUIItem: BuildingUIItem) {
        // console.log("删除建筑" + buidlingUIItem.buildingInfo.buildingData.normalData.key);
        DataManager.deleteOneBuildingData(buidlingUIItem.buildingInfo.buildingData.buildingType, buidlingUIItem.buildingInfo.buildingData.normalData.key);
        for (let i = 0; i < this.buildingUIItems.length; i++) {
            if (this.buildingUIItems[i] == buidlingUIItem) {
                buidlingUIItem.dispose();
                TsTool.arrayRemove(this.buildingUIItems, buidlingUIItem);
                break;
            }
        }
    }

    /**
     * 改变模型
     * @param file 
     */
    changeModel(file: File[], buildingData: BuildingData) {
        if (file == null || file.length == 0) {
            return;
        }
        console.log("修改模型");

        buildingData.outdoorData.modelData.key = buildingData.normalData.key;
        buildingData.outdoorData.modelData.name = buildingData.normalData.key;

        let normalData = buildingData.normalData;
        let resPath_out = DataManager.getResPath_building(
            DataManager.institutionData.normalData.key.toLowerCase(),
            normalData.key.toLocaleLowerCase(),
            "outDoor"
        );
        console.log("新资源路径" + resPath_out);
        let buildingWindow = this;

        let manifestFile: File = null;
        if (buildingData.outdoorData.modelData.resName != null) {

            manifestFile = DataManager.createManifestFile(buildingData.outdoorData.modelData);
            file.push(manifestFile); //临时关闭缓存文件
        }

        PlanComponent.instance.showLoading(true);
        ServeManager.instance.uploadFile(0, file, resPath_out, (name: string, path: string, currentfile) => {
            if (TsTool.stringContain(name, ".gltf")) {
                if (TsTool.stringContain(name, ".gltf.manifest")) {
                    //缓存文件,提取版本号
                    DataManager.readFile_manifest(currentfile, (version: number) => {
                        buildingData.outdoorData.modelData.version = version;
                        // console.log("设置version" + version);
                    });
                }
                else {
                    buildingData.outdoorData.modelData.resName = name;
                    buildingData.outdoorData.modelData.resPath = path;
                    if (manifestFile == null) {
                        manifestFile = DataManager.createManifestFile(buildingData.outdoorData.modelData);
                        file.push(manifestFile);
                    }//临时关闭缓存文件
                }

            }
        }
            , () => {
                PlanComponent.instance.showLoading(false);
                let buildingInfo = buildingWindow.getBuildingInfo(buildingData.normalData.key);
                buildingWindow.updateBuildingModel(buildingInfo, true);
                // buildingWindow.three = ThreeDimensionalHomeComponent.instance;
                // buildingWindow.three.maskLayerService.sendMessage(false) //关闭遮罩层
            });
    }

    /**
     * 获取目标建筑中，室内的某类设备数目
     */
    getNormalBuildingIndoorFacilitys(buildingUIItem: BuildingUIItem, facilityType: FacilityType) {
        let result = 0;

        if (buildingUIItem.buildingInfo.buildingData.buildingType != BuildingType.Normal) {
            //不是普通建筑，没有室内
        }
        else {
            let indoorData: ModelEditData[] = (buildingUIItem.buildingInfo.buildingData as BuildingData_Normal).indoorsData;
            if (indoorData != null) {
                for (let i = 0; i < indoorData.length; i++) {
                    let facilitiesByType = indoorData[i].getFacilitiesByType(facilityType);
                    if (facilitiesByType != null) {
                        result += facilitiesByType.length;
                    }

                }
            }

        }
        return result;
    }

    /**
     * 进入第一个具有本设备的室内楼层
     */
    changeToFirstIndoorByFacility(buildingUIItem: BuildingUIItem, facilityType: FacilityType) {

        let result = false;//是否成功找到并进入某室内层
        let num = 0;

        if (buildingUIItem.buildingInfo.buildingData.buildingType != BuildingType.Normal) {
            //不是普通建筑，没有室内

        }
        else {
            let indoorData: ModelEditData[] = (buildingUIItem.buildingInfo.buildingData as BuildingData_Normal).indoorsData;
            for (let i = 0; i < indoorData.length; i++) {
                let facilitiesByType = indoorData[i].getFacilitiesByType(facilityType);
                if (facilitiesByType != null) {
                    num += facilitiesByType.length;
                }


                if (num > 0) {
                    result = true;
                    buildingUIItem.enterIndoor(indoorData[i].modelData.key, true);
                    break;
                }

            }
        }

        return result;
    }


    /**
     * 加油站信息各个模块的显示、隐藏
     * @param type 
     * @param show true表示显示
     */
    changeJYZInfoModel(type: JYZInfoMoudleType, show: boolean) {
        if (this.currentJYZInfoMoudleType == type) {
            if (show) {
                return; //与上次显示的模块相同
            }
            else {
                this.showJYZModules(type, show); //单纯隐藏
            }
        }
        else {
            if (this.currentJYZInfoMoudleType != null) {
                this.showJYZModules(this.currentJYZInfoMoudleType, false); //先恢复之前隐藏的内容

            }
            this.showJYZModules(type, show);//展示本次要展示的内容
        }

        if (show) {
            if (type == JYZInfoMoudleType.YJCZ) {
                //进入应急处置

            }
            else {//恢复查看状态

            }
            this.recoverMoudleShow(type);
        }
        else {
            if (type == JYZInfoMoudleType.YJCZ) {
                //退出应急处置

            }
            this.recoverMoudleShow(null);
        }


    }

    /**
     * 恢复展示模块状态（视角、罩棚）
     * @param type 
     */
    recoverMoudleShow(type: JYZInfoMoudleType) {
        let showData = DataManager.institutionData.getMoudleShowData(type);
        if (showData != null) {
            //let camera = SceneManager.Instance.defaultCamera;
            //showData.cameraData.setDataToCamera(camera);
            let cameraData = showData.cameraData;
            // BabylonTool.AnimMoveCameraTargetAB(camera, 60, cameraData.target, cameraData.radius, cameraData.alpha, cameraData.beta);
            // this.showZP(showData.showZP);
            // PlanComponent.instance.isOpenAwning = showData.showZP;
            this.revoverCamera(cameraData, showData.showZP);
        }

    }

    /**
     * 动画恢复相机状态
     * @param cameraData 
     * @param showZP 
     */
    revoverCamera(cameraData: ArcRotateCameraData, showZP: boolean, onAnimationEnd?: () => void) {
        this.showZP(showZP);
        PlanComponent.instance.isOpenAwning = showZP;
        let camera = SceneManager.Instance.defaultCamera;
        if (cameraData != null) {

            this.cameraAnim = BabylonTool.AnimMoveCameraTargetAB(camera, 60, cameraData.target, cameraData.radius, cameraData.alpha, cameraData.beta, onAnimationEnd);
            if (Event_LoadingChange.isLoading) { //加载中，暂停
                this.cameraAnim.pause();
            }
        }
    }



    //#endregion


    //#region 生命周期
    onInit() {
        super.onInit();
        GizmoTool.changeGizmoOpen(ModeManager.s_isMakeMode); //内部模式才默认打开gizmo

        this.buldingStatus = StatusManager.getStatus<BuildingStatus>(BuildingStatus);

        this.initBuildings();//创建每一个建筑buildingItem

        BuildingWindow.instance = this;
        this.three = PlanComponent.instance;
        this.three.buildingUIItems = this.buildingUIItems
        this.buildingUIItems.length ? this.three.beforeOneBuildingID = this.three.buildingUIItems[0].getBuildingID() : null
        let instance = this;
        SceneManager.Instance.scene.onBeforeRenderObservable.add(() => {
            instance.onUpdate();
        })
        EventManager.addListener<Event_LoadingChange>(Event_LoadingChange, (eventInfo) => {
            instance.onChangeLoading(eventInfo);
        });

    }

    onShow() {
        this.three = PlanComponent.instance;
        this.three.buildingUIItems = this.buildingUIItems
        this.showModel(true);

        super.onShow();
    }
    onHide() {
        this.showModel(false);
        super.onHide();
    }

    onUpdate() {
        this.updateUVAnim();
        this.updateLimitCameraY();
    }



    /**
     * loading状态改变时
     * @param eventInfo 
     */
    onChangeLoading(eventInfo: Event_LoadingChange) {
        if (eventInfo.showLoading) {
            if (this.cameraAnim != null) {
                this.cameraAnim.pause();
            }

        }
        else {
            if (this.cameraAnim != null) {
                this.cameraAnim.restart();
            }

        }
    }

    /**
     * 释放建筑，回到未创建建筑前
     */
    dispose() {
        for (let i = 0; i < this.buildingUIItems.length; i++) {
            this.buildingUIItems[i].dispose();
        }
        BuildingWindow.instance = null;
    }

    //#endregion


    //#region 外部公有




    /**
     * 清空建筑上的设备实例
     * @param buildingInfo 
     */
    clearFacilityInfos(buildingInfo: BuildingInfo) {

        if (buildingInfo.ModelInfo != null) {
            for (let i = 0; i < buildingInfo.ModelInfo.facilityInfos.length; i++) {
                buildingInfo.ModelInfo.facilityInfos[i].dispose();
            }
            buildingInfo.ModelInfo.facilityInfos = [];
        }
    }

    /**
     * 显示或隐藏建筑上的设备icon
     * @param buildingInfo 
     * @param show 
     */
    showFacilityInfosIcon(buildingInfo: BuildingInfo, show: boolean) {
        if (buildingInfo.ModelInfo != null) {
            buildingInfo.ModelInfo.showFacilityUI(show);
        }
    }

    /**
     * 根据buildingInfo找到item，然后模拟选中
     * @param buildingInfo 建筑信息
     */
    changeCurrentBuildingInfo(modelInfo: ModelInfo_building) {

        let item: BuildingUIItem = null;
        for (let i = 0; i < this.buildingUIItems.length; i++) {
            if (this.buildingUIItems[i].buildingInfo.ModelInfo == modelInfo) {
                item = this.buildingUIItems[i];
                break;
            }
        }

        // console.log("选中建筑", modelInfo);
        this.showJYZModules(JYZInfoMoudleType.YJCZ, false);
        this.showJYZModules(JYZInfoMoudleType.JBXX, false);
        this.showJYZModules(JYZInfoMoudleType.AQSS, false);
        this.showJYZModules(JYZInfoMoudleType.YQHSGX, false);
        this.showJYZModules(JYZInfoMoudleType.SYG, false);
        this.recoverMoudleShow(null);

        //this.onChangeCurrentBuildingItem(item);

        //this.three.selectLeftBuilding(item);

    }

    /**
     * 改变当前操作建筑目标
     * @param buidlingUIItem 新选中的目标
     */
    onChangeCurrentBuildingItem(buidlingUIItem: BuildingUIItem, animMove = true) {
        if (this.currentBuidngItem != null && this.currentBuidngItem != buidlingUIItem) {
            this.currentBuidngItem.onSelect(false);
        }

        this.currentBuidngItem = buidlingUIItem;
        this.currentBuidngItem.onSelect(true, animMove);

        this.buldingStatus.changeCurrentBuilding(buidlingUIItem.buildingInfo);
    }

    /**
     * 查询buildingKey
     * @param key 
     */
    public getBuildingInfo(key: string): BuildingInfo {
        for (let i = 0; i < this.buildingUIItems.length; i++) {
            if (this.buildingUIItems[i].buildingInfo.buildingData.normalData.key == key) {
                return this.buildingUIItems[i].buildingInfo;
            }
        }
        return null;
    }

    /**
     * 查询UIItem
     * @param key 
     */
    public getBuildingUIItem(key: string) {
        for (let i = 0; i < this.buildingUIItems.length; i++) {
            if (this.buildingUIItems[i].buildingInfo.buildingData.normalData.key == key) {
                return this.buildingUIItems[i];
            }
        }
        return null;
    }

    /**
     * 更新建筑模型
     * @param buildingInfo 
     * @param updateFacility 
     * @param onSuccess 
     */
    public updateBuildingModel(buildingInfo: BuildingInfo, updateFacility: boolean, onSuccess?: () => void) {
        if (buildingInfo == null) {
            return;
        }
        if (buildingInfo.ModelInfo != null) {
            buildingInfo.ModelInfo.dispose();
        }


        SceneManager.createModel(ModelType.Building, buildingInfo.buildingData.outdoorData.modelData, true, true, "Building", (newMesh, box, modelInfo) => {
            buildingInfo.ModelInfo = modelInfo as ModelInfo_building;
            buildingInfo.ModelInfo.updateName(buildingInfo.buildingData.normalData.name);
            if (updateFacility) {

                InfoManager.createFacilityInfos(buildingInfo.buildingData.outdoorData, buildingInfo);



            }
            if (buildingInfo instanceof BuildingInfo_Environment) {
                buildingInfo.updateFuGaiCeng();
            }

            if (onSuccess) {
                onSuccess();
            }
        });
    }


    //#endregion


    //#region 内部私有


    //填充建筑列表
    private initBuildings() {


        //因为babylon内对indexDB的封装使用有问题，在用户第一次使用时触发了创建数据库操作，导致我们同时调用多个加载方法时报错
        //解决策略是：如果发现有多个模型要加载，则先加载第一个模型，保证indexDB数据库正常建立， 第一个加载完成后，在加载剩余模型

        BuildingStatus.startEnterObservable.notifyObservers(null);

        let instance = this;
        let firstItem; //第一个要加载的模型
        let firstType: BuildingType;

        let allModelNumber = 0;


        let buildingDatas_Environment = DataManager.getBuildingDataListByType(BuildingType.Environment);
        if (buildingDatas_Environment != null) {
            allModelNumber += buildingDatas_Environment.length;
            if (buildingDatas_Environment.length > 0) {
                firstItem = buildingDatas_Environment[0];
                firstType = BuildingType.Environment;
            }
        }

        let buildingDatas_mormal = DataManager.getBuildingDataListByType(BuildingType.Normal);
        if (buildingDatas_mormal != null) {
            allModelNumber += buildingDatas_mormal.length;
            if (buildingDatas_mormal.length > 0) {
                firstItem = buildingDatas_mormal[0];
                firstType = BuildingType.Normal;
            }
        }

        //暂时关闭 1+ n的加载模式
        // if (allModelNumber > 1) {

        //     if (firstType == BuildingType.Environment) {
        //         instance.createOneBuildingItem(firstItem, 0, (uiItem, index) => {
        //             instance.onChangeCurrentBuildingItem(uiItem, false);
        //             // uiItem.lookAt(false);
        //             if (buildingDatas_Environment.length > 1) {
        //                 instance.addBuildings(BuildingType.Environment, 1);
        //             }

        //             instance.addBuildings(BuildingType.Normal, 0);

        //         });

        //     }
        //     else {
        //         instance.createOneBuildingItem(firstItem, 0, (uiItem, index) => {
        //             instance.onChangeCurrentBuildingItem(uiItem, false);
        //             // uiItem.lookAt(false);
        //             if (buildingDatas_mormal.length > 1) {
        //                 instance.addBuildings(BuildingType.Normal, 1);
        //             }
        //             instance.addBuildings(BuildingType.Environment, 0);


        //         });
        //     }

        // }
        // else {

        //     instance.addBuildings(BuildingType.Normal, 0, (uiItem, index) => {
        //         if (index == 0 && uiItem.buildingInfo.isEnable) {
        //             instance.onChangeCurrentBuildingItem(uiItem, false);
        //             //uiItem.lookAt(false);
        //             // console.log("默认选中" + uiItem.buildingInfo.buildingData.normalData.key);
        //         }
        //     });

        //     instance.addBuildings(BuildingType.Environment, 0);
        // }

        instance.addBuildings(BuildingType.Normal, 0, (uiItem, index) => {
            if (index == 0 && uiItem.buildingInfo.isEnable) {
                instance.onChangeCurrentBuildingItem(uiItem, false);
                //uiItem.lookAt(false);
                // console.log("默认选中" + uiItem.buildingInfo.buildingData.normalData.key);
            }
        });

        instance.addBuildings(BuildingType.Environment, 0);
    }



    //初始化建筑显示(根据类别)
    private addBuildings(buildingType: BuildingType, startIndex: number, onSuccess?: (buildingUIItem: BuildingUIItem, index: number) => void) {
        let index = startIndex;

        let buildingDatas = DataManager.getBuildingDataListByType(buildingType);
        // console.log(buildingDatas);
        while (buildingDatas != null && index < buildingDatas.length) {
            let l_index = index;
            let buildingData = buildingDatas[l_index];
            this.createOneBuildingItem(buildingData, l_index, onSuccess);

            index++;
        }

    }



    //添加一个item到界面中
    private addBuildingItem(buildingInfo: BuildingInfo): BuildingUIItem {
        let buildingItem = new BuildingUIItem(buildingInfo, this);
        this.buildingUIItems.push(buildingItem);

        return buildingItem;
    }



    /**
     * 隐藏或展示模型
     * @param show true-表示展示
     */
    private showModel(show: boolean) {
        for (let i = 0; i < this.buildingUIItems.length; i++) {

            //周围环境,不隐藏（也就不用再显示）
            if (this.buildingUIItems[i].buildingInfo.ModelInfo.buildingType == BuildingType.Environment) {
                (this.buildingUIItems[i].buildingInfo as BuildingInfo_Environment).updateFuGaiCeng();
                if (show) { //切换到室外时，根据选中状态恢复设备UI
                    if (this.currentBuidngItem == this.buildingUIItems[i]) {
                        this.buildingUIItems[i].buildingInfo.ModelInfo.showFacilityUI(show);
                    }
                    else {
                        this.buildingUIItems[i].buildingInfo.ModelInfo.showFacilityUI(false);
                    }
                    this.buildingUIItems[i].buildingInfo.ModelInfo.showFollowUI(true);//环境的名称UI 不显示
                }
                else { //切换到室内时，显示环境的设备UI 
                    this.buildingUIItems[i].buildingInfo.ModelInfo.showFacilityUI(false);//(感觉太乱，暂时取消)
                    this.buildingUIItems[i].buildingInfo.ModelInfo.showFollowUI(false);//环境的名称UI 不显示
                }
            }
            else { // 建筑，正常显隐
                this.buildingUIItems[i].setModelEnable(show);
            }
            // if (this.buildingUIItems[i].buildingInfo != null) {
            //     this.buildingUIItems[i].buildingInfo.setEnable(show);
            // }
        }
    }
    //#endregion

    //#region 寻找建筑内已有设备相关

    /**
     * 消防相关
     */
    readonly c_xiaoFang = "XF_";

    /**
     * 安全疏散
     */
    readonly c_shuSan = "AQSS_";

    /**
     * 加油站相关
     */
    readonly c_jiaYou = "JY_";

    /**
     * 遮挡
     */
    readonly c_zheDang = "ZD";

    /**
    * 清空找不到具体模型的设备信息
    */
    public clearHomeLessFacilityData() {
        if (this.currentBuidngItem != null) {

            let allFacilities = this.currentBuidngItem.buildingInfo.buildingData.outdoorData.facilities;
            let needClear: ModelData_facility[] = [];
            for (let i = 0; i < allFacilities.length; i++) {

                let facilityByType = allFacilities[i];
                for (let j = 0; j < facilityByType.facilities.length; j++) {
                    let info = FacilityInfoInSceneWindow.instance.getFacilityInfo(facilityByType.facilities[j]);
                    if (info == null
                        || TsTool.stringContain(info._modelBox.id, "(Box)")) {
                        needClear.push(facilityByType.facilities[j]);
                    }
                }

            }


            for (let k = 0; k < needClear.length; k++) {
                for (let i = 0; i < allFacilities.length; i++) {
                    let facilityByType = allFacilities[i];
                    TsTool.arrayRemove(facilityByType.facilities, needClear[k]);

                }
            }

        }
    }

    /**
    * 清空所有来自模型的设备
    */
    public clearAllFacilityFromMeshData() {
        if (this.currentBuidngItem != null) {

            this.currentBuidngItem.clearFacilityFromMesh();
        }
    }


    /**
     * 获取并创建建筑上的消防设备数据(内部模式制作时，调用一次)
     */
    public getModelAndCreateFacilityData() {

        this.clearHomeLessFacilityData();

        if (this.currentBuidngItem != null) {
            //获取所有transformNodes
            let allNode = this.currentBuidngItem.buildingInfo.ModelInfo.modelBox.getChildMeshes(false);

            for (let i = 0; i < allNode.length; i++) {
                let nodeName = allNode[i].name;

                if (TsTool.stringContain(nodeName, "primitive")) {
                    //复合材质被分解为多个子mesh，不看做特殊意义的对象
                }
                else if (TsTool.stringContain(nodeName, this.c_zheDang))//遮挡
                {
                    this.currentBuidngItem.createStopByMesh(allNode[i]);
                }
                else if (TsTool.stringContain(nodeName, this.c_xiaoFang)) //消防
                {
                    this.currentBuidngItem.createFacilityByMesh(allNode[i]);
                }
                else if (TsTool.stringContain(nodeName, this.c_shuSan)) {
                    this.currentBuidngItem.createAQSSFromMesh(allNode[i]);//安全疏散
                }
                else if (TsTool.stringContain(nodeName, this.c_jiaYou))//加油站
                {
                    this.currentBuidngItem.createOilingByMesh(allNode[i]);
                }

            }
        }


    }



    //#endregion


    //#region 加油站基本信息模块的显隐表现

    /**
     * 箭头UV动画速度
     */
    readonly c_uvAnimSpeed = 0.001;

    /**
     * 当前查看的加油站信息模块类型
     */
    currentJYZInfoMoudleType: JYZInfoMoudleType = null;

    /**
     * 当前模块需要显示的各类设备
     */
    facilitysByMoudle: Map<JYZInfoMoudleType, FacilityInfoByType[]> = new Map();

    /**
     * 当前模块需要隐藏的设备
     */
    zdByMoudle: Map<JYZInfoMoudleType, FacilityInfoByType[]> = new Map();

    /**
     * uv动画所需材质
     */
    mat_UV: Map<JYZInfoMoudleType, Material[]> = new Map();

    /**
     * 当前罩棚是否显示
     */
    currentZPShow: boolean = true;



    /**
     * 展示加油站信息模块
     * @param type 
     * @param show 
     */
    showJYZModules(type: JYZInfoMoudleType, show: boolean) {
        if (this.currentBuidngItem == null) {
            return;
        }

        if (show) {
            this.updateGizmoType(type);
        }

        if (type == JYZInfoMoudleType.YJCZ) {
            if (show) {
                // console.log("进入应急处置");
                MarkWindow.openWindow();
            }
            else {
                // console.log("退出应急处置");
                MarkWindow.closeWindow();
            }


        }

        this.initFacilityTypeByMoudleType(type, this.currentBuidngItem.buildingInfo);

        FacilityInfoInSceneWindow.instance.selectJYJFrom3D(null);

        //设备： 显示UI
        let facilityByType: FacilityInfoByType[] = [];
        if (this.facilitysByMoudle.has(type)) {
            facilityByType = this.facilitysByMoudle.get(type);
        }
        for (let i = 0; i < facilityByType.length; i++) {
            let infos = facilityByType[i].facilityInfo;
            if (infos != null) {
                for (let j = 0; j < infos.length; j++) {
                    infos[j].playShowAnim(show);
                    //安全疏散，特殊，要在不显示时隐藏本体
                    if (type == JYZInfoMoudleType.AQSS) {
                        infos[j].setEnable(show);
                    }
                }
            }
        }


        //阻挡类物体
        let zdByType: FacilityInfoByType[] = [];
        if (this.zdByMoudle.has(type)) {
            zdByType = this.zdByMoudle.get(type);
        }
        else {
        }
        for (let i = 0; i < zdByType.length; i++) {
            let infos = zdByType[i].facilityInfo;
            if (infos != null) {
                for (let j = 0; j < infos.length; j++) {
                    infos[j].setEnable(!show);
                }
            }
        }

        /**
         * 在输油管和油气回收模块， 要展示油罐和加油机的名字UI
         */
        let isShowNameUI_JYJ_YG = show && (type == JYZInfoMoudleType.SYG || type == JYZInfoMoudleType.YQHSGX);
        let showNameFacilitys: ModelInfo_facility[] = [];
        showNameFacilitys = showNameFacilitys.concat(this.currentBuidngItem.buildingInfo.ModelInfo.getFacilityInfoByType(FacilityType.JY_JYJ));
        showNameFacilitys = showNameFacilitys.concat(this.currentBuidngItem.buildingInfo.ModelInfo.getFacilityInfoByType(FacilityType.JY_YG));
        for (let i = 0; i < showNameFacilitys.length; i++) {
            showNameFacilitys[i].showNameUI(isShowNameUI_JYJ_YG);
        }
        //SceneManager.Instance.openInnerGlow(!isShowNameUI_JYJ_YG); //输油管和油气回收管太细，关闭内发光



        if (show) {
            this.currentJYZInfoMoudleType = type;
        }
        else {
            this.currentJYZInfoMoudleType = null;
            // SceneManager.Instance.highLightLayer.removeAllMeshes();

        }

    }

    /**
     * 根据各个模块，更新gizmo状态
     * @param type 
     */
    updateGizmoType(type: JYZInfoMoudleType) {
        let open = false;

        if (ModeManager.currentMode == ModeType.Edit) {
            switch (type) {
                case JYZInfoMoudleType.JBXX:
                case JYZInfoMoudleType.YJCZ: open = true; break;
            }
        }

        if (ModeManager.s_isMakeMode) {
            open = true;
        }

        GizmoTool.changeGizmoOpen(open);
    }

    /**
     * 根据功能模块，获取所需的设备类型
     * @param moudleType 功能模块
     */
    initFacilityTypeByMoudleType(moudleType: JYZInfoMoudleType, buildingInfo: BuildingInfo) {

        let moudleTypeKey = moudleType; //当前模块物体的特殊字段
        let zdKey = "ZD_" + moudleType; //阻挡类物体特殊字段

        //编辑模式下，基本信息下的设备会随时变化
        if (ModeManager.currentMode == ModeType.Edit) {
            let jbxxMoudle = JYZInfoMoudleType.JBXX;
            if (this.facilitysByMoudle.has(jbxxMoudle)) {
                this.facilitysByMoudle.get(jbxxMoudle).length = 0;
            }
            else {
                this.facilitysByMoudle.set(jbxxMoudle, []);
            }


            let allFacilityByType = buildingInfo.ModelInfo.facilityInfos;
            if (allFacilityByType == null) {
                return; //没有设备
            }

            for (let i = 0; i < allFacilityByType.length; i++) {
                let l_facilityByType = allFacilityByType[i];
                if (ConfigManager.getPosType(l_facilityByType.type) == FacilityPosType.Out) {
                    this.facilitysByMoudle.get(jbxxMoudle).push(l_facilityByType);
                }
            }


        }
        if (this.facilitysByMoudle.has(moudleType)) {
            //已经初始化过了
            return;
        }
        else {
            this.facilitysByMoudle.set(moudleType, []);
        }

        let allFacilityByType = buildingInfo.ModelInfo.facilityInfos;
        if (allFacilityByType == null) {
            return; //没有设备
        }

        for (let i = 0; i < allFacilityByType.length; i++) {
            let l_facilityByType = allFacilityByType[i];

            if (TsTool.stringContain(l_facilityByType.type, zdKey)) { //遮挡物
                if (!this.zdByMoudle.has(moudleType)) {
                    this.zdByMoudle.set(moudleType, []);
                }
                this.zdByMoudle.get(moudleType).push(l_facilityByType);
            }
            else if (TsTool.stringContain(l_facilityByType.type, "_" + moudleTypeKey) || TsTool.stringContain(l_facilityByType.type, moudleTypeKey + "_")) {
                this.facilitysByMoudle.get(moudleType).push(l_facilityByType);
            }

        }
    }

    /**
     * 显示罩棚
     * @param show false 表示隐藏罩棚
     */
    showZP(show: boolean) {
        this.initFacilityTypeByMoudleType(JYZInfoMoudleType.ZP, this.currentBuidngItem.buildingInfo);
        let zpInfoByTypes = this.zdByMoudle.get(JYZInfoMoudleType.ZP);
        if (zpInfoByTypes != null) {
            for (let i = 0; i < zpInfoByTypes.length; i++) {
                let infos = zpInfoByTypes[i].facilityInfo;
                for (let j = 0; j < infos.length; j++) {
                    infos[j].setEnable(show);
                }
            }
        }
        this.currentZPShow = show;
    }

    /**
     * 获取设备所需UV材质(如果有的话)
     * @param facilityType 
     * @param mesh 
     */
    getUVMat(facilityType: FacilityType, mesh: AbstractMesh) {
        let moudleType: JYZInfoMoudleType = null;
        switch (facilityType) {
            case FacilityType.AQSS_TSLX:
                moudleType = JYZInfoMoudleType.AQSS;
                break;
            case FacilityType.JY_SYGX:
                moudleType = JYZInfoMoudleType.SYG;
                break;
            case FacilityType.JY_YQHSGX:
                moudleType = JYZInfoMoudleType.YQHSGX;
                break;
        }

        if (moudleType != null) {
            if (!this.mat_UV.has(moudleType)) {
                this.mat_UV.set(moudleType, []);
            }

            let mats = this.findUVMat(mesh); //找到mesh上的uv材质

            for (let i = 0; i < mats.length; i++) {
                let l_mat = mats[i];

                let mat_uvByType = this.mat_UV.get(moudleType);
                let isRepeat = false;//是重复的
                for (let j = 0; j < mat_uvByType.length; j++) {
                    if (isRepeat) {
                        continue;
                    }
                    if (l_mat == mat_uvByType[j]) {
                        isRepeat = true;
                    }
                }

                if (!isRepeat)//不重复，就添加进去
                {
                    this.mat_UV.get(moudleType).push(l_mat);
                }
            }
        }
    }

    /**
     * 查找mesh中uv动画所需的材质
     * @param mesh 
     */
    private findUVMat(mesh: AbstractMesh) {
        let result = [];
        if (mesh == null) {
            return result;
        }
        let childMesh = mesh.getChildMeshes();
        childMesh.push(mesh);

        for (let i = 0; i < childMesh.length; i++) {
            let mat = childMesh[i].material;
            if (TsTool.stringContain(mat.name, this.c_MAT_UV)) {
                result.push(mat);
            }
        }
        return result;
    }


    /**
     * uv动画 update
     */
    updateUVAnim() {
        // console.log("uv", this.mat_UV);
        if (this.mat_UV == null || this.currentJYZInfoMoudleType == null) {
            return;
        }

        let mats = this.mat_UV.get(this.currentJYZInfoMoudleType);
        if (mats == null) {
            return;
        }

        for (let i = 0; i < mats.length; i++) {
            let mat = mats[i];
            if (mat instanceof PBRMaterial) {

                (mat.albedoTexture as Texture).vOffset += SceneManager.Instance.scene.deltaTime * this.c_uvAnimSpeed;
            }
        }
    }


    /**
     * 保存展示模块当前数据
     */
    saveShowMoudleData() {

        let moudleType = this.currentJYZInfoMoudleType;
        let camera = SceneManager.Instance.defaultCamera;
        let showZP = this.currentZPShow;

        if (DataManager.institutionData.JYZShowDatas == null) {
            DataManager.institutionData.JYZShowDatas = [];
        }

        let jyzShowData: JYZShowData = null;
        for (let i = 0; i < DataManager.institutionData.JYZShowDatas.length; i++) {
            if (DataManager.institutionData.JYZShowDatas[i].moudleType == moudleType) {
                jyzShowData = DataManager.institutionData.JYZShowDatas[i];
                break;
            }
        }
        if (jyzShowData == null) {
            jyzShowData = new JYZShowData(moudleType, camera, showZP);
            DataManager.institutionData.JYZShowDatas.push(jyzShowData);
        }
        jyzShowData.moudleType = moudleType;
        jyzShowData.cameraData.getDataFromCamera(camera);
        jyzShowData.showZP = showZP;
        console.log("保存展示数据", DataManager.institutionData.JYZShowDatas);

    }



    //#endregion

    //#region 限制摄像机Y

    /**
     * 摄像机Y高度的限制
     */
    limitCameraY_min: number = null;

    /**
     * 设置相机target最小Y
     * @param value 
     */
    setLimitCameraY_min(value: number) {
        this.limitCameraY_min = value;
    }

    /**
     * 限制摄像机Y
     */
    updateLimitCameraY() {
        if (SceneManager.Instance.defaultCamera != null) {
            if (this.limitCameraY_min != null) {
                if (SceneManager.Instance.defaultCamera.target.y < this.limitCameraY_min) {
                    SceneManager.Instance.defaultCamera.target.y = this.limitCameraY_min;
                }
            }

        }


    }


    //#endregion

}