deeptwins-engine-3d 0.1.49 → 0.1.50

package/dist/esm/drawCommand/viewShed/RectangularSensorPrimitive.js

@@ -0,0 +1,1271 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as Cesium from 'deeptwins-cesium';
+import { scanPlaneFS, sensorComm, sensorFS, sensorVS } from "./config";
+var attributeLocations = {
+  position: 0,
+  normal: 1
+};
+var RectangularSensorPrimitive = /*#__PURE__*/function () {
+  function RectangularSensorPrimitive(options) {
+    var _options, _options$show, _options$slice, _options$radius, _options$xHalfAngle, _options$yHalfAngle, _options$_color, _options$lineColor, _options$showSectorLi, _options$showSectorSe, _options$showLateralS, _options$showDomeSurf, _options$showDomeLine, _options$showIntersec, _options$intersection, _options$intersection2, _options$showThroughE, _options$showScanPlan, _options$scanPlaneCol, _options$scanPlaneMod, _options$speed;
+    _classCallCheck(this, RectangularSensorPrimitive);
+    /**
+     * 模拟相控阵雷达。
+     * @param {Object} options 具有以下属性
+     * @param {Boolean} [options.show] 是否显示
+     * @param {Cartesian3|LonLat} [options.position] 图形位置
+     * @param {Matrix4} [options.modelMatrix] 模型矩阵,如果定义，则覆盖position属性
+     * @param {Number} [options.slice=32] 切分程度
+     * @param {Number} [options.radius=1] 半径
+     * @param {Color} [options.lineColor=Color.RED] 线的颜色
+     * @param {Number} [options.xHalfAngle] 水平半夹角,单位度
+     * @param {Number} [options.xyHalfAngle] 垂直半夹角，单位度
+     * @param {Boolean} [options.showSectorLines=true] 是否显示扇面线
+     * @param {Boolean} [options.showSectorSegmentLines=true] 是否显示扇面和圆顶面连接线
+     * @param {Boolean} [options.showLateralSurfaces=true] 是否显示侧面
+     * @param {Material} [options.material=Material.ColorType] 材质
+     * @param {Material} [options.lateralSurfaceMaterial=Material.ColorType] 侧面材质
+     * @param {Boolean} [options.showDomeSurfaces=true] 是否显示圆弧顶表面
+     * @param {Material} [options.domeSurfaceMaterial=Material.ColorType] 圆弧顶表面材质
+     * @param {Boolean} [options.showDomeLines=true] 是否显示圆弧顶表面线
+     * @param {Boolean} [options.showIntersection = false] 是否显示与地球相交的线
+     * @param {Color} [options.intersectionColor] 与地球相交的线的颜色
+     * @param {Number} [options.intersectionWidth=5] 与地球相交的线的宽度
+     * @param {Boolean} [options.showThroughEllipsoid=false] 是否穿过地球
+     * @param {Boolean} [options.showScanPlane=true] 是否显示扫描面
+     * @param {Color} [options.scanPlaneColor=Color.WHITE] 扫描面颜色
+     * @param {String} [options.scanPlaneMode='H'] 扫描方向，H表示水平扫描，V表示垂直扫描
+     * @param {Number} [options.speed=10] 扫描速度，值越大，扫描越快
+     */
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "_createVS", void 0);
+    _defineProperty(this, "_createRS", void 0);
+    _defineProperty(this, "_createSP", void 0);
+    _defineProperty(this, "show", void 0);
+    _defineProperty(this, "slice", void 0);
+    _defineProperty(this, "_modelMatrix", void 0);
+    _defineProperty(this, "_computedModelMatrix", void 0);
+    _defineProperty(this, "_computedScanPlaneModelMatrix", void 0);
+    _defineProperty(this, "_radius", void 0);
+    _defineProperty(this, "_xHalfAngle", void 0);
+    _defineProperty(this, "_yHalfAngle", void 0);
+    _defineProperty(this, "_color", void 0);
+    _defineProperty(this, "lineColor", void 0);
+    _defineProperty(this, "showSectorLines", void 0);
+    _defineProperty(this, "showSectorSegmentLines", void 0);
+    _defineProperty(this, "showLateralSurfaces", void 0);
+    _defineProperty(this, "_material", void 0);
+    _defineProperty(this, "_translucent", void 0);
+    _defineProperty(this, "lateralSurfaceMaterial", void 0);
+    _defineProperty(this, "_lateralSurfaceMaterial", void 0);
+    _defineProperty(this, "_lateralSurfaceTranslucent", void 0);
+    _defineProperty(this, "showDomeSurfaces", void 0);
+    _defineProperty(this, "domeSurfaceMaterial", void 0);
+    _defineProperty(this, "showDomeLines", void 0);
+    _defineProperty(this, "showIntersection", void 0);
+    _defineProperty(this, "intersectionColor", void 0);
+    _defineProperty(this, "intersectionWidth", void 0);
+    _defineProperty(this, "_showThroughEllipsoid", void 0);
+    _defineProperty(this, "showScanPlane", void 0);
+    _defineProperty(this, "scanPlaneColor", void 0);
+    _defineProperty(this, "scanPlaneMode", void 0);
+    _defineProperty(this, "speed", void 0);
+    _defineProperty(this, "_scanePlaneXHalfAngle", void 0);
+    _defineProperty(this, "_scanePlaneYHalfAngle", void 0);
+    _defineProperty(this, "_time", void 0);
+    _defineProperty(this, "_boundingSphere", void 0);
+    _defineProperty(this, "_boundingSphereWC", void 0);
+    _defineProperty(this, "_sectorFrontCommand", void 0);
+    _defineProperty(this, "_sectorBackCommand", void 0);
+    _defineProperty(this, "_sectorVA", void 0);
+    _defineProperty(this, "_sectorLineCommand", void 0);
+    _defineProperty(this, "_sectorLineVA", void 0);
+    _defineProperty(this, "_sectorSegmentLineCommand", void 0);
+    _defineProperty(this, "_sectorSegmentLineVA", void 0);
+    _defineProperty(this, "_domeFrontCommand", void 0);
+    _defineProperty(this, "_domeBackCommand", void 0);
+    _defineProperty(this, "_domeVA", void 0);
+    _defineProperty(this, "_domeLineCommand", void 0);
+    _defineProperty(this, "_domeLineVA", void 0);
+    _defineProperty(this, "_scanPlaneFrontCommand", void 0);
+    _defineProperty(this, "_scanPlaneBackCommand", void 0);
+    _defineProperty(this, "_scanRadialCommand", void 0);
+    _defineProperty(this, "_scanPlaneVA", void 0);
+    _defineProperty(this, "_colorCommands", void 0);
+    _defineProperty(this, "_frontFaceRS", void 0);
+    _defineProperty(this, "_backFaceRS", void 0);
+    _defineProperty(this, "_sp", void 0);
+    _defineProperty(this, "_pickSP", void 0);
+    _defineProperty(this, "_scanePlaneSP", void 0);
+    _defineProperty(this, "_uniforms", void 0);
+    _defineProperty(this, "_scanUniforms", void 0);
+    _defineProperty(this, "_pickRS", void 0);
+    options = (_options = options) !== null && _options !== void 0 ? _options : Cesium.defaultValue.EMPTY_OBJECT;
+    var self = this;
+    this._createVS = true;
+    this._createRS = true;
+    this._createSP = true;
+    /**
+     * 是否显示
+     * @type {Boolean}
+     */
+    this.show = (_options$show = options.show) !== null && _options$show !== void 0 ? _options$show : true;
+
+    //切分程度
+    this.slice = (_options$slice = options.slice) !== null && _options$slice !== void 0 ? _options$slice : 32;
+
+    //传感器的模型矩阵
+    if (!options.modelMatrix) {
+      if (!options.position) {
+        throw new Error('parameter position or modelMatrix must be provided.');
+      }
+      this._modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(Cesium.Cartesian3.fromDegrees(options.position.lon, options.position.lat, options.position.alt));
+    } else {
+      this._modelMatrix = Cesium.Matrix4.clone(options.modelMatrix, new Cesium.Matrix4());
+    }
+    this._computedModelMatrix = new Cesium.Matrix4();
+    this._computedScanPlaneModelMatrix = new Cesium.Matrix4();
+
+    //传感器的半径
+    this._radius = (_options$radius = options.radius) !== null && _options$radius !== void 0 ? _options$radius : Number.POSITIVE_INFINITY;
+
+    //传感器水平半角
+    this._xHalfAngle = Cesium.Math.toRadians((_options$xHalfAngle = options.xHalfAngle) !== null && _options$xHalfAngle !== void 0 ? _options$xHalfAngle : 0);
+
+    //传感器垂直半角
+    this._yHalfAngle = Cesium.Math.toRadians((_options$yHalfAngle = options.yHalfAngle) !== null && _options$yHalfAngle !== void 0 ? _options$yHalfAngle : 0);
+    this._color = (_options$_color = options._color) !== null && _options$_color !== void 0 ? _options$_color : Cesium.Color.AQUA.withAlpha(0.4);
+
+    /**
+     * 线的颜色
+     * @type {Cesium.Color}
+     */
+    this.lineColor = (_options$lineColor = options.lineColor) !== null && _options$lineColor !== void 0 ? _options$lineColor : Cesium.Color.WHITE;
+
+    /**
+     * 是否显示扇面的线
+     * @type {Boolean}
+     */
+    this.showSectorLines = (_options$showSectorLi = options.showSectorLines) !== null && _options$showSectorLi !== void 0 ? _options$showSectorLi : true;
+
+    /**
+     * 是否显示扇面和圆顶面连接的线
+     * @type {Boolean}
+     */
+    this.showSectorSegmentLines = (_options$showSectorSe = options.showSectorSegmentLines) !== null && _options$showSectorSe !== void 0 ? _options$showSectorSe : true;
+
+    /**
+     * 是否显示侧面
+     * @type {Boolean}
+     */
+    this.showLateralSurfaces = (_options$showLateralS = options.showLateralSurfaces) !== null && _options$showLateralS !== void 0 ? _options$showLateralS : true;
+
+    //目前用的统一材质
+    this._material = Cesium.defined(options.material) ? options.material : Cesium.Material.fromType(Cesium.Material.ColorType);
+    this._material.uniforms.color = this._color;
+    this._translucent = undefined;
+    /**
+     * 侧面材质
+     * @type {Material}
+     */
+    this.lateralSurfaceMaterial = Cesium.defined(options.lateralSurfaceMaterial) ? options.lateralSurfaceMaterial : Cesium.Material.fromType(Cesium.Material.ColorType);
+    this._lateralSurfaceMaterial = undefined;
+    this._lateralSurfaceTranslucent = undefined;
+
+    /**
+     * 是否显示圆顶表面
+     * @type {Boolean}
+     */
+    this.showDomeSurfaces = (_options$showDomeSurf = options.showDomeSurfaces) !== null && _options$showDomeSurf !== void 0 ? _options$showDomeSurf : true;
+
+    /**
+     * 圆顶表面材质
+     * @type {Material}
+     */
+    this.domeSurfaceMaterial = Cesium.defined(options.domeSurfaceMaterial) ? options.domeSurfaceMaterial : Cesium.Material.fromType(Cesium.Material.ColorType);
+
+    /**
+     * 是否显示圆顶面线
+     * @type {Boolean}
+     */
+    this.showDomeLines = (_options$showDomeLine = options.showDomeLines) !== null && _options$showDomeLine !== void 0 ? _options$showDomeLine : true;
+
+    /**
+     * 是否显示与地球相交的线
+     * @type {Boolean}
+     */
+    this.showIntersection = (_options$showIntersec = options.showIntersection) !== null && _options$showIntersec !== void 0 ? _options$showIntersec : false;
+
+    /**
+     * 与地球相交的线的颜色
+     * @type {Color}
+     */
+    this.intersectionColor = (_options$intersection = options.intersectionColor) !== null && _options$intersection !== void 0 ? _options$intersection : Cesium.Color.WHITE;
+
+    /**
+     * 与地球相交的线的宽度（像素）
+     * @type {Number}
+     */
+    this.intersectionWidth = (_options$intersection2 = options.intersectionWidth) !== null && _options$intersection2 !== void 0 ? _options$intersection2 : 5.0;
+
+    //是否穿过地球
+    this._showThroughEllipsoid = (_options$showThroughE = options.showThroughEllipsoid) !== null && _options$showThroughE !== void 0 ? _options$showThroughE : false;
+
+    /**
+     * 是否显示扫描面
+     * @type {Boolean}
+     */
+    this.showScanPlane = (_options$showScanPlan = options.showScanPlane) !== null && _options$showScanPlan !== void 0 ? _options$showScanPlan : true;
+
+    /**
+     * 扫描面颜色
+     * @type {Color}
+     */
+    this.scanPlaneColor = (_options$scanPlaneCol = options.scanPlaneColor) !== null && _options$scanPlaneCol !== void 0 ? _options$scanPlaneCol : Cesium.Color.AQUA;
+    /**
+     * 扫描面模式 垂直V/水平H
+     * @type {String}
+     */
+    this.scanPlaneMode = (_options$scanPlaneMod = options.scanPlaneMode) !== null && _options$scanPlaneMod !== void 0 ? _options$scanPlaneMod : 'H';
+
+    /**
+     * 扫描速率，值越大，扫描越慢
+     * @type {Number}
+     */
+    this.speed = (_options$speed = options.speed) !== null && _options$speed !== void 0 ? _options$speed : 10;
+    this._scanePlaneXHalfAngle = 0;
+    this._scanePlaneYHalfAngle = 0;
+
+    //时间计算的起点
+    this._time = Cesium.JulianDate.now();
+    this._boundingSphere = new Cesium.BoundingSphere();
+    this._boundingSphereWC = new Cesium.BoundingSphere();
+    this._boundingSphere = new Cesium.BoundingSphere(Cesium.Cartesian3.ZERO, this._radius);
+    Cesium.Matrix4.multiplyByUniformScale(this._modelMatrix, this._radius, this._computedModelMatrix);
+    Cesium.BoundingSphere.transform(this._boundingSphere, this._modelMatrix, this._boundingSphereWC);
+
+    //扇面 sector
+    this._sectorFrontCommand = new Cesium.DrawCommand({
+      owner: this,
+      primitiveType: Cesium.PrimitiveType.TRIANGLES,
+      boundingVolume: this._boundingSphereWC
+    });
+    this._sectorBackCommand = new Cesium.DrawCommand({
+      owner: this,
+      primitiveType: Cesium.PrimitiveType.TRIANGLES,
+      boundingVolume: this._boundingSphereWC
+    });
+    this._sectorVA = undefined;
+
+    //扇面边线 sectorLine
+    this._sectorLineCommand = new Cesium.DrawCommand({
+      owner: this,
+      primitiveType: Cesium.PrimitiveType.LINES,
+      boundingVolume: this._boundingSphereWC
+    });
+    this._sectorLineVA = undefined;
+
+    //扇面分割线 sectorSegmentLine
+    this._sectorSegmentLineCommand = new Cesium.DrawCommand({
+      owner: this,
+      primitiveType: Cesium.PrimitiveType.LINES,
+      boundingVolume: this._boundingSphereWC
+    });
+    this._sectorSegmentLineVA = undefined;
+
+    //弧面 dome
+    this._domeFrontCommand = new Cesium.DrawCommand({
+      owner: this,
+      primitiveType: Cesium.PrimitiveType.TRIANGLES,
+      boundingVolume: this._boundingSphereWC
+    });
+    this._domeBackCommand = new Cesium.DrawCommand({
+      owner: this,
+      primitiveType: Cesium.PrimitiveType.TRIANGLES,
+      boundingVolume: this._boundingSphereWC
+    });
+    this._domeVA = undefined;
+
+    //弧面线 domeLine
+    this._domeLineCommand = new Cesium.DrawCommand({
+      owner: this,
+      primitiveType: Cesium.PrimitiveType.LINES,
+      boundingVolume: this._boundingSphereWC
+    });
+    this._domeLineVA = undefined;
+
+    //扫描面 scanPlane/scanRadial
+    this._scanPlaneFrontCommand = new Cesium.DrawCommand({
+      owner: this,
+      primitiveType: Cesium.PrimitiveType.TRIANGLES,
+      boundingVolume: this._boundingSphereWC
+    });
+    this._scanPlaneBackCommand = new Cesium.DrawCommand({
+      owner: this,
+      primitiveType: Cesium.PrimitiveType.TRIANGLES,
+      boundingVolume: this._boundingSphereWC
+    });
+    this._scanRadialCommand = undefined;
+    this._colorCommands = [];
+    this._frontFaceRS = undefined;
+    this._backFaceRS = undefined;
+    this._sp = undefined;
+    this._pickSP = undefined;
+    this._scanePlaneSP = undefined;
+    this._uniforms = {
+      u_type: function u_type() {
+        return 0; //面
+      },
+      u_xHalfAngle: function u_xHalfAngle() {
+        return self._xHalfAngle;
+      },
+      u_yHalfAngle: function u_yHalfAngle() {
+        return self._yHalfAngle;
+      },
+      u_radius: function u_radius() {
+        return self.radius;
+      },
+      u_showThroughEllipsoid: function u_showThroughEllipsoid() {
+        return self.showThroughEllipsoid;
+      },
+      u_showIntersection: function u_showIntersection() {
+        return self.showIntersection;
+      },
+      u_intersectionColor: function u_intersectionColor() {
+        return self.intersectionColor;
+      },
+      u_intersectionWidth: function u_intersectionWidth() {
+        return self.intersectionWidth;
+      },
+      u_normalDirection: function u_normalDirection() {
+        return 1.0;
+      },
+      u_lineColor: function u_lineColor() {
+        return self.lineColor;
+      }
+    };
+    this._scanUniforms = {
+      u_xHalfAngle: function u_xHalfAngle() {
+        return self._scanePlaneXHalfAngle;
+      },
+      u_yHalfAngle: function u_yHalfAngle() {
+        return self._scanePlaneYHalfAngle;
+      },
+      u_radius: function u_radius() {
+        return self.radius;
+      },
+      u_color: function u_color() {
+        return self.scanPlaneColor;
+      },
+      u_showThroughEllipsoid: function u_showThroughEllipsoid() {
+        return self.showThroughEllipsoid;
+      },
+      u_showIntersection: function u_showIntersection() {
+        return self.showIntersection;
+      },
+      u_intersectionColor: function u_intersectionColor() {
+        return self.intersectionColor;
+      },
+      u_intersectionWidth: function u_intersectionWidth() {
+        return self.intersectionWidth;
+      },
+      u_normalDirection: function u_normalDirection() {
+        return 1.0;
+      },
+      u_lineColor: function u_lineColor() {
+        return self.lineColor;
+      }
+    };
+  }
+  _createClass(RectangularSensorPrimitive, [{
+    key: "color",
+    get: function get() {
+      return this._color;
+    },
+    set: function set(val) {
+      this._color = val;
+      this._material.uniforms.color = val;
+    }
+  }, {
+    key: "boundingSphere",
+    get: function get() {
+      return this._boundingSphere;
+    }
+    /**
+     * 水平面半夹角,单位：度
+     * @type {Number}
+     */
+  }, {
+    key: "xHalfAngle",
+    get: function get() {
+      return Cesium.Math.toDegrees(this._xHalfAngle);
+    },
+    set: function set(val) {
+      if (this._xHalfAngle !== val) {
+        this._xHalfAngle = Cesium.Math.toRadians(val);
+        this._createVS = true;
+      }
+    }
+    /**
+     * 垂直面半夹角,单位：度
+     * @type {Number}
+     */
+  }, {
+    key: "yHalfAngle",
+    get: function get() {
+      return Cesium.Math.toDegrees(this._yHalfAngle);
+    },
+    set: function set(val) {
+      if (this._yHalfAngle !== val) {
+        this._yHalfAngle = Cesium.Math.toRadians(val);
+        this._createVS = true;
+      }
+    }
+    /**
+     * 传感器半径
+     * @type {Number}
+     */
+  }, {
+    key: "radius",
+    get: function get() {
+      return this._radius;
+    },
+    set: function set(val) {
+      if (this._radius !== val) {
+        this._radius = val;
+        this._boundingSphere = new Cesium.BoundingSphere(Cesium.Cartesian3.ZERO, val);
+        Cesium.Matrix4.multiplyByUniformScale(this._modelMatrix, this._radius, this._computedModelMatrix);
+        Cesium.BoundingSphere.transform(this._boundingSphere, this._modelMatrix, this._boundingSphereWC);
+      }
+    }
+    /**
+     * 传感器模型矩阵
+     * @type {Matrix4}
+     */
+  }, {
+    key: "modelMatrix",
+    get: function get() {
+      return this._modelMatrix;
+    },
+    set: function set(val) {
+      var modelMatrixChanged = !Cesium.Matrix4.equals(val, this._modelMatrix);
+      if (modelMatrixChanged) {
+        Cesium.Matrix4.clone(val, this._modelMatrix);
+        Cesium.Matrix4.multiplyByUniformScale(this._modelMatrix, this._radius, this._computedModelMatrix);
+        Cesium.BoundingSphere.transform(this._boundingSphere, this._modelMatrix, this._boundingSphereWC);
+      }
+    }
+    /**
+     * 是否传过地球
+     * @type {Boolean}
+     */
+  }, {
+    key: "showThroughEllipsoid",
+    get: function get() {
+      return this._showThroughEllipsoid;
+    },
+    set: function set(val) {
+      if (this._showThroughEllipsoid !== val) {
+        this._showThroughEllipsoid = val;
+        this._createRS = true;
+      }
+    }
+    /**
+     * 材质
+     * @type {Material}
+     */
+  }, {
+    key: "material",
+    get: function get() {
+      return this._material;
+    },
+    set: function set(val) {
+      this._material = val;
+      this._createRS = true;
+      this._createSP = true;
+    }
+
+    /**
+     * 每一帧在渲染时Cesium会自动调用该方法。不要主动调用该方法
+     * @override
+     * @param  {frameState} frameState
+     */
+  }, {
+    key: "update",
+    value: function update(frameState) {
+      var mode = frameState.mode;
+      if (!this.show || mode !== Cesium.SceneMode.SCENE3D) {
+        return;
+      }
+      var xHalfAngle = this._xHalfAngle;
+      var yHalfAngle = this._yHalfAngle;
+      if (xHalfAngle < 0.0 || yHalfAngle < 0.0) {
+        throw new Error('halfAngle must be greater than or equal to zero.');
+      }
+      if (xHalfAngle == 0.0 || yHalfAngle == 0.0) {
+        return;
+      }
+      var radius = this.radius;
+      if (radius < 0.0) {
+        throw new Error('this.radius must be greater than or equal to zero.');
+      }
+      var showThroughEllipsoid = this.showThroughEllipsoid;
+      var material = this.material;
+      var translucent = material.isTranslucent();
+      if (this._translucent !== translucent) {
+        this._translucent = translucent;
+        this._createRS = true;
+      }
+      if (this.showScanPlane) {
+        var time = frameState.time;
+        var timeDiff = Cesium.JulianDate.secondsDifference(time, this._time);
+        if (timeDiff < 0) {
+          this._time = Cesium.JulianDate.clone(time, this._time);
+        }
+        var percentage;
+        if (this.speed <= 0) {
+          percentage = 0;
+        } else {
+          var speet = 10 / this.speed;
+          percentage = Math.max(timeDiff % speet / speet, 0);
+        }
+        var angle;
+        var matrix3Scratch = new Cesium.Matrix3();
+        if (this.scanPlaneMode == 'H') {
+          angle = 2 * yHalfAngle * percentage - yHalfAngle;
+          var cosYHalfAngle = Math.cos(angle);
+          var tanXHalfAngle = Math.tan(xHalfAngle);
+          var maxX = Math.atan(cosYHalfAngle * tanXHalfAngle);
+          this._scanePlaneXHalfAngle = maxX;
+          this._scanePlaneYHalfAngle = angle;
+          Cesium.Matrix3.fromRotationX(this._scanePlaneYHalfAngle, matrix3Scratch);
+        } else {
+          angle = 2 * xHalfAngle * percentage - xHalfAngle;
+          var tanYHalfAngle = Math.tan(yHalfAngle);
+          var cosXHalfAngle = Math.cos(angle);
+          var maxY = Math.atan(cosXHalfAngle * tanYHalfAngle);
+          this._scanePlaneXHalfAngle = angle;
+          this._scanePlaneYHalfAngle = maxY;
+          Cesium.Matrix3.fromRotationY(this._scanePlaneXHalfAngle, matrix3Scratch);
+        }
+        Cesium.Matrix4.multiplyByMatrix3(this.modelMatrix, matrix3Scratch, this._computedScanPlaneModelMatrix);
+        Cesium.Matrix4.multiplyByUniformScale(this._computedScanPlaneModelMatrix, this.radius, this._computedScanPlaneModelMatrix);
+      }
+      if (this._createVS) {
+        this.createVertexArray(this, frameState);
+      }
+      if (this._createRS) {
+        this.createRenderState(this, showThroughEllipsoid, translucent);
+      }
+      if (this._createSP) {
+        this.createShaderProgram(this, frameState, material);
+      }
+      if (this._createRS || this._createSP) {
+        this.createCommands(this, translucent);
+      }
+      var commandList = frameState.commandList;
+      var passes = frameState.passes;
+      var colorCommands = this._colorCommands;
+      if (passes.render) {
+        for (var i = 0, len = colorCommands.length; i < len; i++) {
+          var colorCommand = colorCommands[i];
+          commandList.push(colorCommand);
+        }
+      }
+    }
+
+    /**
+     * 创建顶点数组
+     * @param primitive: any
+     * @param frameState: any
+     */
+  }, {
+    key: "createVertexArray",
+    value: function createVertexArray(primitive, frameState) {
+      var context = frameState.context;
+      var unitSectorPositions = this.computeUnitPosition(primitive, primitive._xHalfAngle, primitive._yHalfAngle);
+      var positions = this.computeSectorPositions(primitive, unitSectorPositions);
+
+      //显示扇面
+      if (primitive.showLateralSurfaces) {
+        primitive._sectorVA = this.createSectorVertexArray(context, positions);
+      }
+
+      //显示扇面线
+      if (primitive.showSectorLines) {
+        primitive._sectorLineVA = this.createSectorLineVertexArray(context, positions);
+      }
+
+      //显示扇面圆顶面的交线
+      if (primitive.showSectorSegmentLines) {
+        primitive._sectorSegmentLineVA = this.createSectorSegmentLineVertexArray(context, positions);
+      }
+
+      //显示弧面
+      if (primitive.showDomeSurfaces) {
+        primitive._domeVA = this.createDomeVertexArray(context);
+      }
+
+      //显示弧面线
+      if (primitive.showDomeLines) {
+        primitive._domeLineVA = this.createDomeLineVertexArray(context);
+      }
+
+      //显示扫描面
+      if (primitive.showScanPlane) {
+        if (primitive.scanPlaneMode == 'H') {
+          var unitScanPlanePositions = this.computeUnitPosition(primitive, Cesium.Math.PI_OVER_TWO, 0);
+          primitive._scanPlaneVA = this.createScanPlaneVertexArray(context, unitScanPlanePositions.zox);
+        } else {
+          var _unitScanPlanePositions = this.computeUnitPosition(primitive, 0, Cesium.Math.PI_OVER_TWO);
+          primitive._scanPlaneVA = this.createScanPlaneVertexArray(context, _unitScanPlanePositions.zoy);
+        }
+      }
+    }
+    /**
+     * 创建渲染状态
+     * @param primitive: any
+     * @param showThroughEllipsoid: any
+     * @param translucent: any
+     */
+  }, {
+    key: "createRenderState",
+    value: function createRenderState(primitive, showThroughEllipsoid, translucent) {
+      if (translucent) {
+        primitive._frontFaceRS = Cesium.RenderState.fromCache({
+          depthTest: {
+            enabled: !showThroughEllipsoid
+          },
+          depthMask: false,
+          blending: Cesium.BlendingState.ALPHA_BLEND,
+          cull: {
+            enabled: true,
+            face: Cesium.CullFace.BACK
+          }
+        });
+        primitive._backFaceRS = Cesium.RenderState.fromCache({
+          depthTest: {
+            enabled: !showThroughEllipsoid
+          },
+          depthMask: false,
+          blending: Cesium.BlendingState.ALPHA_BLEND,
+          cull: {
+            enabled: true,
+            face: Cesium.CullFace.FRONT
+          }
+        });
+        primitive._pickRS = Cesium.RenderState.fromCache({
+          depthTest: {
+            enabled: !showThroughEllipsoid
+          },
+          depthMask: false,
+          blending: Cesium.BlendingState.ALPHA_BLEND
+        });
+      } else {
+        primitive._frontFaceRS = Cesium.RenderState.fromCache({
+          depthTest: {
+            enabled: !showThroughEllipsoid
+          },
+          depthMask: true
+        });
+        primitive._pickRS = Cesium.RenderState.fromCache({
+          depthTest: {
+            enabled: true
+          },
+          depthMask: true
+        });
+      }
+    }
+    /**
+     * 创建着色器程序
+     * @param primitive: any
+     * @param frameState: any
+     * @param material: any
+     */
+  }, {
+    key: "createShaderProgram",
+    value: function createShaderProgram(primitive, frameState, material) {
+      this.createCommonShaderProgram(primitive, frameState, material);
+      if (primitive.showScanPlane) {
+        this.createScanPlaneShaderProgram(primitive, frameState, material);
+      }
+    }
+
+    /**
+     * 创建命令
+     * @param primitive: any
+     * @param translucent: any
+     */
+  }, {
+    key: "createCommands",
+    value: function createCommands(primitive, translucent) {
+      primitive._colorCommands.length = 0;
+      var pass = translucent ? Cesium.Pass.TRANSLUCENT : Cesium.Pass.OPAQUE;
+
+      //显示扇面
+      if (primitive.showLateralSurfaces) {
+        this.createCommand(primitive, primitive._sectorFrontCommand, primitive._sectorBackCommand, primitive._frontFaceRS, primitive._backFaceRS, primitive._sp, primitive._sectorVA, primitive._uniforms, primitive._computedModelMatrix, translucent, pass);
+      }
+      //显示扇面线
+      if (primitive.showSectorLines) {
+        this.createCommand(primitive, primitive._sectorLineCommand, undefined, primitive._frontFaceRS, primitive._backFaceRS, primitive._sp, primitive._sectorLineVA, primitive._uniforms, primitive._computedModelMatrix, translucent, pass, true);
+      }
+
+      //显示扇面交接线
+      if (primitive.showSectorSegmentLines) {
+        this.createCommand(primitive, primitive._sectorSegmentLineCommand, undefined, primitive._frontFaceRS, primitive._backFaceRS, primitive._sp, primitive._sectorSegmentLineVA, primitive._uniforms, primitive._computedModelMatrix, translucent, pass, true);
+      }
+
+      //显示弧面
+      if (primitive.showDomeSurfaces) {
+        this.createCommand(primitive, primitive._domeFrontCommand, primitive._domeBackCommand, primitive._frontFaceRS, primitive._backFaceRS, primitive._sp, primitive._domeVA, primitive._uniforms, primitive._computedModelMatrix, translucent, pass);
+      }
+
+      //显示弧面线
+      if (primitive.showDomeLines) {
+        this.createCommand(primitive, primitive._domeLineCommand, undefined, primitive._frontFaceRS, primitive._backFaceRS, primitive._sp, primitive._domeLineVA, primitive._uniforms, primitive._computedModelMatrix, translucent, pass, true);
+      }
+      //显示扫描面
+      if (primitive.showScanPlane) {
+        this.createCommand(primitive, primitive._scanPlaneFrontCommand, primitive._scanPlaneBackCommand, primitive._frontFaceRS, primitive._backFaceRS, primitive._scanePlaneSP, primitive._scanPlaneVA, primitive._scanUniforms, primitive._computedScanPlaneModelMatrix, translucent, pass);
+      }
+      return;
+    }
+
+    /**
+     * 生成单位圆
+     * @param primitive: any
+     * @param xHalfAngle: any
+     * @param yHalfAngle: any
+     * @returns {Object} {zoy, zox}
+     */
+  }, {
+    key: "computeUnitPosition",
+    value: function computeUnitPosition(primitive, xHalfAngle, yHalfAngle) {
+      var slice = primitive.slice;
+      //以中心为角度
+      var cosYHalfAngle = Math.cos(yHalfAngle);
+      var tanYHalfAngle = Math.tan(yHalfAngle);
+      var cosXHalfAngle = Math.cos(xHalfAngle);
+      var tanXHalfAngle = Math.tan(xHalfAngle);
+      var maxY = Math.atan(cosXHalfAngle * tanYHalfAngle);
+      var maxX = Math.atan(cosYHalfAngle * tanXHalfAngle);
+
+      //ZOY面单位圆
+      var zoy = [];
+      for (var i = 0; i < slice; i++) {
+        var phi = 2 * maxY * i / (slice - 1) - maxY;
+        zoy.push(new Cesium.Cartesian3(0, Math.sin(phi), Math.cos(phi)));
+      }
+      //zox面单位圆
+      var zox = [];
+      for (var _i = 0; _i < slice; _i++) {
+        var _phi = 2 * maxX * _i / (slice - 1) - maxX;
+        zox.push(new Cesium.Cartesian3(Math.sin(_phi), 0, Math.cos(_phi)));
+      }
+      return {
+        zoy: zoy,
+        zox: zox
+      };
+    }
+
+    /**
+     * 计算扇面位置
+     * @param primitive: any
+     * @param unitPosition: { zoy: any[]; zox: any[] }
+     * @returns {Array} 扇面位置
+     */
+  }, {
+    key: "computeSectorPositions",
+    value: function computeSectorPositions(primitive, unitPosition) {
+      var xHalfAngle = primitive._xHalfAngle,
+        yHalfAngle = primitive._yHalfAngle,
+        zoy = unitPosition.zoy,
+        zox = unitPosition.zox;
+      var positions = [];
+
+      //zoy面沿y轴逆时针转xHalfAngle
+      var matrix3Scratch = new Cesium.Matrix3();
+      var matrix3 = Cesium.Matrix3.fromRotationY(xHalfAngle, matrix3Scratch);
+      positions.push(zoy.map(function (p) {
+        return Cesium.Matrix3.multiplyByVector(matrix3, p, new Cesium.Cartesian3());
+      }));
+      //zox面沿x轴顺时针转yHalfAngle
+      matrix3 = Cesium.Matrix3.fromRotationX(-yHalfAngle, matrix3Scratch);
+      positions.push(zox.map(function (p) {
+        return Cesium.Matrix3.multiplyByVector(matrix3, p, new Cesium.Cartesian3());
+      }).reverse());
+      //zoy面沿y轴顺时针转xHalfAngle
+      matrix3 = Cesium.Matrix3.fromRotationY(-xHalfAngle, matrix3Scratch);
+      positions.push(zoy.map(function (p) {
+        return Cesium.Matrix3.multiplyByVector(matrix3, p, new Cesium.Cartesian3());
+      }).reverse());
+      //zox面沿x轴逆时针转yHalfAngle
+      matrix3 = Cesium.Matrix3.fromRotationX(yHalfAngle, matrix3Scratch);
+      positions.push(zox.map(function (p) {
+        return Cesium.Matrix3.multiplyByVector(matrix3, p, new Cesium.Cartesian3());
+      }));
+      return positions;
+    }
+
+    /**
+     * 创建扇面顶点数组
+     * @param context: any
+     * @param positions: any[]
+     * @returns {VertexArray}
+     */
+  }, {
+    key: "createSectorVertexArray",
+    value: function createSectorVertexArray(context, positions) {
+      var planeLength = Array.prototype.concat.apply([], positions).length - positions.length;
+      var vertices = new Float32Array(2 * 3 * 3 * planeLength);
+      var k = 0;
+      for (var i = 0, len = positions.length; i < len; i++) {
+        var planePositions = positions[i];
+        var nScratch = new Cesium.Cartesian3();
+        var n = Cesium.Cartesian3.normalize(Cesium.Cartesian3.cross(planePositions[0], planePositions[planePositions.length - 1], nScratch), nScratch);
+        for (var j = 0, _planeLength = planePositions.length - 1; j < _planeLength; j++) {
+          vertices[k++] = 0.0;
+          vertices[k++] = 0.0;
+          vertices[k++] = 0.0;
+          vertices[k++] = -n.x;
+          vertices[k++] = -n.y;
+          vertices[k++] = -n.z;
+          vertices[k++] = planePositions[j].x;
+          vertices[k++] = planePositions[j].y;
+          vertices[k++] = planePositions[j].z;
+          vertices[k++] = -n.x;
+          vertices[k++] = -n.y;
+          vertices[k++] = -n.z;
+          vertices[k++] = planePositions[j + 1].x;
+          vertices[k++] = planePositions[j + 1].y;
+          vertices[k++] = planePositions[j + 1].z;
+          vertices[k++] = -n.x;
+          vertices[k++] = -n.y;
+          vertices[k++] = -n.z;
+        }
+      }
+      var vertexBuffer = Cesium.Buffer.createVertexBuffer({
+        context: context,
+        typedArray: vertices,
+        usage: Cesium.BufferUsage.STATIC_DRAW
+      });
+      var stride = 2 * 3 * Float32Array.BYTES_PER_ELEMENT;
+      var attributes = [{
+        index: attributeLocations.position,
+        vertexBuffer: vertexBuffer,
+        componentsPerAttribute: 3,
+        componentDatatype: Cesium.ComponentDatatype.FLOAT,
+        offsetInBytes: 0,
+        strideInBytes: stride
+      }, {
+        index: attributeLocations.normal,
+        vertexBuffer: vertexBuffer,
+        componentsPerAttribute: 3,
+        componentDatatype: Cesium.ComponentDatatype.FLOAT,
+        offsetInBytes: 3 * Float32Array.BYTES_PER_ELEMENT,
+        strideInBytes: stride
+      }];
+      return new Cesium.VertexArray({
+        context: context,
+        attributes: attributes
+      });
+    }
+
+    /**
+     * 创建扇面边线顶点数组
+     * @param context: any
+     * @param positions: any[]
+     * @returns {VertexArray}
+     */
+  }, {
+    key: "createSectorLineVertexArray",
+    value: function createSectorLineVertexArray(context, positions) {
+      var planeLength = positions.length;
+      var vertices = new Float32Array(3 * 3 * planeLength);
+      var k = 0;
+      for (var i = 0, len = positions.length; i < len; i++) {
+        var planePositions = positions[i];
+        vertices[k++] = 0.0;
+        vertices[k++] = 0.0;
+        vertices[k++] = 0.0;
+        vertices[k++] = planePositions[0].x;
+        vertices[k++] = planePositions[0].y;
+        vertices[k++] = planePositions[0].z;
+      }
+      var vertexBuffer = Cesium.Buffer.createVertexBuffer({
+        context: context,
+        typedArray: vertices,
+        usage: Cesium.BufferUsage.STATIC_DRAW
+      });
+      var stride = 3 * Float32Array.BYTES_PER_ELEMENT;
+      var attributes = [{
+        index: attributeLocations.position,
+        vertexBuffer: vertexBuffer,
+        componentsPerAttribute: 3,
+        componentDatatype: Cesium.ComponentDatatype.FLOAT,
+        offsetInBytes: 0,
+        strideInBytes: stride
+      }];
+      return new Cesium.VertexArray({
+        context: context,
+        attributes: attributes
+      });
+    }
+
+    /**
+     * 创建扇面圆顶面连接线顶点数组
+     * @param context: any
+     * @param positions: any[]
+     * @returns {VertexArray}
+     */
+  }, {
+    key: "createSectorSegmentLineVertexArray",
+    value: function createSectorSegmentLineVertexArray(context, positions) {
+      var planeLength = Array.prototype.concat.apply([], positions).length - positions.length;
+      var vertices = new Float32Array(3 * 3 * planeLength);
+      var k = 0;
+      for (var i = 0, len = positions.length; i < len; i++) {
+        var planePositions = positions[i];
+        for (var j = 0, _planeLength2 = planePositions.length - 1; j < _planeLength2; j++) {
+          vertices[k++] = planePositions[j].x;
+          vertices[k++] = planePositions[j].y;
+          vertices[k++] = planePositions[j].z;
+          vertices[k++] = planePositions[j + 1].x;
+          vertices[k++] = planePositions[j + 1].y;
+          vertices[k++] = planePositions[j + 1].z;
+        }
+      }
+      var vertexBuffer = Cesium.Buffer.createVertexBuffer({
+        context: context,
+        typedArray: vertices,
+        usage: Cesium.BufferUsage.STATIC_DRAW
+      });
+      var stride = 3 * Float32Array.BYTES_PER_ELEMENT;
+      var attributes = [{
+        index: attributeLocations.position,
+        vertexBuffer: vertexBuffer,
+        componentsPerAttribute: 3,
+        componentDatatype: Cesium.ComponentDatatype.FLOAT,
+        offsetInBytes: 0,
+        strideInBytes: stride
+      }];
+      return new Cesium.VertexArray({
+        context: context,
+        attributes: attributes
+      });
+    }
+    /**
+     * 创建圆顶面顶点数组
+     * @param context: any
+     * @returns {VertexArray}
+     */
+  }, {
+    key: "createDomeVertexArray",
+    value: function createDomeVertexArray(context) {
+      var geometry = Cesium.EllipsoidGeometry.createGeometry(new Cesium.EllipsoidGeometry({
+        vertexFormat: Cesium.VertexFormat.POSITION_ONLY,
+        stackPartitions: 32,
+        slicePartitions: 32
+      }));
+      var vertexArray = Cesium.VertexArray.fromGeometry({
+        context: context,
+        geometry: geometry,
+        attributeLocations: attributeLocations,
+        bufferUsage: Cesium.BufferUsage.STATIC_DRAW,
+        interleave: false
+      });
+      return vertexArray;
+    }
+
+    /**
+     * 创建圆顶面边线顶点数组
+     * @param context: any
+     * @returns {VertexArray}
+     */
+  }, {
+    key: "createDomeLineVertexArray",
+    value: function createDomeLineVertexArray(context) {
+      var geometry = Cesium.EllipsoidOutlineGeometry.createGeometry(new Cesium.EllipsoidOutlineGeometry({
+        vertexFormat: Cesium.VertexFormat.POSITION_ONLY,
+        stackPartitions: 32,
+        slicePartitions: 32
+      }));
+      var vertexArray = Cesium.VertexArray.fromGeometry({
+        context: context,
+        geometry: geometry,
+        attributeLocations: attributeLocations,
+        bufferUsage: Cesium.BufferUsage.STATIC_DRAW,
+        interleave: false
+      });
+      return vertexArray;
+    }
+    /**
+     * 创建扫描面顶点数组
+     * @param context: any
+     * @param positions: any[]
+     * @returns {VertexArray}
+     */
+  }, {
+    key: "createScanPlaneVertexArray",
+    value: function createScanPlaneVertexArray(context, positions) {
+      var planeLength = positions.length - 1;
+      var vertices = new Float32Array(3 * 3 * planeLength);
+      var k = 0;
+      for (var i = 0; i < planeLength; i++) {
+        vertices[k++] = 0.0;
+        vertices[k++] = 0.0;
+        vertices[k++] = 0.0;
+        vertices[k++] = positions[i].x;
+        vertices[k++] = positions[i].y;
+        vertices[k++] = positions[i].z;
+        vertices[k++] = positions[i + 1].x;
+        vertices[k++] = positions[i + 1].y;
+        vertices[k++] = positions[i + 1].z;
+      }
+      var vertexBuffer = Cesium.Buffer.createVertexBuffer({
+        context: context,
+        typedArray: vertices,
+        usage: Cesium.BufferUsage.STATIC_DRAW
+      });
+      var stride = 3 * Float32Array.BYTES_PER_ELEMENT;
+      var attributes = [{
+        index: attributeLocations.position,
+        vertexBuffer: vertexBuffer,
+        componentsPerAttribute: 3,
+        componentDatatype: Cesium.ComponentDatatype.FLOAT,
+        offsetInBytes: 0,
+        strideInBytes: stride
+      }];
+      return new Cesium.VertexArray({
+        context: context,
+        attributes: attributes
+      });
+    }
+    /**
+     * 创建通用着色器程序
+     * @param primitive: any
+     * @param frameState: any
+     * @param material: any
+     * @returns {ShaderProgram}
+     */
+  }, {
+    key: "createCommonShaderProgram",
+    value: function createCommonShaderProgram(primitive, frameState, material) {
+      var context = frameState.context;
+      var vs = sensorVS;
+      var fs = new Cesium.ShaderSource({
+        sources: [sensorComm, material.shaderSource, sensorFS]
+      });
+      primitive._sp = Cesium.ShaderProgram.replaceCache({
+        context: context,
+        shaderProgram: primitive._sp,
+        vertexShaderSource: vs,
+        fragmentShaderSource: fs,
+        attributeLocations: attributeLocations
+      });
+      var pickFS = new Cesium.ShaderSource({
+        sources: [sensorComm, material.shaderSource, sensorFS],
+        pickColorQualifier: 'uniform'
+      });
+      primitive._pickSP = Cesium.ShaderProgram.replaceCache({
+        context: context,
+        shaderProgram: primitive._pickSP,
+        vertexShaderSource: vs,
+        fragmentShaderSource: pickFS,
+        attributeLocations: attributeLocations
+      });
+    }
+
+    /**
+     * 创建扫描面着色器程序
+     * @param primitive: any
+     * @param frameState: any
+     * @param material: any
+     * @returns {ShaderProgram}
+     */
+  }, {
+    key: "createScanPlaneShaderProgram",
+    value: function createScanPlaneShaderProgram(primitive, frameState, material) {
+      var context = frameState.context;
+      var vs = sensorVS;
+      var fs = new Cesium.ShaderSource({
+        sources: [sensorComm, material.shaderSource, scanPlaneFS]
+      });
+      primitive._scanePlaneSP = Cesium.ShaderProgram.replaceCache({
+        context: context,
+        shaderProgram: primitive._scanePlaneSP,
+        vertexShaderSource: vs,
+        fragmentShaderSource: fs,
+        attributeLocations: attributeLocations
+      });
+    }
+    /**
+     * 创建命令
+     * @param primitive: any
+     * @param frontCommand: any
+     * @param backCommand: any
+     * @param frontFaceRS: any
+     * @param backFaceRS: any
+     * @param sp: any
+     * @param va: any
+     * @param uniforms: any
+     * @param modelMatrix: any
+     * @param translucent: any
+     * @param pass: any
+     * @param isLine: any
+     * @returns {any}
+     */
+  }, {
+    key: "createCommand",
+    value: function createCommand(primitive, frontCommand, backCommand, frontFaceRS, backFaceRS, sp, va, uniforms, modelMatrix, translucent, pass, isLine) {
+      if (translucent && backCommand) {
+        backCommand.vertexArray = va;
+        backCommand.renderState = backFaceRS;
+        backCommand.shaderProgram = sp;
+        backCommand.uniformMap = Cesium.combine(uniforms, primitive._material._uniforms);
+        backCommand.uniformMap.u_normalDirection = function () {
+          return -1.0;
+        };
+        backCommand.pass = pass;
+        backCommand.modelMatrix = modelMatrix;
+        primitive._colorCommands.push(backCommand);
+      }
+      frontCommand.vertexArray = va;
+      frontCommand.renderState = frontFaceRS;
+      frontCommand.shaderProgram = sp;
+      frontCommand.uniformMap = Cesium.combine(uniforms, primitive._material._uniforms);
+      if (isLine) {
+        frontCommand.uniformMap.u_type = function () {
+          return 1;
+        };
+      }
+      frontCommand.pass = pass;
+      frontCommand.modelMatrix = modelMatrix;
+      primitive._colorCommands.push(frontCommand);
+    }
+    /**
+     * 销毁对象，清理所有资源
+     */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      // 清理顶点数组
+      if (this._sectorVA) {
+        this._sectorVA.destroy();
+        this._sectorVA = undefined;
+      }
+      if (this._sectorLineVA) {
+        this._sectorLineVA.destroy();
+        this._sectorLineVA = undefined;
+      }
+      if (this._sectorSegmentLineVA) {
+        this._sectorSegmentLineVA.destroy();
+        this._sectorSegmentLineVA = undefined;
+      }
+      if (this._domeVA) {
+        this._domeVA.destroy();
+        this._domeVA = undefined;
+      }
+      if (this._domeLineVA) {
+        this._domeLineVA.destroy();
+        this._domeLineVA = undefined;
+      }
+      if (this._scanPlaneVA) {
+        this._scanPlaneVA.destroy();
+        this._scanPlaneVA = undefined;
+      }
+
+      // 清理着色器程序
+      if (this._sp) {
+        this._sp.destroy();
+        this._sp = undefined;
+      }
+      if (this._pickSP) {
+        this._pickSP.destroy();
+        this._pickSP = undefined;
+      }
+      if (this._scanePlaneSP) {
+        this._scanePlaneSP.destroy();
+        this._scanePlaneSP = undefined;
+      }
+
+      // 清理渲染状态
+      if (this._frontFaceRS) {
+        this._frontFaceRS = undefined;
+      }
+      if (this._backFaceRS) {
+        this._backFaceRS = undefined;
+      }
+      if (this._pickRS) {
+        this._pickRS = undefined;
+      }
+
+      // 清理命令
+      this._colorCommands.length = 0;
+
+      // 清理材质
+      if (this._material) {
+        this._material = undefined;
+      }
+      if (this.lateralSurfaceMaterial) {
+        this.lateralSurfaceMaterial = undefined;
+      }
+      if (this.domeSurfaceMaterial) {
+        this.domeSurfaceMaterial = undefined;
+      }
+
+      // 清理矩阵
+      if (this._modelMatrix) {
+        this._modelMatrix = undefined;
+      }
+      if (this._computedModelMatrix) {
+        this._computedModelMatrix = undefined;
+      }
+      if (this._computedScanPlaneModelMatrix) {
+        this._computedScanPlaneModelMatrix = undefined;
+      }
+
+      // 清理边界球
+      if (this._boundingSphere) {
+        this._boundingSphere = undefined;
+      }
+      if (this._boundingSphereWC) {
+        this._boundingSphereWC = undefined;
+      }
+
+      // 清理命令对象
+      this._sectorFrontCommand = undefined;
+      this._sectorBackCommand = undefined;
+      this._sectorLineCommand = undefined;
+      this._sectorSegmentLineCommand = undefined;
+      this._domeFrontCommand = undefined;
+      this._domeBackCommand = undefined;
+      this._domeLineCommand = undefined;
+      this._scanPlaneFrontCommand = undefined;
+      this._scanPlaneBackCommand = undefined;
+      this._scanRadialCommand = undefined;
+
+      // 清理uniforms
+      this._uniforms = undefined;
+      this._scanUniforms = undefined;
+
+      // 标记为已销毁
+      this.show = false;
+      return Cesium.destroyObject(this);
+    }
+  }, {
+    key: "isDestroyed",
+    value: function isDestroyed() {
+      return false;
+    }
+  }]);
+  return RectangularSensorPrimitive;
+}();
+export default RectangularSensorPrimitive;