import * as Cesium from 'cesium'
|
import { getPointPositionsHeight } from './mapUtil'
|
|
const DEVICE_RANGE_MATERIAL_TYPE = 'DeviceRangeEllipsoid'
|
let deviceRangeMaterialRegistered = false
|
|
export const registerDeviceRangeMaterial = () => {
|
if (deviceRangeMaterialRegistered || !Cesium?.Material) return
|
deviceRangeMaterialRegistered = true
|
Cesium.Material._materialCache.addMaterial(DEVICE_RANGE_MATERIAL_TYPE, {
|
fabric: {
|
type: DEVICE_RANGE_MATERIAL_TYPE,
|
uniforms: {
|
color: new Cesium.Color(1.0, 0.0, 0.0, 0.7),
|
speed: 3.0,
|
globalAlpha: 0.9
|
},
|
source: `
|
uniform vec4 color;
|
uniform float speed;
|
uniform float globalAlpha;
|
|
czm_material czm_getMaterial(czm_materialInput materialInput)
|
{
|
czm_material material = czm_getDefaultMaterial(materialInput);
|
vec2 st = materialInput.st;
|
|
float time = fract(czm_frameNumber * speed / 1000.0);
|
|
if (st.t < 0.5) {
|
discard;
|
}
|
|
float alphaMars3D = abs(smoothstep(0.5, 1.0, fract(-st.t - time)));
|
alphaMars3D += 0.1;
|
|
material.alpha = alphaMars3D * globalAlpha;
|
material.diffuse = color.rgb;
|
|
return material;
|
}
|
`,
|
},
|
translucent: () => true,
|
})
|
}
|
|
export const createDeviceRangeMaterial = () => {
|
registerDeviceRangeMaterial()
|
return Cesium.Material.fromType(DEVICE_RANGE_MATERIAL_TYPE, {
|
color: Cesium.Color.fromBytes(0, 255, 255, 155),
|
})
|
}
|
|
export const getDeviceLngLat = device => {
|
const lngRaw = device?.longitude ?? device?.lng ?? device?.lon
|
const latRaw = device?.latitude ?? device?.lat
|
const lng = Number(lngRaw)
|
const lat = Number(latRaw)
|
if (!Number.isFinite(lng) || !Number.isFinite(lat)) return null
|
return { lng, lat }
|
}
|
|
export const normalizeDeviceRange = value => {
|
const range = Number(value)
|
if (!Number.isFinite(range) || range <= 0) return 2000
|
return range
|
}
|
|
export const resolveDeviceTerrainHeight = async (viewer, position) => {
|
if (!viewer || !position) return 0
|
const lng = position.lng ?? position.longitude
|
const lat = position.lat ?? position.latitude
|
if (!Number.isFinite(Number(lng)) || !Number.isFinite(Number(lat))) return 0
|
try {
|
const results = await getPointPositionsHeight([{ lng: Number(lng), lat: Number(lat) }], viewer)
|
const height = Number(results?.[0]?.ASL)
|
return Number.isFinite(height) ? height : 0
|
} catch (error) {
|
return 0
|
}
|
}
|
|
export const createDeviceRangePrimitiveWithHeight = (position, rangeMeters, height, material = null) => {
|
if (!position || !Number.isFinite(rangeMeters)) return null
|
const lng = position.lng ?? position.longitude
|
const lat = position.lat ?? position.latitude
|
if (!Number.isFinite(Number(lng)) || !Number.isFinite(Number(lat))) return null
|
const center = Cesium.Cartesian3.fromDegrees(Number(lng), Number(lat), Number(height) || 0)
|
const radii = new Cesium.Cartesian3(rangeMeters, rangeMeters, rangeMeters)
|
const geometry = new Cesium.EllipsoidGeometry({
|
radii,
|
vertexFormat: Cesium.MaterialAppearance.MaterialSupport.TEXTURED?.vertexFormat
|
|| Cesium.VertexFormat.POSITION_AND_NORMAL,
|
})
|
const instance = new Cesium.GeometryInstance({
|
geometry,
|
modelMatrix: Cesium.Transforms.eastNorthUpToFixedFrame(center),
|
})
|
return new Cesium.Primitive({
|
geometryInstances: instance,
|
appearance: new Cesium.MaterialAppearance({
|
material: material || createDeviceRangeMaterial(),
|
closed: true,
|
translucent: true,
|
flat: true,
|
faceForward: true,
|
}),
|
asynchronous: false
|
})
|
}
|
|
export const createDeviceRangePrimitive = async (viewer, position, rangeMeters, material = null) => {
|
if (!viewer) return null
|
const height = await resolveDeviceTerrainHeight(viewer, position)
|
return createDeviceRangePrimitiveWithHeight(position, rangeMeters, height, material)
|
}
|
