deeptwins-engine-3d 0.1.40 → 0.1.41

package/dist/esm/analyze/ViewshedAnalysis.js

@@ -0,0 +1,442 @@
+// import * as Cesium from 'deeptwins-cesium';
+// import { merge } from 'lodash';
+// import { DEFAULT_VIEWSHED_ANALYSIS_OPTIONS } from '../constant';
+// import { MapContext } from '../map/Map';
+// import * as utils from '../tool/utils';
+//
+// // 可视域分析。
+// class ViewshedAnalysis {
+//   private readonly _mapContext: MapContext;
+//   public options: any;
+//   public isDestroyed: boolean = false;
+//   private _viewPositionC3: any;
+//   private _viewPositionEndC3: any;
+//   private _viewDistance: any;
+//   private _viewHeading: any;
+//   private _viewPitch: any;
+//   private lightCamera: any;
+//   private shadowMap: any;
+//   private postStage: any;
+//   private frustumOutline: any;
+//   private sketch: any;
+//
+//   constructor(map: any, options: any) {
+//     this._mapContext = map._mapContext;
+//     this.options = merge(DEFAULT_VIEWSHED_ANALYSIS_OPTIONS(), options);
+//     if (!this.options.viewPosition) return;
+//     const [lng, lat, alt] = this.options.viewPosition;
+//     this._viewPositionC3 = utils.lngLatAltToCartesian3(lng, lat, alt || 0);
+//     this._viewDistance = this.options.viewDistance;
+//     this._viewHeading = this.options.viewHeading;
+//     this._viewPitch = this.options.viewPitch;
+//     if (this.options.viewPositionEnd) {
+//       const [lng, lat, alt] = this.options.viewPositionEnd;
+//       this._viewPositionEndC3 = utils.lngLatAltToCartesian3(lng, lat, alt || 0);
+//       this._viewDistance = Cesium.Cartesian3.distance(
+//         this._viewPositionC3,
+//         this._viewPositionEndC3,
+//       );
+//       this._viewHeading = getHeading(
+//         this._viewPositionC3,
+//         this._viewPositionEndC3,
+//       );
+//       this._viewPitch = getPitch(this._viewPositionC3, this._viewPositionEndC3);
+//     }
+//     this.add();
+//   }
+//
+//   // 是否能进行操作
+//   private _canOperate() {
+//     if (this.isDestroyed) {
+//       utils.error('SunLightAnalysis实例已销毁');
+//       return false;
+//     }
+//     return true;
+//   }
+//
+//   public getMap() {
+//     return this._mapContext && this._mapContext.getMap();
+//   }
+//
+//   public add() {
+//     this.createLightCamera();
+//     this.createShadowMap();
+//     this.createPostStage();
+//     this.drawFrustumOutline();
+//     this.drawSketch();
+//   }
+//
+//   public update() {
+//     if (!this._canOperate) return;
+//     this.clear();
+//     this.add();
+//   }
+//
+//   //创建相机
+//   public createLightCamera() {
+//     if (!this._canOperate) return;
+//     this.lightCamera = new Cesium.Camera(this.getMap().scene);
+//     this.lightCamera.position = this._viewPositionC3;
+//     // if (this.viewPositionEnd) {
+//     //     let direction = Cesium.Cartesian3.normalize(Cesium.Cartesian3.subtract(this.viewPositionEnd, this.viewPosition, new Cesium.Cartesian3()), new Cesium.Cartesian3());
+//     //     this.lightCamera.direction = direction; // direction是相机面向的方向
+//     // }
+//     this.lightCamera.frustum.near = this._viewDistance * 0.001;
+//     this.lightCamera.frustum.far = this._viewDistance;
+//     const hr = Cesium.Math.toRadians(this.options.horizontalViewAngle);
+//     const vr = Cesium.Math.toRadians(this.options.verticalViewAngle);
+//     const aspectRatio =
+//       (this._viewDistance * Math.tan(hr / 2) * 2) /
+//       (this._viewDistance * Math.tan(vr / 2) * 2);
+//     this.lightCamera.frustum.aspectRatio = aspectRatio;
+//     if (hr > vr) {
+//       this.lightCamera.frustum.fov = hr;
+//     } else {
+//       this.lightCamera.frustum.fov = vr;
+//     }
+//     this.lightCamera.setView({
+//       destination: this._viewPositionC3,
+//       orientation: {
+//         heading: Cesium.Math.toRadians(this._viewHeading || 0),
+//         pitch: Cesium.Math.toRadians(this._viewPitch || 0),
+//         roll: 0,
+//       },
+//     });
+//   }
+//
+//   //创建阴影贴图
+//   public createShadowMap() {
+//     if (!this._canOperate) return;
+//     // 启用地形阴影
+//     this.getMap().scene.globe.shadows = Cesium.ShadowMode.ENABLED;
+//     // this.shadowMap = new Cesium.ShadowMap();
+//     // this.shadowMap.enabled = this.options.enabled;
+//     // this.shadowMap.size = this.options.size;
+//     // this.shadowMap.softShadows = this.options.softShadows;
+//     // this.shadowMap.normalOffset = false;
+//     this.shadowMap = new Cesium.ShadowMap({
+//       context: this.getMap().scene.context,
+//       lightCamera: this.lightCamera,
+//       enabled: this.options.enabled,
+//       isPointLight: true,
+//       pointLightRadius: this._viewDistance,
+//       cascadesEnabled: false,
+//       size: this.options.size,
+//       softShadows: this.options.softShadows,
+//       normalOffset: false,
+//       fromLightSource: false,
+//     });
+//     this.getMap().scene.shadowMap = this.shadowMap;
+//   }
+//
+//   //创建PostStage
+//   public createPostStage() {
+//     if (!this._canOperate) return;
+//     const fs = `
+//         #define USE_CUBE_MAP_SHADOW true
+//         uniform sampler2D colorTexture;
+//         uniform sampler2D depthTexture;
+//         varying vec2 v_textureCoordinates;
+//         uniform mat4 camera_projection_matrix;
+//         uniform mat4 camera_view_matrix;
+//         uniform samplerCube shadowMap_textureCube;
+//         uniform mat4 shadowMap_matrix;
+//         uniform vec4 shadowMap_lightPositionEC;
+//         uniform vec4 shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness;
+//         uniform vec4 shadowMap_texelSizeDepthBiasAndNormalShadingSmooth;
+//         uniform float helsing_viewDistance;
+//         uniform vec4 helsing_visibleAreaColor;
+//         uniform vec4 helsing_invisibleAreaColor;
+//         struct zx_shadowParameters
+//         {
+//             vec3 texCoords;
+//             float depthBias;
+//             float depth;
+//             float nDotL;
+//             vec2 texelStepSize;
+//             float normalShadingSmooth;
+//             float darkness;
+//         };
+//         float czm_shadowVisibility(samplerCube shadowMap, zx_shadowParameters shadowParameters)
+//         {
+//             float depthBias = shadowParameters.depthBias;
+//             float depth = shadowParameters.depth;
+//             float nDotL = shadowParameters.nDotL;
+//             float normalShadingSmooth = shadowParameters.normalShadingSmooth;
+//             float darkness = shadowParameters.darkness;
+//             vec3 uvw = shadowParameters.texCoords;
+//             depth -= depthBias;
+//             float visibility = czm_shadowDepthCompare(shadowMap, uvw, depth);
+//             return czm_private_shadowVisibility(visibility, nDotL, normalShadingSmooth, darkness);
+//         }
+//         vec4 getPositionEC(){
+//             return czm_windowToEyeCoordinates(gl_FragCoord);
+//         }
+//         vec3 getNormalEC(){
+//             return vec3(1.);
+//         }
+//         vec4 toEye( vec2 uv, float depth){
+//             vec2 xy=vec2((uv.x*2.-1.),(uv.y*2.-1.));
+//             vec4 posInCamera=czm_inverseProjection*vec4(xy,depth,1.);
+//             posInCamera=posInCamera/posInCamera.w;
+//             return posInCamera;
+//         }
+//         vec3 pointProjectOnPlane( vec3 planeNormal, vec3 planeOrigin, vec3 point){
+//             vec3 v01=point-planeOrigin;
+//             float d=dot(planeNormal,v01);
+//             return(point-planeNormal*d);
+//         }
+//         float getDepth( vec4 depth){
+//             float z_window=czm_unpackDepth(depth);
+//             z_window=czm_reverseLogDepth(z_window);
+//             float n_range=czm_depthRange.near;
+//             float f_range=czm_depthRange.far;
+//             return(2.*z_window-n_range-f_range)/(f_range-n_range);
+//         }
+//         float shadow( vec4 positionEC){
+//             vec3 normalEC=getNormalEC();
+//             zx_shadowParameters shadowParameters;
+//             shadowParameters.texelStepSize=shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.xy;
+//             shadowParameters.depthBias=shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.z;
+//             shadowParameters.normalShadingSmooth=shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.w;
+//             shadowParameters.darkness=shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.w;
+//             vec3 directionEC=positionEC.xyz-shadowMap_lightPositionEC.xyz;
+//             float distance=length(directionEC);
+//             directionEC=normalize(directionEC);
+//             float radius=shadowMap_lightPositionEC.w;
+//             if(distance>radius)
+//             {
+//                 return 2.0;
+//             }
+//             vec3 directionWC=czm_inverseViewRotation*directionEC;
+//             shadowParameters.depth=distance/radius-0.0003;
+//             shadowParameters.nDotL=clamp(dot(normalEC,-directionEC),0.,1.);
+//             shadowParameters.texCoords=directionWC;
+//             float visibility=czm_shadowVisibility(shadowMap_textureCube,shadowParameters);
+//             return visibility;
+//         }
+//         bool visible( vec4 result)
+//         {
+//             result.x/=result.w;
+//             result.y/=result.w;
+//             result.z/=result.w;
+//             return result.x>=-1.&&result.x<=1.
+//             &&result.y>=-1.&&result.y<=1.
+//             &&result.z>=-1.&&result.z<=1.;
+//         }
+//         void main(){
+//             // 釉色 = 结构二维(颜色纹理, 纹理坐标)
+//             gl_FragColor = texture2D(colorTexture, v_textureCoordinates);
+//             // 深度 = 获取深度(结构二维(深度纹理, 纹理坐标))
+//             float depth = getDepth(texture2D(depthTexture, v_textureCoordinates));
+//             // 视角 = (纹理坐标, 深度)
+//             vec4 viewPos = toEye(v_textureCoordinates, depth);
+//             // 世界坐标
+//             vec4 wordPos = czm_inverseView * viewPos;
+//             // 虚拟相机中坐标
+//             vec4 vcPos = camera_view_matrix * wordPos;
+//             float near = .001 * helsing_viewDistance;
+//             float dis = length(vcPos.xyz);
+//             if(dis > near && dis < helsing_viewDistance){
+//                 // 透视投影
+//                 vec4 posInEye = camera_projection_matrix * vcPos;
+//                 // 可视区颜色
+//                 // vec4 helsing_visibleAreaColor=vec4(0.,1.,0.,.5);
+//                 // vec4 helsing_invisibleAreaColor=vec4(1.,0.,0.,.5);
+//                 if(visible(posInEye)){
+//                     float vis = shadow(viewPos);
+//                     if(vis > 0.3){
+//                         gl_FragColor = mix(gl_FragColor,helsing_visibleAreaColor,.5);
+//                     } else{
+//                         gl_FragColor = mix(gl_FragColor,helsing_invisibleAreaColor,.5);
+//                     }
+//                 }
+//             }
+//         }`;
+//     const scene = this.getMap().scene;
+//     const postStage = new Cesium.PostProcessStage({
+//       fragmentShader: fs,
+//       uniforms: {
+//         shadowMap_textureCube: () => {
+//           this.shadowMap.update(Reflect.get(scene, '_frameState'));
+//           return Reflect.get(this.shadowMap, '_shadowMapTexture');
+//         },
+//         shadowMap_matrix: () => {
+//           this.shadowMap.update(Reflect.get(scene, '_frameState'));
+//           return Reflect.get(this.shadowMap, '_shadowMapMatrix');
+//         },
+//         shadowMap_lightPositionEC: () => {
+//           this.shadowMap.update(Reflect.get(scene, '_frameState'));
+//           return Reflect.get(this.shadowMap, '_lightPositionEC');
+//         },
+//         shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness: () => {
+//           this.shadowMap.update(Reflect.get(scene, '_frameState'));
+//           const bias = this.shadowMap._pointBias;
+//           return Cesium.Cartesian4.fromElements(
+//             bias.normalOffsetScale,
+//             this.shadowMap._distance,
+//             this.shadowMap.maximumDistance,
+//             0.0,
+//             new Cesium.Cartesian4(),
+//           );
+//         },
+//         shadowMap_texelSizeDepthBiasAndNormalShadingSmooth: () => {
+//           this.shadowMap.update(Reflect.get(scene, '_frameState'));
+//           const bias = this.shadowMap._pointBias;
+//           const scratchTexelStepSize = new Cesium.Cartesian2();
+//           const texelStepSize = scratchTexelStepSize;
+//           texelStepSize.x = 1.0 / this.shadowMap._textureSize.x;
+//           texelStepSize.y = 1.0 / this.shadowMap._textureSize.y;
+//
+//           return Cesium.Cartesian4.fromElements(
+//             texelStepSize.x,
+//             texelStepSize.y,
+//             bias.depthBias,
+//             bias.normalShadingSmooth,
+//             new Cesium.Cartesian4(),
+//           );
+//         },
+//         camera_projection_matrix: this.lightCamera.frustum.projectionMatrix,
+//         camera_view_matrix: this.lightCamera.viewMatrix,
+//         helsing_viewDistance: () => {
+//           return this._viewDistance;
+//         },
+//         helsing_visibleAreaColor: this.options.visibleAreaColor,
+//         helsing_invisibleAreaColor: this.options.invisibleAreaColor,
+//       },
+//     });
+//     this.postStage = scene.postProcessStages.add(postStage);
+//   }
+//
+//   //创建视锥线
+//   public drawFrustumOutline() {
+//     if (!this._canOperate) return;
+//     const scratchRight = new Cesium.Cartesian3();
+//     const scratchRotation = new Cesium.Matrix3();
+//     const scratchOrientation = new Cesium.Quaternion();
+//     // const position = this.lightCamera.positionWC;
+//     const direction = this.lightCamera.directionWC;
+//     const up = this.lightCamera.upWC;
+//     let right = this.lightCamera.rightWC;
+//     right = Cesium.Cartesian3.negate(right, scratchRight);
+//     const rotation = scratchRotation;
+//     Cesium.Matrix3.setColumn(rotation, 0, right, rotation);
+//     Cesium.Matrix3.setColumn(rotation, 1, up, rotation);
+//     Cesium.Matrix3.setColumn(rotation, 2, direction, rotation);
+//     const orientation = Cesium.Quaternion.fromRotationMatrix(
+//       rotation,
+//       scratchOrientation,
+//     );
+//
+//     const instance = new Cesium.GeometryInstance({
+//       geometry: new Cesium.FrustumOutlineGeometry({
+//         frustum: this.lightCamera.frustum,
+//         origin: this._viewPositionC3,
+//         orientation: orientation,
+//       }),
+//       attributes: {
+//         color: Cesium.ColorGeometryInstanceAttribute.fromColor(
+//           Cesium.Color.YELLOWGREEN, //new Cesium.Color(0.0, 1.0, 0.0, 1.0)
+//         ),
+//         show: new Cesium.ShowGeometryInstanceAttribute(true),
+//       },
+//     });
+//
+//     this.frustumOutline = this.getMap().scene.primitives.add(
+//       new Cesium.Primitive({
+//         geometryInstances: [instance],
+//         appearance: new Cesium.PerInstanceColorAppearance({
+//           flat: true,
+//           translucent: false,
+//         }),
+//       }),
+//     );
+//   }
+//
+//   //创建视网
+//   public drawSketch() {
+//     if (!this._canOperate) return;
+//     this.sketch = this.getMap().entities.add({
+//       name: 'sketch',
+//       position: this._viewPositionC3,
+//       orientation: Cesium.Transforms.headingPitchRollQuaternion(
+//         this._viewPositionC3,
+//         Cesium.HeadingPitchRoll.fromDegrees(
+//           this._viewHeading - this.options.horizontalViewAngle,
+//           this._viewPitch,
+//           0.0,
+//         ),
+//       ),
+//       ellipsoid: {
+//         radii: new Cesium.Cartesian3(
+//           this._viewDistance,
+//           this._viewDistance,
+//           this._viewDistance,
+//         ),
+//         // innerRadii: new Cesium.Cartesian3(2.0, 2.0, 2.0),
+//         minimumClock: Cesium.Math.toRadians(
+//           -this.options.horizontalViewAngle / 2,
+//         ),
+//         maximumClock: Cesium.Math.toRadians(
+//           this.options.horizontalViewAngle / 2,
+//         ),
+//         minimumCone: Cesium.Math.toRadians(
+//           this.options.verticalViewAngle + 7.75,
+//         ),
+//         maximumCone: Cesium.Math.toRadians(
+//           180 - this.options.verticalViewAngle - 7.75,
+//         ),
+//         fill: false,
+//         outline: true,
+//         subdivisions: 256,
+//         stackPartitions: 64,
+//         slicePartitions: 64,
+//         outlineColor: Cesium.Color.YELLOWGREEN,
+//       },
+//     });
+//   }
+//
+//   public clear() {
+//     if (!this._canOperate) return;
+//     if (this.frustumOutline) {
+//       this.frustumOutline.destroy();
+//       this.frustumOutline = null;
+//     }
+//     if (this.postStage) {
+//       this.getMap().scene.postProcessStages.remove(this.postStage);
+//       this.postStage = null;
+//     }
+//     if (this.sketch) {
+//       this.getMap().entities.remove(this.sketch);
+//       this.sketch = null;
+//     }
+//   }
+//
+//   public destroy() {
+//     if (!this._canOperate) return;
+//     this.isDestroyed = true;
+//     this.clear();
+//   }
+// }
+//
+// export default ViewshedAnalysis;
+//
+// //获取偏航角
+// function getHeading(fromPosition: any, toPosition: any) {
+//   const finalPosition = new Cesium.Cartesian3();
+//   const matrix4 = Cesium.Transforms.eastNorthUpToFixedFrame(fromPosition);
+//   Cesium.Matrix4.inverse(matrix4, matrix4);
+//   Cesium.Matrix4.multiplyByPoint(matrix4, toPosition, finalPosition);
+//   Cesium.Cartesian3.normalize(finalPosition, finalPosition);
+//   return Cesium.Math.toDegrees(Math.atan2(finalPosition.x, finalPosition.y));
+// }
+//
+// //获取俯仰角
+// function getPitch(fromPosition: any, toPosition: any) {
+//   const finalPosition = new Cesium.Cartesian3();
+//   const matrix4 = Cesium.Transforms.eastNorthUpToFixedFrame(fromPosition);
+//   Cesium.Matrix4.inverse(matrix4, matrix4);
+//   Cesium.Matrix4.multiplyByPoint(matrix4, toPosition, finalPosition);
+//   Cesium.Cartesian3.normalize(finalPosition, finalPosition);
+//   return Cesium.Math.toDegrees(Math.asin(finalPosition.z));
+// }

