TDataView_ui/scripts/mod/menu/getCollect3DData.js

/**
 * [ONEMAP.M.projectController]
 * @return {[object]}
 */
define(function (tplLayout) {

    /**
     * 初始化并订阅事件
     * @return {[type]} [description]
     */
    /**
     * 模块数据 用于数据存储和外部调用
     * @type {Object}
     * 数据存放
     */
    var modValue = {
        QXSY: {},
        model: {},
        seleted_guid: null,
        stereoscopic_handle: null,
    }

    /**
     * 状态值
     * @type {Boolean}
     * @default false
     * @private
     */
    var status = {
        initialized: false,
        isShowChild: false,
        connect: false,
        webSocketState: false
    };

    function init() {
        if (!status.initialized) {
            subscribe();
            bindEvent();
            prototypeBind();
            status.initialized = true;
            // $("#threeData").parent().find(".menu-content").show();
        }
        ONEMAP.C.publisher.publish({
            modName: 'threeData'
        }, 'menuListClick');
    }

    function prototypeBind() {
        //1.0GLTG插件
        var fixGltf = function (gltf) {
            if (!gltf.extensionsUsed) {
                return;
            }
            var v = gltf.extensionsUsed.indexOf('KHR_technique_webgl');
            var t = gltf.extensionsRequired.indexOf('KHR_technique_webgl');
            // 中招了。。
            if (v !== -1) {
                gltf.extensionsRequired.splice(t, 1, 'KHR_techniques_webgl');
                gltf.extensionsUsed.splice(v, 1, 'KHR_techniques_webgl');
                gltf.extensions = gltf.extensions || {};
                gltf.extensions['KHR_techniques_webgl'] = {};
                gltf.extensions['KHR_techniques_webgl'].programs = gltf.programs;
                gltf.extensions['KHR_techniques_webgl'].shaders = gltf.shaders;
                gltf.extensions['KHR_techniques_webgl'].techniques = gltf.techniques;
                var techniques = gltf.extensions['KHR_techniques_webgl'].techniques;

                gltf.materials.forEach(function (mat, index) {
                    gltf.materials[index].extensions['KHR_technique_webgl'].values = gltf.materials[index].values;
                    gltf.materials[index].extensions['KHR_techniques_webgl'] = gltf.materials[index].extensions['KHR_technique_webgl'];

                    var vtxfMaterialExtension = gltf.materials[index].extensions['KHR_techniques_webgl'];

                    for (var value in vtxfMaterialExtension.values) {
                        var us = techniques[vtxfMaterialExtension.technique].uniforms;
                        for (var key in us) {
                            if (us[key] === value) {
                                vtxfMaterialExtension.values[key] = vtxfMaterialExtension.values[value];
                                delete vtxfMaterialExtension.values[value];
                                break;
                            }
                        }
                    };
                });

                techniques.forEach(function (t) {
                    for (var attribute in t.attributes) {
                        var name = t.attributes[attribute];
                        t.attributes[attribute] = t.parameters[name];
                    };

                    for (var uniform in t.uniforms) {
                        var name = t.uniforms[uniform];
                        t.uniforms[uniform] = t.parameters[name];
                    };
                });
            }
        }
        Object.defineProperties(Cesium.Model.prototype, {
            _cachedGltf: {
                set: function (value) {
                    this._vtxf_cachedGltf = value;
                    if (this._vtxf_cachedGltf && this._vtxf_cachedGltf._gltf) {
                        fixGltf(this._vtxf_cachedGltf._gltf);
                    }
                },
                get: function () {
                    return this._vtxf_cachedGltf;
                }
            }
        });
    }

    function bindEvent() {
        var thrData = ONEMAP.D.globalSettingData.map3DModelSetting;
        var threeLength = ONEMAP.D.globalSettingData.map3DModelSetting.length;
        // alert(thrData);
        var ul = $('<ul class="menu-content"></ul>');
        for (var i = 0; i < threeLength; i++) {
            var threeDlist = $('<li class="item" cid="' + i + '"><input type="checkbox" class="zt-cbx" layer=""><span class="meun-checkBox menu-select-no"></span><span class="no-bg">' + thrData[i].name + '</span></li>');
            ul.append(threeDlist);
        }
        var data = ul.html();
        $(".sanWei .menu-content").html(data);

        $(".sanWei li").unbind('click').bind('click', function () {
            var menuCheckBox = $(this).find('.meun-checkBox');
            var ztCbx = $(this).find('.zt-cbx');
            if (menuCheckBox.hasClass("menu-select-no")) {

                menuCheckBox.removeClass('menu-select-no').addClass("menu-select");

                if (!map23DData.display.map3D) {
                    $("#mapModelChange .bg")[0].click()
                }

                var idx = $(this).attr('cid');
                var modelData = ONEMAP.D.globalSettingData.map3DModelSetting[idx];
                var guid = null
                var options = {};
                if (modelData.type == "qxData") {
                    guid = add3DQX(modelData);
                    options = {
                        action: "add",
                        DOM: {
                            guid: guid,
                            type: "QXSY",
                            name: $(this).find('.no-bg').text(),
                        },
                        mod: "QXSY"
                    }
                } else {
                    guid = add3DModel(modelData)
                    options = {
                        action: "add",
                        DOM: {
                            guid: guid,
                            type: "MOXING",
                            name: $(this).find('.no-bg').text(),
                        },
                        mod: "MOXING"
                    }
                }
                if (!guid) {
                    return
                }

                ztCbx.attr("layer", guid);
                ztCbx.attr("class", "zt-cbx " + guid);

                // // 添加到我的图层
                // var options = {
                //     action: "add",
                //     DOM: {
                //         guid: guid,
                //         type: "QXSY",
                //         name: $(this).find('.no-bg').text(),
                //     },
                //     mod: "QXSY"
                // }
                ONEMAP.M.myLayers.myLayerControl(options); // 添加信息到“我的图层”
                ONEMAP.C.publisher.subscribe(layerAction, guid);

            } else {
                menuCheckBox.removeClass('menu-select').addClass("menu-select-no");
                var guid = ztCbx.attr("layer");
                var type = guid.split("-")[0]
                if (type == "QXSY") {
                    removeQXSY(guid);
                } else {
                    removeMX(guid)
                }
                ONEMAP.M.myLayers.myLayerControl({
                    action: "remove",
                    DOMid: guid
                }); // 移除数据层
            }
        })
    }


    function layerAction(options) {
        if (options.guid.split("-")[0] == "QXSY") {
            if (options.action == "remove") {
                removeQXSY(options.guid)
            } else if (options.action == "opacity") {
                opacityQXSY(options)
            }
        } else if (options.guid.split("-")[0] == "MOXING") {
            if (options.action == "remove") {
                removeMX(options.guid)
            } else if (options.action == "opacity") {
                opacityMX(options)
            } else if (options.action == "set") {
                // 高亮显示模型，选中后可拖动
                removeModelHighlight();
                if (modValue.seleted_guid != null && options.guid == modValue.seleted_guid) {
                    removeControlStereoscopic();
                    modValue.seleted_guid = null;
                    return;
                }
                modValue.seleted_guid = options.guid;
                addControlStereoscopic();
            }
        }
    }

    function removeQXSY(guid) {
        map3DViewer.map.scene.primitives.remove(modValue.QXSY[guid]);
        delete modValue.QXSY[guid];

    }

    function opacityQXSY(options) {
        if (options.options.opacity)
            modValue.QXSY[options.guid].show = true
        if (!options.options.opacity)
            modValue.QXSY[options.guid].show = false
    }

    function removeMX(guid) {
        map3DViewer.map.entities.remove(modValue.model[guid]);
        delete modValue.model[guid];
        if (modValue.seleted_guid == guid) {
            removeControlStereoscopic()
            modValue.seleted_guid = null
        }
    }

    function opacityMX(options) {
        if (options.options.opacity) {
            modValue.model[options.guid].show = true
        } else {
            modValue.model[options.guid].show = false
        }
    }

    // 添加控制 模型  事件
    function addControlStereoscopic() {
        removeControlStereoscopic()
        addModelHighlight();
        modValue.stereoscopic_handle = new Cesium.ScreenSpaceEventHandler(map3DViewer.map.scene.canvas);
        // console.log(viewer.scene.canvas);
        modValue.stereoscopic_handle.setInputAction(mouseLeftDown, Cesium.ScreenSpaceEventType.LEFT_DOWN);
    }

    function mouseLeftDown(e) {
        //当鼠标点击时获取移动的位置 
        var pick = map3DViewer.map.scene.pick(e.position);
        // console.log(pick);
        if (pick != undefined) {
            var id = pick.id._id;
            if (modValue.seleted_guid != id) {
                return;
            } else {
                //禁止地图移动，绑定鼠标移动时间，移动时模型随之移动
                setMapControl(false)
                modValue.stereoscopic_handle.setInputAction(mouseLeftUp, Cesium.ScreenSpaceEventType.LEFT_UP);
                modValue.stereoscopic_handle.setInputAction(mouseMove, Cesium.ScreenSpaceEventType.MOUSE_MOVE)
            }
        }
    }

    function mouseLeftUp(e) {
        // //当鼠标点击时获取移动的位置 
        // var pick = map3DViewer.map.scene.pick(e.position);
        // if (pick != undefined) {
        //     var id = pick.id._id;
        //     if (modValue.seleted_guid != id) {
        //         return;
        //     } else {
        //         //恢复地图移动 取消鼠标移动事件
        //         setMapControl(true)
        //         modValue.stereoscopic_handle.removeInputAction(mouseMove, Cesium.ScreenSpaceEventType.MOUSE_MOVE)
        //     }
        // }

        //恢复地图移动 取消鼠标移动事件
        setMapControl(true)
        modValue.stereoscopic_handle.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_UP)
        modValue.stereoscopic_handle.removeInputAction(Cesium.ScreenSpaceEventType.MOUSE_MOVE)
    }

    function mouseMove(e) {
        var ray = map3DViewer.map.camera.getPickRay(e.endPosition);
        var cartesian = map3DViewer.map.scene.globe.pick(ray, map3DViewer.map.scene);
        // console.log(cartesian);
        modValue.model[modValue.seleted_guid].position.setValue(cartesian);
    }

    // 移除控制 模型  事件
    function removeControlStereoscopic() {
        if (modValue.stereoscopic_handle != null) {
            modValue.stereoscopic_handle.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_DOWN);
            modValue.stereoscopic_handle.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_UP);
            modValue.stereoscopic_handle.removeInputAction(Cesium.ScreenSpaceEventType.MOUSE_MOVE);
            modValue.stereoscopic_handle = null;
        }
    }

    // 添加 模型  高亮
    function addModelHighlight() {
        modValue.model[modValue.seleted_guid].model.silhouetteColor = Cesium.Color.BLUE;
        modValue.model[modValue.seleted_guid].model.silhouetteSize = 3.0;
    }
    // 移除 模型  高亮
    function removeModelHighlight() {
        if (modValue.seleted_guid != null) {
            modValue.model[modValue.seleted_guid].model.silhouetteSize = 0.0;
        }
    }

    function setMapControl(judge) {
        var obj = {};
        if (!judge) {
            modValue.screenSpaceCameraController = {
                rotateEventTypes: map3DViewer.map.scene.screenSpaceCameraController.rotateEventTypes,
                tiltEventTypes: map3DViewer.map.scene.screenSpaceCameraController.tiltEventTypes,
                translateEventTypes: map3DViewer.map.scene.screenSpaceCameraController.translateEventTypes,
                zoomEventTypes: map3DViewer.map.scene.screenSpaceCameraController.zoomEventTypes
                // enableRotate: map3DViewer.map.scene.screenSpaceCameraController.enableRotate,
                // enableTranslate: map3DViewer.map.scene.screenSpaceCameraController.enableTranslate,
                // enableZoom: map3DViewer.map.scene.screenSpaceCameraController.enableZoom,
                // enableTilt: map3DViewer.map.scene.screenSpaceCameraController.enableTilt,
            }
            obj = {
                rotateEventTypes: undefined,
                tiltEventTypes: undefined,
                translateEventTypes: undefined,
                zoomEventTypes: undefined
            }
        } else {
            if (!modValue.screenSpaceCameraController) {
                return
            }
            obj = {
                rotateEventTypes: modValue.screenSpaceCameraController.rotateEventTypes,
                tiltEventTypes: modValue.screenSpaceCameraController.tiltEventTypes,
                translateEventTypes: modValue.screenSpaceCameraController.translateEventTypes,
                zoomEventTypes: modValue.screenSpaceCameraController.zoomEventTypes,
            }
            modValue.screenSpaceCameraController = null;
        }
        // 如果为真，则允许用户旋转相机。如果为假，相机将锁定到当前标题。此标志仅适用于2D和3D。
        // map3DViewer.map.scene.screenSpaceCameraController.enableRotate  = obj.enableRotate;
        // // 如果为true，则允许用户平移地图。如果为假，相机将保持锁定在当前位置。此标志仅适用于2D和Columbus视图模式。
        // map3DViewer.map.scene.screenSpaceCameraController.enableTranslate = obj.enableTranslate;
        // // 如果为真，允许用户放大和缩小。如果为假，相机将锁定到距离椭圆体的当前距离
        // map3DViewer.map.scene.screenSpaceCameraController.enableZoom = obj.enableZoom;
        // // 如果为真，则允许用户倾斜相机。如果为假，相机将锁定到当前标题。这个标志只适用于3D和哥伦布视图。
        // map3DViewer.map.scene.screenSpaceCameraController.enableTilt = obj.enableTilt;

        map3DViewer.map.scene.screenSpaceCameraController.rotateEventTypes = obj.rotateEventTypes;
        map3DViewer.map.scene.screenSpaceCameraController.tiltEventTypes = obj.tiltEventTypes;
        map3DViewer.map.scene.screenSpaceCameraController.translateEventTypes = obj.translateEventTypes;
        map3DViewer.map.scene.screenSpaceCameraController.zoomEventTypes = obj.zoomEventTypes;

    }

    /**
     * 设置界面
     */
    function setLayout() {

    }

    /**
     * 界面重置
     * @return {[type]} [description]
     */
    function layoutResize(options) {
        if (options.modName != "threeData") {
            remove();
        } else {
            if (status.isShowChild) {
                remove();
            } else {
                $("#menu .sanWei").addClass('active');
                status.isShowChild = true;
                if (map23DData.show3DAlert) {
                    ONEMAP.C.publisher.publish('3D', 'layout::mapStyle');
                }
            }
        }
    }

    /**
     * 模块移除
     * @return {[type]} [description]
     */
    function remove() {
        //取消订阅
        unSubscribe();

        $("#menu .sanWei").removeClass('active');
        status.isShowChild = false;
    }

    /**
     * 加载/移除倾斜摄影
     * @return {[type]} [description]
     */
    function add3DQX(options) {
        var guid = map23DControl.buildGuid('QXSY-3DData');
        var tilesetUrl = options.url
        var tileset = new Cesium.Cesium3DTileset({
            url: tilesetUrl,
            show: true,
        });
        modValue.tileset = tileset
        map3DViewer.map.scene.primitives.add(tileset, 1);
        tileset.readyPromise.then(function (tileset) {
            // mapControl.viewer.camera.viewBoundingSphere(tileset.boundingSphere, new Cesium.HeadingPitchRange(0, -0.5, 0));
            // changeHeight(0)
        });
        map3DViewer.map.zoomTo(tileset);
        modValue.QXSY[guid] = tileset
        return guid;
    };
    /**
     * [add3DModel description]
     * 加载/移除三维模型
     * @param  {[type]} options [description]
     * @return {[type]}         [description]
     */
    function add3DModel(options) {
        var guid = map23DControl.buildGuid('MOXING-3DData');
        options.m_height = JSON.parse(options.m_height);
        options.m_hdeading = JSON.parse(options.m_hdeading);
        options.m_pitch = JSON.parse(options.m_pitch);
        options.m_roll = JSON.parse(options.m_roll);
        options.m_scale = JSON.parse(options.m_scale);
        var position = Cesium.Cartesian3.fromDegrees(options.center.lng, options.center.lat, options.m_height);
        var tileset = map3DViewer.map.entities.add({
            id: guid,
            position: position,
            orientation: Cesium.Transforms.headingPitchRollQuaternion(
                position,
                new Cesium.HeadingPitchRoll(
                    Cesium.Math.toRadians(options.m_hdeading),
                    Cesium.Math.toRadians(options.m_pitch),
                    Cesium.Math.toRadians(options.m_roll)
                )
            ),
            model: {
                uri: onemapUrlConfig.qxsy + options.url,
                // uri: options.url,
                minimumPixelSize: 128,
                scale: options.m_scale,
                heightReference: Cesium.HeightReference.RELATIVE_TO_GROUND
            }
        });
        map3DViewer.map.zoomTo(tileset);
        modValue.model[guid] = tileset;
        return guid;
    }

    function add3DModelNoFly(options) {
        if (options.name) {
            modValue['model' + options.indexNum] = locaSpaceMap.Globe.Layers.Add1(options.url);
        } else {
            locaSpaceMap.Globe.Layers.RemoveLayerByID(modValue['model' + options.indexNum]['ID']);
        }
        locaSpaceMap.Refresh();
    };

    function qxAction(options) {
        var thrData = ONEMAP.D.globalSettingData.map3DModelSetting;
        var opData = {
            lng: "",
            lat: "",
            zoom: ""
        };
        for (var i = 0; i < thrData.length; i++) {
            var threeDlist = thrData[i].type;
            if (threeDlist == "qxData") {
                // alert("qx");

                // alert(opData.lng);
                // alert(thrData[i].center.lat)

                if (options == "add") {
                    // alert(thrData[i].name);
                    add3DModelNoFly(thrData[i]);
                    thrData[i].indexNum = i;

                    if (opData.lng == "") {
                        opData.lng = thrData[i].center.lng;
                        opData.lat = thrData[i].center.lat;
                        opData.zoom = thrData[i].zoom;
                        // if(options == "add"){
                        point3D = locaSpaceMap.CreateGeoPoint3D();
                        point3D.X = opData.lng;
                        point3D.Y = opData.lat;
                        point3D.Z = opData.zoom;
                        feature = locaSpaceMap.CreateFeature();
                        feature.Geometry = point3D;
                        locaSpaceMap.Globe.FlyToFeature1(feature, 0, 45, 1); //飞行定位到目标点
                        //locaSpace.FlyToPlace(opData.lng,opData.lat,opData.zoom,0,45);
                        // }
                    }
                } else if (options == "remove") {
                    var modelData = {
                        indexNum: i
                    }
                    add3DModelNoFly(modelData);
                }
            } else {
                // alert(threeDlist);
            }
        }
        // if(options == "add"){
        //     locaSpace.FlyToPlace(opData.lng,opData.lat,opData.zoom,0,45);
        // }
    }

    /**
     * 注册订阅
     * @type {Function}
     * 推送：ONEMAP.C.publisher.publish(options,'moduleName::type');
     * 订阅：ONEMAP.C.publisher.subscribe(layoutResize,'sideBarLayoutChange');
     */
    function subscribe() {
        ONEMAP.C.publisher.subscribe(layoutResize, 'menuListClick');
        ONEMAP.C.publisher.subscribe(qxAction, '3DModelControl');
        // ONEMAP.C.publisher.subscribe(remove, 'cleanMap');
    }

    /**
     * 取消订阅
     * @type {Function}
     * 取消订阅：ONEMAP.C.publisher.unSubscribe(layoutResize,'sideBarLayoutChange');
     */
    function unSubscribe() {

    }

    return ONEMAP.M.threeData = {
        init: init
    }
});