add Model Collection Primitive

modules/event/type/MouseEvent.js

   /**
    * Returns the target information for the mouse event
    * @param target
-   * @returns {{overlay: any, feature: any, layer: any}}
+   * @returns {{instanceId: *, overlay: undefined, feature: undefined, layer: undefined}}
    * @private
    */
   _getTargetInfo(target) {
     let feature = undefined
 
     // for Entity
-    if (target && target.id && target.id instanceof Cesium.Entity) {
+    if (target?.id instanceof Cesium.Entity) {
       layer = this._viewer
         .getLayers()
         .filter(item => item.layerId === target.id.layerId)[0]
-      if (layer && layer.getOverlay) {
+      if (layer?.getOverlay) {
         overlay = layer.getOverlay(target.id.overlayId)
       }
     }
 
     // for Cesium3DTileFeature
-    else if (target && target instanceof Cesium.Cesium3DTileFeature) {
+    else if (target instanceof Cesium.Cesium3DTileFeature) {
       layer = this._viewer
         .getLayers()
         .filter(item => item.layerId === target.tileset.layerId)[0]
       feature = target
-      if (layer && layer.getOverlay) {
+      if (layer?.getOverlay) {
         overlay = layer.getOverlay(target.tileset.overlayId)
         if (feature && feature.getPropertyNames) {
           let propertyNames = feature.getPropertyNames()
     }
 
     // for Cesium3DTileset
-    else if (
-      target &&
-      target.primitive &&
-      target.primitive instanceof Cesium.Cesium3DTileset
-    ) {
+    else if (target?.primitive instanceof Cesium.Cesium3DTileset) {
       layer = this._viewer
         .getLayers()
         .filter(item => item.layerId === target.primitive.layerId)[0]
-      if (layer && layer.getOverlay) {
+      if (layer?.getOverlay) {
         overlay = layer.getOverlay(target.primitive.overlayId)
       }
     }
 
     // for Primitve
-    else if (target && target.primitive) {
+    else if (target?.primitive) {
       layer = this._viewer
         .getLayers()
         .filter(item => item.layerId === target.primitive.layerId)[0]
-      if (layer && layer.getOverlay) {
+      if (layer?.getOverlay) {
         overlay = layer.getOverlay(target.primitive.overlayId)
       }
     }
 
-    return { layer: layer, overlay: overlay, feature: feature }
+    return {
+      layer: layer,
+      overlay: overlay,
+      feature: feature,
+      instanceId: target?.instanceId
+    }
   }
 
   /**

modules/overlay/index.js

 export { default as ElecEllipsoidPrimitive } from './primitive/ElecEllipsoidPrimitive'
 export { default as FlowLinePrimitive } from './primitive/FlowLinePrimitive'
 export { default as LabelPrimitive } from './primitive/LabelPrimitive'
+export { default as ModelCollectionPrimitive } from './primitive/ModelCollectionPrimitive'
 export { default as ModelPrimitive } from './primitive/ModelPrimitive'
 export { default as PointPrimitive } from './primitive/PointPrimitive.js'
 export { default as PolylinePrimitive } from './primitive/PolylinePrimitive.js'

modules/overlay/primitive/ModelCollectionPrimitive.js

+/**
+ * @Author: Caven
+ * @Date: 2021-08-02 20:12:04
+ */
+
+import { Cesium } from '@dc-modules/namespace'
+import State from '@dc-modules/state/State'
+import Parse from '@dc-modules/parse/Parse'
+import { Transform } from '@dc-modules/transform'
+import Overlay from '../Overlay'
+
+class ModelCollectionPrimitive extends Overlay {
+  constructor(positions, modelUrl) {
+    super()
+    this._positions = Parse.parsePositions(positions)
+    this._modelUrl = modelUrl
+    this._attrs = []
+    this._state = State.INITIALIZED
+  }
+
+  get type() {
+    return Overlay.getOverlayType('model_collection_primitive')
+  }
+
+  set attrs(attrs) {
+    this._attrs = attrs
+    return this
+  }
+
+  get attrs() {
+    return this._attrs
+  }
+
+  set positions(positions) {
+    this._positions = Parse.parsePositions(positions)
+    if (this._layer) {
+      this._resetDelegate()
+      this._layer.delegate.add(this._delegate)
+    }
+    return this
+  }
+
+  set modelUrl(modelUrl) {
+    this._modelUrl = modelUrl
+    if (this._layer) {
+      this._resetDelegate()
+      this._layer.delegate.add(this._delegate)
+    }
+    return this
+  }
+
+  get modelUrl() {
+    return this._modelUrl
+  }
+
+  _resetDelegate() {
+    this._delegate = this._delegate && this._delegate.destroy()
+    this._delegate = new Cesium.ModelInstanceCollection({
+      url: this._modelUrl,
+      instances: this._positions.map(item => {
+        let origin = Transform.transformWGS84ToCartesian(item)
+        let modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(
+          origin,
+          new Cesium.HeadingPitchRoll(
+            Cesium.Math.toRadians(item.heading),
+            Cesium.Math.toRadians(item.pitch),
+            Cesium.Math.toRadians(item.roll)
+          )
+        )
+        this._style?.scale &&
+          Cesium.Matrix4.multiplyByUniformScale(
+            modelMatrix,
+            this._style?.scale,
+            modelMatrix
+          )
+        return {
+          modelMatrix
+        }
+      }),
+      ...this._style
+    })
+    this._delegate.layerId = this._layer?.layerId
+    this._delegate.overlayId = this._id
+  }
+
+  _mountedHook() {
+    this._resetDelegate()
+  }
+
+  /**
+   *
+   * @param instanceId
+   * @returns {undefined}
+   */
+  getModelInstance(instanceId) {
+    return this._delegate._instances[instanceId] || undefined
+  }
+
+  /**
+   *
+   * @param instanceId
+   * @returns {*|{}}
+   */
+  getAttrByInstanceId(instanceId) {
+    return this._attrs[instanceId] || {}
+  }
+
+  /**
+   *
+   * @param style
+   * @returns {ModelCollectionPrimitive}
+   */
+  setStyle(style) {
+    if (!style || Object.keys(style).length === 0) {
+      return this
+    }
+    delete style['instances'] && delete style['url']
+    this._style = style
+    if (this._layer) {
+      this._resetDelegate()
+      this._layer.delegate.add(this._delegate)
+    }
+    return this
+  }
+}
+
+Overlay.registerType('model_collection_primitive')
+
+export default ModelCollectionPrimitive

modules/widget/type/ContextMenu.js

     this._surfacePosition = undefined
     this._wgs84SurfacePosition = undefined
     this._windowPosition = undefined
+    this._instanceId = undefined
     this._config = {}
     this._defaultMenu = [
       {
         }
       }
     }
+    this._instanceId = target?.instanceId
     // for Entity
-    if (target && target.id && target.id instanceof Cesium.Entity) {
+    if (target?.id instanceof Cesium.Entity) {
       let layer = this._viewer
         .getLayers()
         .filter(item => item.layerId === target.id.layerId)[0]
     }
 
     // for Cesium3DTileFeature
-    else if (target && target instanceof Cesium.Cesium3DTileFeature) {
+    else if (target instanceof Cesium.Cesium3DTileFeature) {
       let layer = this._viewer
         .getLayers()
         .filter(item => item.layerId === target.tileset.layerId)[0]
     }
 
     // for Cesium3DTileset
-    else if (
-      target &&
-      target.primitive &&
-      target.primitive instanceof Cesium.Cesium3DTileset
-    ) {
+    else if (target?.primitive instanceof Cesium.Cesium3DTileset) {
       let layer = this._viewer
         .getLayers()
         .filter(item => item.layerId === target.primitive.layerId)[0]
     }
 
     // for Primitve
-    else if (target && target.primitive) {
+    else if (target?.primitive) {
       let layer = this._viewer
         .getLayers()
         .filter(item => item.layerId === target.primitive.layerId)[0]
           wgs84Position: self._wgs84Position,
           surfacePosition: self._surfacePosition,
           wgs84SurfacePosition: self._wgs84SurfacePosition,
-          overlay: self._overlay
+          overlay: self._overlay,
+          instanceId: self._instanceId
         })
         self.hide()
       }

packages/core/src/components.js

   ElecEllipsoidPrimitive,
   FlowLinePrimitive,
   LabelPrimitive,
+  ModelCollectionPrimitive,
   ModelPrimitive,
   PointPrimitive,
   PolylinePrimitive,
   ElecEllipsoidPrimitive,
   FlowLinePrimitive,
   LabelPrimitive,
+  ModelCollectionPrimitive,
   ModelPrimitive,
   PointPrimitive,
   PolylinePrimitive,