package/dist/esm/constant.d.ts

@@ -146,7 +146,20 @@ export declare const DEFAULT_SUN_ANALYSIS_OPTIONS: () => {
     clockRange: Cesium.ClockRange;
     clockStep: Cesium.ClockStep;
 };
-export declare const DEFAULT_VIEWSHED_ANALYSIS_OPTIONS: () => {};
+export declare const DEFAULT_VIEWSHED_ANALYSIS_OPTIONS: () => {
+    viewPosition: null;
+    viewPositionEnd: null;
+    viewDistance: number;
+    viewHeading: number;
+    viewPitch: number;
+    horizontalViewAngle: number;
+    verticalViewAngle: number;
+    visibleAreaColor: Cesium.Color;
+    invisibleAreaColor: Cesium.Color;
+    enabled: boolean;
+    softShadows: boolean;
+    size: number;
+};
 export declare const DEFAULT_BASE_LAYER_TYPE: any;
 export declare const DEFAULT_BASE_LAYER: any;
 export declare const LAYER_TYPE_TO_CLASS: any;

package/dist/esm/constant.js

@@ -235,7 +235,31 @@ export var DEFAULT_SUN_ANALYSIS_OPTIONS = function DEFAULT_SUN_ANALYSIS_OPTIONS(
 
 // 默认可视域分析
 export var DEFAULT_VIEWSHED_ANALYSIS_OPTIONS = function DEFAULT_VIEWSHED_ANALYSIS_OPTIONS() {
-  return {};
+  return {
+    viewPosition: null,
+    // 观测点位置
+    viewPositionEnd: null,
+    // 最远观测点位置 （如果设置了观测距离，这个属性可以不设置
+    viewDistance: 100,
+    // 观测距离
+    viewHeading: 0.0,
+    // 航向角
+    viewPitch: 0.0,
+    // 俯仰角
+    horizontalViewAngle: 90.0,
+    // 可视域水平夹角
+    verticalViewAngle: 60.0,
+    // 可视域垂直夹角
+    visibleAreaColor: Cesium.Color.GREEN,
+    // 可视区域颜色（默认值`绿色`）。
+    invisibleAreaColor: Cesium.Color.RED,
+    // 不可视区域颜色（默认值`红色`）。
+    enabled: true,
+    // 阴影贴图是否可用
+    softShadows: true,
+    // 是否启用柔和阴影
+    size: 2048 // 每个阴影贴图的大小
+  };
 };
 
 // 默认的底图类型

package/dist/esm/deepTwins/index.js

@@ -57,7 +57,6 @@ var DeepTwins = /*#__PURE__*/function () {
                   moduleLayer: this._getModuleLayer.bind(this),
                   trafficHistoryLayer: this._YunJing.TrafficHistoryLayer,
                   trafficLayer: this._YunJing.TrafficLayer,
-                  // 优先从 YunjingCesiumPlugins 获取 GridVTLayer（与示例代码一致）
                   gridVTLayer: (_this$_YunjingCesiumP = this._YunjingCesiumPlugins) === null || _this$_YunjingCesiumP === void 0 ? void 0 : _this$_YunjingCesiumP.GridVTLayer
                 });
               }

