ts/src/hooks/entity.ts

import { reactive } from 'vue'
import { getMubiaoHisTraj } from '@/api/Mubiao'

const baseMap = new Map()
const mubiaoMap = new Map()
const mubiaoConicMap = new Map()
const satelliteMap = new Map()

const mbPayloadShowMap = reactive(new Map())
// const satDetectingPayloadMap = reactive(new Map())
// const satCommunicationPayloadMap = reactive(new Map())
const satellitePayloadShowMap = reactive(new Map())

export const useEntity = () => {
  return {
    baseMap,
    mubiaoMap,
    mubiaoConicMap,
    satelliteMap,
    mbPayloadShowMap,
    // satDetectingPayloadMap,
    // satCommunicationPayloadMap,
    satellitePayloadShowMap,
    showEntity,
    getHisTraj,
    getMBEntityOpt,
    createMBConicSensor,
    iconOrModel,
    changeIconOrModel,
    showOrHideLoad,
    changeShowOrHideLoad,
  }
}

function showEntity(show: boolean) {
  ;[...mubiaoMap.values()].forEach(entity => {
    entity.show = show
  })
}

async function getHisTraj({
  id,
  timeRange,
}: {
  id: string
  timeRange: string[]
}) {
  const [timeBegin, timeEnd] = timeRange
  const { code, data: result } = await getMubiaoHisTraj({
    target_id: id,
    timeBegin,
    timeEnd,
  })
  if (code !== '200') {
    return
  }

  const timeArray = result.map(item => {
    return new Date(item.time).getTime()
  })
  const posArray = result.map(item => item.position).flat(Infinity)
  const points = result.reduce<TPoints>((acc, point, index, array) => {
    const { time, position } = point
    const cartesian3 = Cesium.Cartesian3.fromDegrees(...position)
    if (index === 0) {
      acc.push({ time: 0, position: cartesian3 })
    } else {
      acc.push({
        time:
          (new Date(time).getTime() - new Date(array[0].time).getTime()) / 1000,
        position: cartesian3,
      })
    }
    return acc
  }, [])

  return { points, posArray, timeArray }
}

function getMBEntityOpt({
  id,
  targetType,
  extendInfo,
}: {
  id: string
  targetType: string
  extendInfo?: { detectingPayload: Record<string, number> }
}) {
  const mubiaoDict = window.settings.mbDict[targetType]

  let ellipsoid
  if (extendInfo) {
    const {
      angle,
      maximumCone,
      minimumCone,
      minimumClock,
      maximumClock,
      radius,
    } = extendInfo.detectingPayload
    if (radius) {
      ellipsoid = {
        ellipsoid: {
          show: mbPayloadShowMap.get(id)?.detectingPayload?.show || false,
          radii: new Cesium.Cartesian3(radius, radius, radius),
          innerRadii: new Cesium.Cartesian3(1.0, 1.0, 1.0),
          maximumCone: Cesium.Math.toRadians(90),
          minimumCone: Cesium.Math.toRadians(minimumCone),
          minimumClock: Cesium.Math.toRadians(minimumClock),
          maximumClock: Cesium.Math.toRadians(maximumClock),
          material: Cesium.Color.fromCssColorString('#00dcff44'),
          outline: true,
          outlineColor: Cesium.Color.fromCssColorString('#00dcff'),
          outlineWidth: 1,
          distanceDisplayCondition: new Cesium.DistanceDisplayCondition(
            0.0,
            10.5e8
          ),
          slicePartitions: 24,
          stackPartitions: 36,
        },
      }
    }
  }
  return {
    label: {
      text: `${id}`,
      font: '12pt sans-serif',
      fillColor: Cesium.Color.YELLOW,
      outlineColor: Cesium.Color.BLACK,
      outlineWidth: 2,
      style: Cesium.LabelStyle.FILL_AND_OUTLINE,
      pixelOffset: new Cesium.Cartesian2(20, -20),
      pixelOffsetScaleByDistance: new Cesium.NearFarScalar(
        7000000,
        1.0,
        18000000,
        0.4
      ),
      scaleByDistance: new Cesium.NearFarScalar(7000000, 1.0, 18000000, 0.4),
    },
    billboard: {
      show: !iconOrModel.value,
      image: mubiaoDict.icon,
      width: 30,
      height: 30,
      color: Cesium.Color.fromCssColorString(mubiaoDict.color),
      scaleByDistance: new Cesium.NearFarScalar(7000000, 1.0, 18000000, 0.4),
    },
    model: {
      show: iconOrModel.value,
      uri: mubiaoDict.model,
      scale: 1000,
      minimumPixelSize: 50,
    },
    ...ellipsoid,
  }
}

