mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
Task 12a. The Local ADS-B logic (index.js, models.js) no longer imports
Cesium. src/layers/localAdsb/render/cesium.js holds what it built, one
for one: the CustomDataSource of marker entities (billboard with
per-frame position/rotation/visibility CallbackProperties, the 2,000 km
DistanceDisplayCondition, the 978 MHz UAT ring as a PointGraphics), the
model PrimitiveCollection (models load, pose and leave through the shared
aircraft renderer's model part, adopting that collection), the selected
aircraft's trail (data/trailRenderer, as before) and live head segment,
and the camera reads. Registered for 'local-adsb' in the renderer
registry, created at init(viewer, {engine}).
- Clicks go through the engine's selection dispatcher (drill 8) instead of
the layer's ScreenSpaceEventHandler, with the layer's own rule kept as is
— a new `lookUnder` owner kind: its marker on top, or under picks no
layer owns and under trail lines, is selected (and re-selected);
another layer's contact on top, or empty map, releases only its own
selection; a trail line alone does nothing; no gesture rule. To the
other owners it is another layer, as its pick-owner registration made
it before. (The dispatcher's `drillThrough` would have taken the marker
from under another layer's contact, which the old handler never did.)
- models.js reads the camera through the renderer's view (frustum and
horizon tests, ground snap owner) and draws through renderer.models
(loadFleet/add/remove/destroy/setPose: the same MIX-tinted glTF options,
the same HPR frame with the Flights nose offset). The shared aircraft
renderer gains a loadModel seam (default Cesium.Model.fromGltfAsync).
- Cesium math → src/geo; the model tint is an Rgba equal to the old
Cesium.Color; check-import-directions: src/layers/localAdsb/ joins the
rendered layers.
Tests moved with the code, same meaning:
- index.test: the services fixture creates the layer's Cesium renderer and
the selection dispatcher; the click harness scripts the picks on a fake
engine registered for the fake viewer (was a fake ScreenSpaceEventHandler)
and the app's pick owners (trails, a Flights contact) are registered in
the pick registry (was an injected picking service).
- cockpitModels.test: the GLB loads are the aircraft renderer's loadModel
calls (Cesium.Model.fromGltfAsync by default), each asynchronous:false.
- trackingClickGesture.test: the dispatcher's empty click goes to the
plain owners (filter(plain)).
- renderers.test: local-adsb has an extracted Cesium renderer.
New: the dispatcher's look-under rule beside a plain owner (7 click cases).
W1 replay (flights, military, localAdsb) vs a fresh 7c7422e2 run: counts,
known objects, screen points, tracking poses, requests and every shot's
sha256 identical.
139 lines
5.7 KiB
JavaScript
139 lines
5.7 KiB
JavaScript
// Which engine draws which layer: the layer renderer registry (plan, "layer
|
|
// renderer interface") and the layer availability API built on it.
|
|
//
|
|
// A renderer factory `(engine, options) => renderer` draws one layer on one
|
|
// engine kind (`render/cesium.js`, `render/navara.js` of a layer). Cesium
|
|
// layers still draw themselves until their render/cesium.js is extracted
|
|
// (the *a tasks): they are registered as CESIUM_BUILTIN. Cesium entries are
|
|
// registered here, statically (main chunk); Navara factories are registered
|
|
// by the Navara mode after its import() (src/app/navaraMode.js).
|
|
//
|
|
// ## Layer availability (stable API, used by phase 4's layer list)
|
|
//
|
|
// import { createLayerAvailability } from './app/layers/renderers.js';
|
|
// const availability = createLayerAvailability(engine.kind);
|
|
// availability.engine // 'cesium' | 'navara'
|
|
// availability.isAvailable(id) // can this engine show layer `id`?
|
|
// availability.available() // [{ id, name }] in catalog order
|
|
// availability.unavailable() // [{ id, name }] the catalog leaves out
|
|
//
|
|
// The object is frozen; available() and unavailable() return fresh arrays.
|
|
// It reads the registry when called, so a Navara factory registered later
|
|
// (after the Navara mode loads) shows up. `name` is the layer's display name
|
|
// (src/app/layers/directory.js). Phase 4 injects it as its `availability`
|
|
// provider (`{ engine, unavailable() }` is the part it reads).
|
|
|
|
import { APPLICATION_LAYER_DIRECTORY } from './directory.js';
|
|
import { createFlightsCesiumRenderer } from '../../layers/flights/render/cesium.js';
|
|
import { createMilitaryCesiumRenderer } from '../../layers/military/render/cesium.js';
|
|
import { createLocalAdsbCesiumRenderer } from '../../layers/localAdsb/render/cesium.js';
|
|
|
|
const ENGINE_KINDS = new Set(['cesium', 'navara']);
|
|
|
|
/** The layer draws itself on Cesium (no separate renderer yet). */
|
|
export const CESIUM_BUILTIN = Object.freeze({ builtin: 'cesium' });
|
|
|
|
const isFactory = (value) =>
|
|
typeof value === 'function' || value === CESIUM_BUILTIN;
|
|
|
|
/** A registry of layer renderers per engine kind. */
|
|
export function createRendererRegistry() {
|
|
const byEngine = new Map();
|
|
const entries = (engineKind) => byEngine.get(engineKind) ?? new Map();
|
|
return {
|
|
/** Adds `{ [layerId]: factory }` for an engine kind; one per layer. */
|
|
register(engineKind, factories) {
|
|
if (typeof engineKind !== 'string' || !engineKind)
|
|
throw new TypeError('registerLayerRenderers needs an engine kind');
|
|
let map = byEngine.get(engineKind);
|
|
if (!map) byEngine.set(engineKind, (map = new Map()));
|
|
for (const [layerId, factory] of Object.entries(factories ?? {})) {
|
|
if (!isFactory(factory))
|
|
throw new TypeError(
|
|
`Layer renderer for ${layerId} on ${engineKind} is not a factory`,
|
|
);
|
|
if (map.has(layerId))
|
|
throw new Error(
|
|
`Layer ${layerId} already has a renderer on ${engineKind}`,
|
|
);
|
|
map.set(layerId, factory);
|
|
}
|
|
},
|
|
/**
|
|
* The renderer of a layer on `engine` (factory(engine, options)), or null
|
|
* when the engine has none or the layer still draws itself (Cesium).
|
|
*/
|
|
rendererFor(layerId, engine, options = {}) {
|
|
const factory = entries(engine?.kind).get(layerId);
|
|
return typeof factory === 'function' ? factory(engine, options) : null;
|
|
},
|
|
layerAvailableOn: (layerId, engineKind) => entries(engineKind).has(layerId),
|
|
availableIds: (engineKind) => [...entries(engineKind).keys()],
|
|
};
|
|
}
|
|
|
|
const defaultRegistry = createRendererRegistry();
|
|
|
|
/** Registers layer renderers on the application's registry. */
|
|
export const registerLayerRenderers = (engineKind, factories) =>
|
|
defaultRegistry.register(engineKind, factories);
|
|
/** The application registry's renderer of a layer on an engine, or null. */
|
|
export const rendererFor = (layerId, engine, options) =>
|
|
defaultRegistry.rendererFor(layerId, engine, options);
|
|
/** Whether the application can show a layer on an engine kind. */
|
|
export const layerAvailableOn = (layerId, engineKind) =>
|
|
defaultRegistry.layerAvailableOn(layerId, engineKind);
|
|
|
|
/** Cesium renderers extracted from their layers (render/cesium.js). */
|
|
export const CESIUM_LAYER_RENDERERS = Object.freeze({
|
|
flights: createFlightsCesiumRenderer,
|
|
military: createMilitaryCesiumRenderer,
|
|
'local-adsb': createLocalAdsbCesiumRenderer,
|
|
});
|
|
|
|
// The other application layers still draw themselves on Cesium.
|
|
registerLayerRenderers(
|
|
'cesium',
|
|
Object.fromEntries(
|
|
APPLICATION_LAYER_DIRECTORY.map(({ id }) => [
|
|
id,
|
|
CESIUM_LAYER_RENDERERS[id] ?? CESIUM_BUILTIN,
|
|
]),
|
|
),
|
|
);
|
|
|
|
/**
|
|
* @typedef {object} LayerAvailability
|
|
* @property {'cesium' | 'navara'} engine
|
|
* @property {(layerId: string) => boolean} isAvailable
|
|
* @property {() => { id: string, name: string }[]} available
|
|
* @property {() => { id: string, name: string }[]} unavailable
|
|
*/
|
|
|
|
/**
|
|
* The layers an engine kind can show (stable API; see the module comment).
|
|
* @param {'cesium' | 'navara'} engineKind
|
|
* @param {{ registry?: object, directory?: { id: string, name: string }[] }} [options]
|
|
* Test seams: the registry and the layer directory.
|
|
* @returns {LayerAvailability}
|
|
*/
|
|
export function createLayerAvailability(
|
|
engineKind,
|
|
{ registry = defaultRegistry, directory = APPLICATION_LAYER_DIRECTORY } = {},
|
|
) {
|
|
if (!ENGINE_KINDS.has(engineKind))
|
|
throw new TypeError(`Unknown engine kind for layers: ${engineKind}`);
|
|
const isAvailable = (layerId) =>
|
|
registry.layerAvailableOn(layerId, engineKind);
|
|
const rows = (wanted) =>
|
|
directory
|
|
.filter(({ id }) => isAvailable(id) === wanted)
|
|
.map(({ id, name }) => ({ id, name }));
|
|
return Object.freeze({
|
|
engine: engineKind,
|
|
isAvailable,
|
|
available: () => rows(true),
|
|
unavailable: () => rows(false),
|
|
});
|
|
}
|