package/dist/esm/index.js

@@ -9,6 +9,7 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
 import * as Cesium from 'deeptwins-cesium';
 import SubmergenceAnalysis from "./analyze/SubmergenceAnalysis";
 import SunLightAnalysis from "./analyze/SunLightAnalysis";
+// import ViewshedAnalysis from './analyze/ViewshedAnalysis';
 import ModelRoamHistory from "./cameraControl/ModelRoamHistory";
 import ModelRoamRealTime from "./cameraControl/ModelRoamRealTime";
 import Roam from "./cameraControl/Roam";
@@ -53,11 +54,11 @@ DEEP_TWINS_BASE_URL && (window.CESIUM_BASE_URL = DEEP_TWINS_BASE_URL);
 // 全局加载css
 loadCss(Cesium.buildModuleUrl('Widgets/widgets.css'));
 // 打印版本信息
-console.log('DeepTwinsEngine3D Version:', "0.1.40");
+console.log('DeepTwinsEngine3D Version:', "0.1.41");
 export var DeepTwinsEngine3D = /*#__PURE__*/_createClass(function DeepTwinsEngine3D() {
   _classCallCheck(this, DeepTwinsEngine3D);
 });
-_defineProperty(DeepTwinsEngine3D, "Version", "0.1.40");
+_defineProperty(DeepTwinsEngine3D, "Version", "0.1.41");
 _defineProperty(DeepTwinsEngine3D, "Map", Map);
 _defineProperty(DeepTwinsEngine3D, "GroundSkyBox", GroundSkyBox);
 _defineProperty(DeepTwinsEngine3D, "RasterLayer", RasterLayer);

