mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 16:52:20 +00:00
Every aircraft model (Flights, Military Flights, Local ADS-B) mixed 94% of a flat class colour over its mesh, so airliners drew as white silhouettes and military ones as amber. Models now use HIGHLIGHT: white leaves the mesh's own colours as built, and the tracked and emergency colours tint the mesh without hiding its paint. The IR boost still draws them flat white.
300 lines
9.7 KiB
JavaScript
300 lines
9.7 KiB
JavaScript
import * as Cesium from 'cesium';
|
|
import { horizonOccluder } from '../../data/iconOrientation.js';
|
|
import { selectModelEligible } from '../../data/modelEligibility.js';
|
|
import { aircraftLayerModelSpec } from '../flights/modelSpec.js';
|
|
import { createFleetModel } from '../../data/fleetModelInstances.js';
|
|
import { loadFleetModelSet } from '../../data/fleetModels.js';
|
|
import {
|
|
FLEET_DR_INTERVAL_MS,
|
|
MODEL_ALL_ADD_M,
|
|
MODEL_ALL_KEEP_M,
|
|
MODEL_ALT_CEIL_M,
|
|
MODEL_HEADING_OFFSET_DEG,
|
|
MODEL_MAX,
|
|
MODEL_MAX_ALL,
|
|
MODEL_MIN_PX,
|
|
MODEL_PROX_ADD_M,
|
|
MODEL_PROX_KEEP_M,
|
|
} from '../flights/policy.js';
|
|
import {
|
|
AIRCRAFT_ENVIRONMENT_MAP_OPTIONS,
|
|
aircraftModelBlend,
|
|
} from '../../data/aircraftModelLighting.js';
|
|
|
|
const specOf = (marker) =>
|
|
aircraftLayerModelSpec({
|
|
typeCode: marker?.typeCode,
|
|
category: marker?.category,
|
|
callsign: marker?.record?.callsign,
|
|
});
|
|
|
|
/**
|
|
* 3D models for Local ADS-B aircraft under the DISPLAY rail's 3D toggle.
|
|
*
|
|
* Mirrors the public Flights fleet: models only below the altitude ceiling,
|
|
* the same proximity/all caps and add/keep radii, the same visible-first
|
|
* eligibility (`selectModelEligible`), the same fleet model per type, life
|
|
* size (`aircraftLayerModelSpec`) and the same colours: the mesh's own
|
|
* (`aircraftModelBlend`). Each model owns its matrix. A
|
|
* billboard stays the visual until its model is loaded AND placed; a grounded
|
|
* aircraft's model rides the one-shot ground snap plus the class belly
|
|
* offset, and without a resolved ground it stays a billboard. Every fleet
|
|
* model loads once, up front, when the layer starts (`loadFleetModelSet`).
|
|
* @param {object} options
|
|
* @param {object} options.viewer Cesium viewer.
|
|
* @param {(url: string) => string} options.resolveAsset
|
|
* @param {object|null} [options.groundSnap] `createGroundSnap()` instance.
|
|
* @param {(options: object) => Promise<object>} [options.loadModel]
|
|
* @returns {object}
|
|
*/
|
|
export function createLocalAdsbModels({
|
|
viewer,
|
|
resolveAsset,
|
|
groundSnap = null,
|
|
loadModel = (options) => Cesium.Model.fromGltfAsync(options),
|
|
}) {
|
|
void loadFleetModelSet({ resolveAsset }).catch(() => {
|
|
/* aircraft stay billboards */
|
|
});
|
|
const collection = new Cesium.PrimitiveCollection();
|
|
viewer.scene.primitives.add(collection);
|
|
/** @type {Map<string, object>} id -> admitted model */
|
|
const models = new Map();
|
|
/** @type {Map<string, number>} id -> generation of an in-flight load */
|
|
const pending = new Map();
|
|
let generation = 0;
|
|
let destroyed = false;
|
|
let lastEligibilityAt = 0;
|
|
let eligible = new Set();
|
|
const scratchHpr = new Cesium.HeadingPitchRoll();
|
|
const scratchSphere = new Cesium.BoundingSphere(Cesium.Cartesian3.ZERO, 1);
|
|
const scratchCarto = new Cesium.Cartographic();
|
|
const scratchGround = new Cesium.Cartesian3();
|
|
|
|
function release(id) {
|
|
pending.delete(id);
|
|
const model = models.get(id);
|
|
if (!model) return;
|
|
models.delete(id);
|
|
if (!collection.isDestroyed()) collection.remove(model);
|
|
groundSnap?.forget?.(id);
|
|
}
|
|
|
|
function releaseAll() {
|
|
for (const id of [...models.keys()]) release(id);
|
|
pending.clear();
|
|
generation += 1;
|
|
}
|
|
|
|
async function ensure(id, marker, cap) {
|
|
const spec = specOf(marker);
|
|
if (!spec.model) return;
|
|
const key = spec.key;
|
|
const current = models.get(id);
|
|
if (current && current._gevSpecKey === key) return;
|
|
if (current) release(id);
|
|
if (pending.has(id) || models.size + pending.size >= cap) return;
|
|
const loadGeneration = generation;
|
|
pending.set(id, loadGeneration);
|
|
let model;
|
|
try {
|
|
model = await createFleetModel(
|
|
spec,
|
|
{
|
|
asynchronous: false,
|
|
environmentMapOptions: AIRCRAFT_ENVIRONMENT_MAP_OPTIONS,
|
|
minimumPixelSize: MODEL_MIN_PX,
|
|
scale: spec.scale,
|
|
color: Cesium.Color.WHITE,
|
|
...aircraftModelBlend(false),
|
|
id,
|
|
},
|
|
{ resolveAsset, load: loadModel },
|
|
);
|
|
} catch {
|
|
if (pending.get(id) === loadGeneration) pending.delete(id);
|
|
return;
|
|
}
|
|
const stale =
|
|
destroyed ||
|
|
pending.get(id) !== loadGeneration ||
|
|
generation !== loadGeneration ||
|
|
!eligible.has(id) ||
|
|
models.has(id) ||
|
|
specOf(marker).key !== key;
|
|
if (pending.get(id) === loadGeneration) pending.delete(id);
|
|
if (stale) {
|
|
model.destroy?.();
|
|
return;
|
|
}
|
|
model.id = id;
|
|
model._gevSpecKey = key;
|
|
model._gevBellyM = spec.bellyM;
|
|
// Admitted, not yet the visual: placement turns it on.
|
|
model.show = false;
|
|
collection.add(model);
|
|
models.set(id, model);
|
|
}
|
|
|
|
function regime(preferences) {
|
|
if (!preferences?.models3d) return false;
|
|
const height = viewer.camera?.positionCartographic?.height ?? Infinity;
|
|
return height < MODEL_ALT_CEIL_M;
|
|
}
|
|
|
|
function refreshEligibility(markers, preferences) {
|
|
const all = preferences.models3dMode === 'all';
|
|
const cap = all ? MODEL_MAX_ALL : MODEL_MAX;
|
|
const addM = all ? MODEL_ALL_ADD_M : MODEL_PROX_ADD_M;
|
|
const keepM = all ? MODEL_ALL_KEEP_M : MODEL_PROX_KEEP_M;
|
|
const camera = viewer.camera;
|
|
const cameraPosition = camera.positionWC;
|
|
const cull = camera.frustum.computeCullingVolume(
|
|
cameraPosition,
|
|
camera.directionWC,
|
|
camera.upWC,
|
|
);
|
|
const candidates = [];
|
|
for (const [id, marker] of markers) {
|
|
if (!marker.position) continue;
|
|
const distanceSq = Cesium.Cartesian3.distanceSquared(
|
|
cameraPosition,
|
|
marker.position,
|
|
);
|
|
if (distanceSq > keepM * keepM) continue;
|
|
Cesium.Cartesian3.clone(marker.position, scratchSphere.center);
|
|
candidates.push([
|
|
id,
|
|
distanceSq,
|
|
cull.computeVisibility(scratchSphere) !== Cesium.Intersect.OUTSIDE,
|
|
]);
|
|
}
|
|
candidates.sort((a, b) => a[1] - b[1]);
|
|
eligible = selectModelEligible(candidates, {
|
|
cap,
|
|
addDistSq: addM * addM,
|
|
isModeled: (id) => models.has(id),
|
|
});
|
|
for (const id of [...models.keys(), ...pending.keys()])
|
|
if (!eligible.has(id)) release(id);
|
|
for (const id of eligible) void ensure(id, markers.get(id), cap);
|
|
}
|
|
|
|
function placement(id, marker) {
|
|
if (!marker.onGround) return marker.position;
|
|
const model = models.get(id);
|
|
// The vertical sample must hit the tile skin, not this aircraft's own
|
|
// billboard or model.
|
|
const height = groundSnap?.heightFor?.(viewer, id, marker.position, () =>
|
|
[marker.entity, model].filter(Boolean),
|
|
);
|
|
if (!Number.isFinite(height)) return null;
|
|
const carto = Cesium.Cartographic.fromCartesian(
|
|
marker.position,
|
|
Cesium.Ellipsoid.WGS84,
|
|
scratchCarto,
|
|
);
|
|
return Cesium.Cartesian3.fromRadians(
|
|
carto.longitude,
|
|
carto.latitude,
|
|
height + (model?._gevBellyM || 0),
|
|
Cesium.Ellipsoid.WGS84,
|
|
scratchGround,
|
|
);
|
|
}
|
|
|
|
return {
|
|
/** Ids whose model admission is current; the layer enriches these. */
|
|
get eligible() {
|
|
return eligible;
|
|
},
|
|
|
|
/**
|
|
* Per-frame pass: re-derive eligibility at the fleet cadence, then place
|
|
* every admitted model and hand each marker's visual to its model only
|
|
* once the model is ready and placed.
|
|
* @param {Map<string, object>} markers Layer markers (position, courseDeg,
|
|
* klass, onGround); `modelOwnsVisual` is written back.
|
|
* @param {object} preferences `{ models3d, models3dMode }`.
|
|
* @param {number} nowMs
|
|
*/
|
|
frame(markers, preferences, nowMs) {
|
|
if (destroyed) return;
|
|
if (!regime(preferences)) {
|
|
if (models.size || pending.size) releaseAll();
|
|
eligible = new Set();
|
|
for (const marker of markers.values()) marker.modelOwnsVisual = false;
|
|
return;
|
|
}
|
|
if (nowMs - lastEligibilityAt >= FLEET_DR_INTERVAL_MS) {
|
|
lastEligibilityAt = nowMs;
|
|
refreshEligibility(markers, preferences);
|
|
}
|
|
const occluder = horizonOccluder(viewer.camera);
|
|
for (const [id, marker] of markers) {
|
|
const model = models.get(id);
|
|
marker.modelOwnsVisual = false;
|
|
if (!model || !marker.position) continue;
|
|
const position = placement(id, marker);
|
|
if (!position || !occluder.isPointVisible(marker.position)) {
|
|
model.show = false;
|
|
continue;
|
|
}
|
|
scratchHpr.heading = Cesium.Math.toRadians(
|
|
(marker.courseDeg || 0) + MODEL_HEADING_OFFSET_DEG,
|
|
);
|
|
scratchHpr.pitch = 0;
|
|
scratchHpr.roll = 0;
|
|
Cesium.Transforms.headingPitchRollToFixedFrame(
|
|
position,
|
|
scratchHpr,
|
|
Cesium.Ellipsoid.WGS84,
|
|
undefined,
|
|
model.modelMatrix,
|
|
);
|
|
if (!model.ready) {
|
|
model.show = false;
|
|
continue;
|
|
}
|
|
model.show = true;
|
|
marker.modelOwnsVisual = true;
|
|
}
|
|
for (const id of [...models.keys()]) if (!markers.has(id)) release(id);
|
|
},
|
|
|
|
/**
|
|
* Drop the model, and any load still in flight, of every aircraft that
|
|
* is no longer a marker. The layer calls this whenever markers expire:
|
|
* the per-frame pass does not run once the last marker is gone.
|
|
* @param {Map<string, object>|Set<string>} live Current marker ids.
|
|
*/
|
|
retain(live) {
|
|
if (destroyed) return;
|
|
let dropped = false;
|
|
for (const id of [...models.keys(), ...pending.keys()]) {
|
|
if (live.has(id)) continue;
|
|
release(id);
|
|
eligible.delete(id);
|
|
dropped = true;
|
|
}
|
|
if (dropped) eligible = new Set(eligible);
|
|
},
|
|
|
|
/** Drop every model (3D off, layer disabled). */
|
|
clear: releaseAll,
|
|
|
|
/** Number of admitted models (tests and diagnostics). */
|
|
get size() {
|
|
return models.size;
|
|
},
|
|
|
|
destroy() {
|
|
destroyed = true;
|
|
releaseAll();
|
|
groundSnap?.clear?.();
|
|
if (!viewer.isDestroyed?.() && !collection.isDestroyed())
|
|
viewer.scene.primitives.remove(collection);
|
|
},
|
|
};
|
|
}
|