function createMBConicSensor({
  entity,
  angle,
  show,
}: {
  entity: Cesium.Entity
  angle: number
  show: boolean
}) {
  console.log('entity', angle)
  const conicSensor = new CesiumSensorVolumes.ConicSensorGraphics({
    show,
    radius: 2e7,
    innerHalfAngle: 0,
    outerHalfAngle: Cesium.Math.toRadians(angle / 2),
    minimumClockAngle: 0,
    maximumClockAngle: 2 * Math.PI,
    showIntersection: true,
    intersectionColor: new Cesium.Color(1, 1, 1, 1),
    intersectionWidth: 3,
    lateralSurfaceMaterial: new Cesium.Color(0.0, 1.0, 1.0, 0.3),
  })
  const mbConic = viewer.entities.add({
    position: entity.position,
    orientation:
      entity.position &&
      Cesium.Transforms.headingPitchRollQuaternion(
        entity.position._value,
        new Cesium.HeadingPitchRoll(
          Cesium.Math.toRadians(90),
          0,
          Cesium.Math.toRadians(180)
        ) // 初始朝向
      ),
    conicSensor: conicSensor,
  })
  return mbConic
}

const iconOrModel = ref(false)
function changeIconOrModel() {
  iconOrModel.value = !iconOrModel.value
  ;[...mubiaoMap.values(), ...baseMap.values()].forEach(entity => {
    entity.model.show = !entity.model.show._value
    entity.billboard.show = !entity.billboard.show._value
  })
}

const showOrHideLoad = ref(false)

watch([mbPayloadShowMap, satellitePayloadShowMap], ([newMb, newSatellite]) => {
  ;[...newMb.keys()].forEach(key => {
    let show = false
    if (newMb.get(key).detectingPayload) {
      show = newMb.get(key).detectingPayload.show
    }
    if (mubiaoMap.has(key)) {
      // if(console.log(mubiaoMap.get(key).ellipsoid)
      mubiaoMap.get(key).ellipsoid && (mubiaoMap.get(key).ellipsoid.show = show)

      mubiaoConicMap.get(key)?.conicSensor &&
        (mubiaoConicMap.get(key).conicSensor.show = show)
    }
  })
  ;[...newSatellite.keys()].forEach(key => {
    let show = false
    if (newSatellite.get(key).detectingPayload) {
      show = newSatellite.get(key).detectingPayload.show
      // console.log(newSatellite.get(key).detectingPayload.show)
    }
    if (satelliteMap.has(key)) {
      satelliteMap.get(key).sensor = show
    }
  })
})
function changeShowOrHideLoad() {
  showOrHideLoad.value = !showOrHideLoad.value
  // ;[...mubiaoMap.values()].forEach(entity => {
  //   entity.ellipsoid.show = !entity.ellipsoid.show._value
  // })
  for (const [key] of mbPayloadShowMap.entries()) {
    mbPayloadShowMap.get(key).detectingPayload.show = showOrHideLoad.value
  }

  for (const [key] of satellitePayloadShowMap.entries()) {
    satellitePayloadShowMap.get(key).detectingPayload &&
      (satellitePayloadShowMap.get(key).detectingPayload.show =
        showOrHideLoad.value)
    satellitePayloadShowMap.get(key).communicationPayload &&
      (satellitePayloadShowMap.get(key).communicationPayload.show =
        showOrHideLoad.value)
  }
  // ;[...satelliteMap.values()].forEach(satellite => {
  //   satellite.sensor = showOrHideLoad.value
  // })
}