package/dist/esm/map/Map.d.ts

@@ -65,11 +65,9 @@ export default class Map extends Cesium.Viewer implements MapContext {
     addTerrainUrl(url: string): Promise<unknown>;
     addTerrain(terrain: any): Promise<unknown>;
     resetTerrain(): void;
-    showModuleLayer(isShow: boolean): void;
     addEffect(effect: any): void;
     removeEffect(effect: any): void;
     on(type: any, event: any): any;
     addModuleLayer: (moduleLayer: any) => any;
-    pickMonomer(data: any): any;
     destroy(): void;
 }

package/dist/esm/map/Map.js

@@ -74,7 +74,7 @@ var Map = /*#__PURE__*/function (_Cesium$Viewer) {
     _defineProperty(_assertThisInitialized(_this), "_defaultSkybox", null);
     // 近地天空盒监听
     _defineProperty(_assertThisInitialized(_this), "_handleSkyBox", null);
-    // 云镜
+    // 云镜模型实例
     _defineProperty(_assertThisInitialized(_this), "_yunjing", void 0);
     // 事件
     _defineProperty(_assertThisInitialized(_this), "_event", void 0);
@@ -658,14 +658,6 @@ var Map = /*#__PURE__*/function (_Cesium$Viewer) {
       this.scene.terrainProvider = new Cesium.EllipsoidTerrainProvider({});
     }
 
-    // 隐藏模型
-  }, {
-    key: "showModuleLayer",
-    value: function showModuleLayer(isShow) {
-      if (!this._yunjing) return;
-      isShow ? this._yunjing.show() : this._yunjing.hide();
-    }
-
     // 添加特效
   }, {
     key: "addEffect",
@@ -695,20 +687,10 @@ var Map = /*#__PURE__*/function (_Cesium$Viewer) {
       }
     }
   }, {
-    key: "pickMonomer",
+    key: "destroy",
     value:
-    // 拾取单体
-    function pickMonomer(data) {
-      if (!this._yunjing) {
-        throw new Error('请先加载模型');
-      }
-      return this._yunjing.pickMonomer(data);
-    }
-
     // 销毁
-  }, {
-    key: "destroy",
-    value: function destroy() {
+    function destroy() {
       this._eventTrick.forEach(function (t) {
         t.off();
       });

package/dist/esm/tileLayer/BarrierLayer.d.ts

@@ -13,14 +13,15 @@
  * ```
  */
 export default class BarrierLayer {
+    private readonly _mapContext;
+    isDestroyed: boolean;
     private _gridVTLayer;
-    private _viewer;
     private _options;
     private _heightColors;
     private static readonly DEFAULT_HEIGHT_COLORS;
     /**
      * 创建障碍物图层
-     * @param viewer Cesium Viewer实例
+     * @param map Cesium Viewer实例
      * @param options 配置选项
      * @param options.gridVTLayer GridVTLayer类（从DeepTwins.onLoad中获取）
      * @param options.url MVT数据URL模板，默认为障碍物数据地址
@@ -32,7 +33,9 @@ export default class BarrierLayer {
      * @param options.minHeight 最小高度（米），低于此高度的障碍物不渲染，默认0
      * @param options.maxHeight 最大高度（米），高于此高度的障碍物不渲染，默认Infinity
      */
-    constructor(viewer: any, options?: any);
+    constructor(map: any, options?: any);
+    private _canOperate;
+    getMap(): any;
     /**
      * 创建primitives
      * 按照示例代码的逻辑实现，每个feature创建一个障碍物实例