Files
gods-eye-view/mobile/ui/globeStub.js
T

1856 lines
53 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* Offline stand-in for mobile/globe (DESIGN.md §10 Globe API contract).
*
* A WebGL2 orthographic planet: Esri World Imagery day mosaic, NASA Black
* Marble night lights blended across the real terminator, an atmosphere rim,
* and a sharper Esri export for the view when you descend. Contacts and
* situations are SIMULATED so the shell is always demoable; every card and
* pick from this engine says so.
*/
import { esriThumb } from './dom.js';
const R_EARTH = 6371008.8;
const D2R = Math.PI / 180;
const R2D = 180 / Math.PI;
const FOV_HALF = Math.tan(20 * D2R);
const MIN_H = 60e3;
const MAX_H = 42000e3;
const HOME = { lon: 20, lat: 18, height: 15500e3 };
const SIM = 'Simulated · offline stub engine';
const DAY_URL =
'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=-180,-90,180,90&bboxSR=4326&imageSR=4326&size=4096,2048&format=jpg&f=image';
const NIGHT_URL =
'https://gibs.earthdata.nasa.gov/wms/epsg4326/best/wms.cgi?SERVICE=WMS&REQUEST=GetMap&VERSION=1.3.0&LAYERS=VIIRS_Black_Marble&STYLES=&CRS=EPSG:4326&BBOX=-90,-180,90,180&WIDTH=2048&HEIGHT=1024&FORMAT=image/jpeg';
/* ------------------------------------------------------------------ */
/* Catalog (DESIGN.md §8) */
/* ------------------------------------------------------------------ */
const CATALOG = {
sky: [
'Commercial flights',
'Military aircraft',
'Helicopters',
'Private / GA',
'Emergency squawks',
'Drones (Remote ID)',
'Airport boards',
'Holding patterns',
],
sea: [
'AIS vessels',
'Ports',
'Tankers / cargo',
'Fishing effort',
'Dark vessels',
'Submarine cables',
],
orbit: [
'Satellites (TLE)',
'ISS & crewed',
'Starlink trains',
'Launches',
'Debris',
'Ground tracks',
],
hazards: [
'Earthquakes',
'Active fires',
'Fire perimeters',
'Floods',
'Tropical cyclones',
'Volcanoes',
'Air quality',
],
eyes: [
'Public CCTV',
'Signed captures',
'Street-level',
'Holograms',
'Live streams',
],
ground: [
'Transit vehicles',
'Traffic flow',
'Bike share',
'Rail',
'Events & venues',
'ALPR cameras',
],
weather: ['Radar', 'Clouds', 'Lightning', 'Wind', 'Forecast models'],
infra: [
'Datacenters',
'Dams',
'Power plants',
'Military installations',
'GNSS interference',
'Recent imagery',
],
};
const slug = (s) =>
s
.toLowerCase()
.replace(/[^a-z0-9]+/g, '-')
.replace(/(^-|-$)/g, '');
const DEFAULT_ON = new Set([
'sky.commercial-flights',
'sky.helicopters',
'sea.ais-vessels',
'orbit.iss-crewed',
'orbit.satellites-tle',
'hazards.earthquakes',
'hazards.active-fires',
'hazards.tropical-cyclones',
'hazards.floods',
]);
/* ------------------------------------------------------------------ */
/* Deterministic randomness */
/* ------------------------------------------------------------------ */
function rng(seed) {
let s = seed >>> 0;
return () => {
s = (s + 0x6d2b79f5) >>> 0;
let t = s;
t = Math.imul(t ^ (t >>> 15), t | 1);
t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
};
}
/* ------------------------------------------------------------------ */
/* Geometry */
/* ------------------------------------------------------------------ */
function toVec(lon, lat) {
const cl = Math.cos(lat * D2R);
return [
cl * Math.cos(lon * D2R),
cl * Math.sin(lon * D2R),
Math.sin(lat * D2R),
];
}
const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
function haversine(lon1, lat1, lon2, lat2) {
const dLat = (lat2 - lat1) * D2R;
const dLon = (lon2 - lon1) * D2R;
const a =
Math.sin(dLat / 2) ** 2 +
Math.cos(lat1 * D2R) * Math.cos(lat2 * D2R) * Math.sin(dLon / 2) ** 2;
return 2 * R_EARTH * Math.asin(Math.min(1, Math.sqrt(a)));
}
function destination(lon, lat, bearingDeg, distM) {
const d = distM / R_EARTH;
const b = bearingDeg * D2R;
const p1 = lat * D2R;
const l1 = lon * D2R;
const p2 = Math.asin(
Math.sin(p1) * Math.cos(d) + Math.cos(p1) * Math.sin(d) * Math.cos(b),
);
const l2 =
l1 +
Math.atan2(
Math.sin(b) * Math.sin(d) * Math.cos(p1),
Math.cos(d) - Math.sin(p1) * Math.sin(p2),
);
return [((l2 * R2D + 540) % 360) - 180, p2 * R2D];
}
function subsolar(date) {
const start = Date.UTC(date.getUTCFullYear(), 0, 0);
const doy = (date.getTime() - start) / 86400000;
const decl = 23.44 * Math.sin(((2 * Math.PI) / 365) * (doy - 81));
const hours =
date.getUTCHours() +
date.getUTCMinutes() / 60 +
date.getUTCSeconds() / 3600;
const lon = -(hours - 12) * 15;
return toVec(lon, decl);
}
/* ------------------------------------------------------------------ */
/* Simulated world */
/* ------------------------------------------------------------------ */
const HUBS = [
[-84.43, 33.64],
[-87.9, 41.98],
[-0.45, 51.47],
[55.36, 25.25],
[139.78, 35.55],
[2.55, 49.01],
[8.57, 50.04],
[103.99, 1.36],
[-118.41, 33.94],
[-73.78, 40.64],
[-122.38, 37.62],
[77.1, 28.56],
[151.18, -33.94],
[-46.47, -23.43],
[28.75, 41.26],
[4.76, 52.31],
[126.45, 37.46],
[114.2, 22.3],
[-99.07, 19.44],
[18.6, -33.97],
];
const PORTS = [
[32.55, 29.9, 'Suez approach'],
[103.85, 1.22, 'Singapore Strait'],
[4.05, 51.95, 'Maasvlakte'],
[-122.5, 37.79, 'Golden Gate'],
[-5.6, 35.95, 'Gibraltar'],
[121.6, 31.2, 'Yangshan'],
[-79.7, 9.2, 'Panama'],
[56.3, 26.4, 'Hormuz'],
];
const PREFIX = ['AEX', 'NVA', 'PLR', 'HLX', 'TRN', 'KTX', 'ORV', 'SNW'];
const SHIP = [
'Aster',
'Nordlys',
'Kestrel',
'Meridian',
'Halcyon',
'Sable',
'Tern',
'Cobalt',
'Brightwater',
'Pelagia',
];
function buildContacts() {
const r = rng(7);
const out = [];
HUBS.forEach(([lon, lat], hi) => {
for (let i = 0; i < 34; i += 1) {
const [x, y] = destination(lon, lat, r() * 360, 20e3 + r() * 900e3);
out.push({
kind: 'aircraft',
layer: 'sky.commercial-flights',
id: `ac-${hi}-${i}`,
title: `${PREFIX[(hi + i) % PREFIX.length]}${100 + Math.floor(r() * 8900)}`,
lon: x,
lat: y,
altM: 2500 + r() * 9800,
headingDeg: r() * 360,
speed: 170 + r() * 90,
});
}
});
for (let i = 0; i < 23; i += 1) {
const [x, y] = destination(-85.72, 31.36, r() * 360, 3e3 + r() * 18e3);
out.push({
kind: 'helicopter',
layer: 'sky.helicopters',
id: `heli-${i}`,
title: `ARMY ${String(20000 + Math.floor(r() * 900))}`,
lon: x,
lat: y,
altM: 150 + r() * 300,
headingDeg: r() * 360,
speed: 45 + r() * 20,
circuit: true,
});
}
for (let i = 0; i < 14; i += 1) {
const [x, y] = destination(3.5, 55.5, r() * 360, r() * 260e3);
out.push({
kind: 'aircraft',
layer: 'sky.military-aircraft',
id: `mil-${i}`,
title: `RCH${300 + i}`,
lon: x,
lat: y,
altM: 6000 + r() * 4000,
headingDeg: r() * 360,
speed: 190,
});
}
PORTS.forEach(([lon, lat], pi) => {
for (let i = 0; i < 26; i += 1) {
const [x, y] = destination(lon, lat, r() * 360, r() * 60e3);
out.push({
kind: 'ship',
layer: 'sea.ais-vessels',
id: `ship-${pi}-${i}`,
title: `${SHIP[(pi * 3 + i) % SHIP.length]} ${['Star', 'Spirit', 'Trader', 'Bay', 'Venture', 'Dawn', 'Pioneer'][(i + pi) % 7]}${i >= 10 ? ` ${['II', 'III', 'IV'][i % 3]}` : ''}`,
lon: x,
lat: y,
altM: 0,
headingDeg: r() * 360,
speed: r() < 0.6 ? 0.3 : 6 + r() * 6,
});
}
});
const sats = [
{
id: 'iss',
title: 'ISS (ZARYA)',
layer: 'orbit.iss-crewed',
inc: 51.6,
alt: 418e3,
raan: 40,
phase: 0,
},
];
for (let i = 0; i < 48; i += 1) {
sats.push({
id: `sat-${i}`,
title: i < 18 ? `STARLINK-${31000 + i * 7}` : `SAT-${40000 + i * 113}`,
layer: 'orbit.satellites-tle',
inc: i < 18 ? 53 : 45 + r() * 53,
alt: i < 18 ? 550e3 : 480e3 + r() * 800e3,
raan: i < 18 ? 120 : r() * 360,
phase: i < 18 ? i * 3.2 : r() * 360,
});
}
sats.forEach((s) =>
out.push({
kind: 'satellite',
layer: s.layer,
id: s.id,
title: s.title,
orbit: s,
lon: 0,
lat: 0,
altM: s.alt,
headingDeg: 0,
}),
);
const quakes = [
[144.2, 42.1, 6.4],
[-70.9, -30.2, 5.1],
[27.8, 38.4, 4.6],
[-155.3, 19.4, 4.2],
[95.9, 2.9, 5.3],
];
quakes.forEach(([lon, lat, m], i) =>
out.push({
kind: 'quake',
layer: 'hazards.earthquakes',
id: `eq-${i}`,
title: `M${m.toFixed(1)}`,
lon,
lat,
altM: 0,
headingDeg: 0,
mag: m,
}),
);
for (let i = 0; i < 40; i += 1) {
const [x, y] = destination(-120.9, 39.0, r() * 360, r() * 90e3);
out.push({
kind: 'fire',
layer: 'hazards.active-fires',
id: `fire-${i}`,
title: 'FIRMS hotspot',
lon: x,
lat: y,
altM: 0,
headingDeg: 0,
});
}
return out;
}
function propagate(c, t0, t) {
if (c.kind === 'satellite') {
const o = c.orbit;
const mu = 3.986004418e14;
const a = R_EARTH + o.alt;
const n = Math.sqrt(mu / a ** 3);
const u = o.phase * D2R + n * (t / 1000);
const inc = o.inc * D2R;
const lat = Math.asin(Math.sin(inc) * Math.sin(u));
const lonI = Math.atan2(Math.cos(inc) * Math.sin(u), Math.cos(u));
const earth = 7.2921159e-5 * (t / 1000);
const lon = (((lonI + o.raan * D2R - earth) * R2D + 540) % 360) - 180;
c.lon = lon;
c.lat = lat * R2D;
c.headingDeg = 90 - o.inc * Math.cos(u);
return;
}
if (!c.speed) return;
const dt = (t - t0) / 1000;
if (!c.base) c.base = { lon: c.lon, lat: c.lat, h: c.headingDeg };
if (c.circuit) {
const w = c.speed / 2500;
const h = c.base.h + ((dt * w * R2D) % 360);
const [x, y] = destination(c.base.lon, c.base.lat, h, 2500);
c.lon = x;
c.lat = y;
c.headingDeg = (h + 90) % 360;
return;
}
const [x, y] = destination(c.base.lon, c.base.lat, c.base.h, c.speed * dt);
c.lon = x;
c.lat = y;
}
/* ------------------------------------------------------------------ */
/* Situations */
/* ------------------------------------------------------------------ */
function buildSituations(now) {
const min = 60e3;
const S = (o) => ({
live: true,
source: SIM,
updatedAt: now - (o.age ?? 2) * min,
time: o.time ?? { start: now - 6 * 3600e3, end: now + 24 * 3600e3 },
camera: o.camera ?? {
lon: o.lon,
lat: o.lat,
height: o.height ?? 400e3,
heading: 0,
pitch: -90,
},
thumbnail: esriThumb(o.lon, o.lat, o.span ?? 1, 480, o.th ?? 600),
...o,
});
return [
S({
id: 'cyclone-wpac',
kind: 'cyclone',
family: 'hazards',
title: 'Typhoon tracking toward Luzon',
subtitle: 'Category 4 · eyewall replacement under way',
place: 'Philippine Sea',
lon: 126.5,
lat: 15.4,
span: 9,
th: 640,
height: 2200e3,
layers: ['hazards.tropical-cyclones', 'weather.clouds', 'weather.wind'],
metrics: [
{ label: 'Wind', value: 185, unit: 'km/h' },
{ label: 'Pressure', value: 935, unit: 'hPa' },
{ label: 'Moving', value: 'WNW 18', unit: 'km/h' },
],
series: [120, 130, 140, 150, 165, 175, 185, 185, 180, 185],
age: 2,
time: { start: now - 72 * 3600e3, end: now + 120 * 3600e3 },
events: [{ at: now + 30 * 3600e3, label: 'Landfall (fcst)' }],
}),
S({
id: 'quake-24h',
kind: 'quake',
family: 'hazards',
title: 'M6.4 · largest quake in 24 h',
subtitle: 'Shallow thrust event, aftershocks continuing',
place: 'Off Hokkaido, Japan',
lon: 144.2,
lat: 42.1,
span: 3.5,
th: 480,
height: 900e3,
layers: ['hazards.earthquakes'],
metrics: [
{ label: 'Magnitude', value: 6.4, unit: 'Mw' },
{ label: 'Depth', value: 38, unit: 'km' },
{ label: 'Aftershocks', value: 27, unit: '' },
],
series: [0, 0, 6.4, 4.1, 3.8, 4.4, 3.2, 3.9, 3.1, 3.3],
age: 11,
events: [{ at: now - 14 * 3600e3, label: 'M6.4' }],
}),
S({
id: 'fires-sierra',
kind: 'fires',
family: 'hazards',
title: 'Fire cluster in the Sierra foothills',
subtitle: 'FIRMS hotspots doubling since dawn',
place: 'Nevada County, California',
lon: -120.9,
lat: 39.05,
span: 1.6,
th: 560,
height: 260e3,
layers: [
'hazards.active-fires',
'hazards.fire-perimeters',
'weather.wind',
],
metrics: [
{ label: 'Hotspots', value: 214, unit: '' },
{ label: 'FRP', value: 1840, unit: 'MW' },
{ label: 'Wind', value: 32, unit: 'km/h' },
],
series: [12, 18, 30, 44, 61, 88, 120, 160, 190, 214],
age: 4,
}),
S({
id: 'iss-pass',
kind: 'pass',
family: 'orbit',
title: 'ISS passes over you tonight',
subtitle: 'Bright pass · max elevation 71°',
place: 'Low Earth orbit',
lon: -40,
lat: 30,
span: 30,
th: 520,
height: 9000e3,
layers: ['orbit.iss-crewed', 'orbit.ground-tracks'],
metrics: [
{ label: 'Altitude', value: 418, unit: 'km' },
{ label: 'Speed', value: 27600, unit: 'km/h' },
{ label: 'Next pass', value: '21:42', unit: '' },
],
age: 1,
alwaysOn: true,
}),
S({
id: 'atl-rush',
kind: 'airport',
family: 'sky',
title: 'Busiest airport right now',
subtitle: 'Hartsfield–Jackson arrival bank',
place: 'Atlanta, Georgia',
lon: -84.428,
lat: 33.6407,
span: 0.09,
th: 600,
height: 18e3,
layers: [
'sky.commercial-flights',
'sky.holding-patterns',
'sky.airport-boards',
],
metrics: [
{ label: 'Movements', value: 182, unit: '/h' },
{ label: 'Holding', value: 6, unit: '' },
{ label: 'Delay', value: 14, unit: 'min' },
],
series: [120, 140, 166, 170, 182, 176, 181, 182],
age: 1,
alwaysOn: true,
}),
S({
id: 'novosel',
kind: 'heliport',
family: 'sky',
title: 'Helicopter school circuits',
subtitle: 'Rotor training pattern over Wiregrass',
place: 'Fort Novosel, Alabama',
lon: -85.72,
lat: 31.36,
span: 0.22,
th: 420,
height: 40e3,
layers: ['sky.helicopters'],
metrics: [
{ label: 'Airborne', value: 23, unit: 'rotorcraft' },
{ label: 'Pattern alt', value: 700, unit: 'ft' },
],
series: [4, 9, 14, 18, 23, 21, 23],
age: 3,
alwaysOn: true,
}),
S({
id: 'bhote-koshi-2026',
kind: 'reconstruction',
family: 'hazards',
title: 'Bhote Koshi outburst flood',
subtitle: '16 sourced observations · 3 open hypotheses',
place: 'Rasuwa, Nepal ↔ Gyirong, Tibet',
lon: 85.33,
lat: 28.15,
span: 0.3,
th: 640,
height: 30e3,
camera: {
lon: 85.3548,
lat: 28.207,
height: 14e3,
heading: 344,
pitch: -39,
},
layers: [
'hazards.floods',
'infra.recent-imagery',
'eyes.signed-captures',
],
metrics: [
{ label: 'Observations', value: 16, unit: '' },
{ label: 'Corridor', value: 145, unit: 'pts' },
{ label: 'Hypotheses', value: 3, unit: '' },
],
live: false,
age: 60 * 24 * 7,
source: 'GeoPera reconstruction · Vantor Open Data (CC BY-NC 4.0)',
time: { start: Date.UTC(2026, 7, 26, 0), end: Date.UTC(2026, 7, 27, 12) },
thread: 'bhote-koshi-2026',
thumbnail: '/events/bhote-koshi-2026/post.webp',
}),
S({
id: 'starbase',
kind: 'launch',
family: 'orbit',
title: 'Launch countdown · Starbase',
subtitle: 'Window opens 06:00 local · trajectory east',
place: 'Boca Chica, Texas',
lon: -97.157,
lat: 25.997,
span: 0.06,
th: 380,
height: 12e3,
layers: ['orbit.launches', 'orbit.ground-tracks'],
metrics: [
{ label: 'T−', value: '06:12:00', unit: '' },
{ label: 'Weather go', value: 80, unit: '%' },
],
age: 6,
events: [{ at: now + 6.2 * 3600e3, label: 'T-0' }],
}),
S({
id: 'suez-queue',
kind: 'queue',
family: 'sea',
title: 'Ships queuing at Suez',
subtitle: 'Southbound convoy holding in the anchorage',
place: 'Gulf of Suez, Egypt',
lon: 32.55,
lat: 29.88,
span: 0.35,
th: 560,
height: 60e3,
layers: ['sea.ais-vessels', 'sea.tankers-cargo'],
metrics: [
{ label: 'Waiting', value: 41, unit: 'vessels' },
{ label: 'Median wait', value: 19, unit: 'h' },
],
series: [28, 30, 33, 35, 39, 41],
age: 5,
}),
S({
id: 'gnss-baltic',
kind: 'gnss',
family: 'infra',
title: 'GNSS interference over the Baltic',
subtitle: 'Aircraft reporting degraded NIC',
place: 'Baltic Sea',
lon: 21.0,
lat: 56.5,
span: 6,
th: 480,
height: 1500e3,
layers: ['infra.gnss-interference', 'sky.commercial-flights'],
metrics: [
{ label: 'Affected', value: 312, unit: 'aircraft' },
{ label: 'Area', value: 84, unit: 'k km²' },
],
series: [120, 180, 240, 260, 300, 312],
age: 9,
}),
S({
id: 'singapore',
kind: 'strait',
family: 'sea',
title: 'Singapore Strait traffic',
subtitle: 'Eastbound lane at capacity',
place: 'Singapore Strait',
lon: 103.85,
lat: 1.22,
span: 0.4,
th: 420,
height: 70e3,
layers: ['sea.ais-vessels'],
metrics: [
{ label: 'Transits', value: 22, unit: '/h' },
{ label: 'At anchor', value: 318, unit: '' },
],
age: 3,
alwaysOn: true,
}),
S({
id: 'tokyo-rush',
kind: 'transit',
family: 'ground',
title: 'Rush hour · Tokyo rail',
subtitle: 'Yamanote line headways at 2 min 30 s',
place: 'Shinjuku, Tokyo',
lon: 139.7,
lat: 35.69,
span: 0.05,
th: 600,
height: 9e3,
layers: ['ground.transit-vehicles', 'ground.rail'],
metrics: [
{ label: 'Trains moving', value: 1840, unit: '' },
{ label: 'On time', value: 98.6, unit: '%' },
],
age: 2,
alwaysOn: true,
}),
S({
id: 'rotterdam',
kind: 'port',
family: 'sea',
title: 'Port of Rotterdam',
subtitle: 'Europe’s busiest port, always on',
place: 'Maasvlakte, Netherlands',
lon: 4.03,
lat: 51.96,
span: 0.12,
th: 380,
height: 30e3,
layers: ['sea.ais-vessels', 'sea.ports'],
metrics: [
{ label: 'Berthed', value: 96, unit: '' },
{ label: 'Arriving 6 h', value: 34, unit: '' },
],
age: 4,
alwaysOn: true,
}),
S({
id: 'north-sea-mil',
kind: 'military',
family: 'sky',
title: 'Military air activity · North Sea',
subtitle: 'Tanker tracks and fighter CAPs',
place: 'North Sea',
lon: 3.5,
lat: 55.5,
span: 5,
th: 520,
height: 900e3,
layers: ['sky.military-aircraft'],
metrics: [
{ label: 'Aircraft', value: 14, unit: '' },
{ label: 'Tankers', value: 3, unit: '' },
],
age: 7,
}),
S({
id: 'aurora',
kind: 'aurora',
family: 'weather',
title: 'Aurora nowcast · Tromsø',
subtitle: 'Kp 6 storm, clear skies after 22:00',
place: 'Tromsø, Norway',
lon: 18.95,
lat: 69.65,
span: 0.5,
th: 600,
height: 300e3,
layers: ['weather.clouds'],
metrics: [
{ label: 'Kp', value: 6, unit: '' },
{ label: 'Cloud', value: 20, unit: '%' },
],
series: [2, 3, 3, 4, 5, 6, 6],
age: 15,
}),
S({
id: 'sfo-arrivals',
kind: 'airport',
family: 'sky',
title: 'SFO arrivals on 28L/R',
subtitle: 'Paired approaches over the bay',
place: 'San Francisco, California',
lon: -122.379,
lat: 37.6213,
span: 0.12,
th: 480,
height: 25e3,
layers: ['sky.commercial-flights', 'sky.airport-boards'],
metrics: [
{ label: 'Arrivals', value: 44, unit: '/h' },
{ label: 'Delay', value: 9, unit: 'min' },
],
age: 2,
}),
S({
id: 'etna',
kind: 'volcano',
family: 'eyes',
title: 'Etna webcam vs ash advisory',
subtitle: 'Strombolian activity at the SE crater',
place: 'Sicily, Italy',
lon: 14.995,
lat: 37.751,
span: 0.2,
th: 420,
height: 30e3,
layers: ['hazards.volcanoes', 'eyes.public-cctv'],
metrics: [
{ label: 'Cameras', value: 4, unit: 'live' },
{ label: 'Ash FL', value: 120, unit: '' },
],
age: 13,
}),
S({
id: 'dxb',
kind: 'airport',
family: 'sky',
title: 'Dubai International night bank',
subtitle: 'Long-haul departures to Europe',
place: 'Dubai, UAE',
lon: 55.3657,
lat: 25.2532,
span: 0.1,
th: 560,
height: 25e3,
layers: ['sky.commercial-flights'],
metrics: [{ label: 'Departures', value: 61, unit: '/h' }],
age: 1,
alwaysOn: true,
}),
];
}
/* ------------------------------------------------------------------ */
/* WebGL planet */
/* ------------------------------------------------------------------ */
const VS = `#version 300 es
in vec2 p; void main(){ gl_Position = vec4(p,0.,1.); }`;
const FS = `#version 300 es
precision highp float;
uniform vec2 u_c; uniform float u_R; uniform vec2 u_res;
uniform vec3 u_right, u_up, u_fwd, u_sun;
uniform sampler2D u_day, u_night, u_det;
uniform vec4 u_box; uniform float u_detOn, u_tex, u_lens, u_nightTex, u_close;
out vec4 o;
const float PI = 3.14159265;
float hash(vec2 p){ return fract(sin(dot(p, vec2(127.1,311.7)))*43758.5453); }
vec4 sampleEq(sampler2D t, vec2 uv){
vec2 uv2 = vec2(fract(uv.x+0.5), uv.y);
vec2 dx1 = dFdx(uv), dy1 = dFdy(uv), dx2 = dFdx(uv2), dy2 = dFdy(uv2);
vec2 dx = abs(dx1.x) < abs(dx2.x) ? dx1 : dx2;
vec2 dy = abs(dy1.x) < abs(dy2.x) ? dy1 : dy2;
return textureGrad(t, uv, dx, dy);
}
void main(){
vec2 f = gl_FragCoord.xy;
vec2 p = (f - u_c) / u_R;
float r2 = dot(p,p);
vec3 col;
if (r2 > 1.0) {
float r = sqrt(r2);
float k = (r - 1.0) * u_R / (u_R * 0.045 + 5.0);
float halo = exp(-k * 1.6);
vec3 dirW = normalize(p.x*u_right + p.y*u_up);
float sunSide = 0.25 + 0.75*smoothstep(-0.5, 0.7, dot(dirW, u_sun));
vec3 atm = mix(vec3(0.18,0.36,0.85), vec3(0.55,0.78,1.0), halo) * halo * sunSide;
vec2 g = floor(f / 1.5);
float st = step(0.9975, hash(g)) * (0.4 + 0.6*hash(g+7.7));
vec2 q = f / u_res;
vec3 neb = vec3(0.02,0.03,0.06) * (0.6 + 0.4*sin(q.x*3.0+q.y*2.0));
col = vec3(0.008,0.012,0.022) + neb + atm*0.95 + vec3(st)*(1.0-halo)*0.85;
} else {
float z = sqrt(1.0 - r2);
vec3 n = normalize(p.x*u_right + p.y*u_up + z*u_fwd);
float lat = asin(clamp(n.z,-1.,1.));
float lon = atan(n.y, n.x);
vec2 uv = vec2((lon + PI) / (2.0*PI), (PI*0.5 - lat) / PI);
vec3 day;
if (u_tex > 0.5) {
day = sampleEq(u_day, uv).rgb;
float polar = smoothstep(84.0, 85.0, abs(lat*180.0/PI));
vec3 pole = lat > 0.0 ? vec3(0.78,0.84,0.9) : vec3(0.9,0.93,0.96);
day = mix(day, pole, polar);
} else {
day = mix(vec3(0.03,0.10,0.22), vec3(0.08,0.22,0.38), 0.5 + 0.5*sin(lat*3.0));
}
if (u_detOn > 0.001) {
float lonD = lon*180.0/PI, latD = lat*180.0/PI;
vec2 duv = vec2((lonD - u_box.x)/(u_box.z - u_box.x), (u_box.w - latD)/(u_box.w - u_box.y));
if (duv.x > 0.0 && duv.x < 1.0 && duv.y > 0.0 && duv.y < 1.0) {
vec2 e = min(duv, 1.0-duv);
float edge = smoothstep(0.0, 0.06, min(e.x, e.y));
day = mix(day, texture(u_det, duv).rgb, edge * u_detOn);
}
}
vec3 nightL = u_nightTex > 0.5 ? sampleEq(u_night, uv).rgb : vec3(0.0);
float mu = dot(n, u_sun);
float dayK = smoothstep(-0.10, 0.16, mu);
if (u_lens > 1.5 && u_lens < 2.5) dayK *= 0.0;
vec3 lit = day * (0.18 + 1.05*clamp(mu*1.4+0.2, 0.0, 1.0));
vec3 nightC = pow(nightL, vec3(1.9)) * vec3(1.65,1.25,0.78) * 2.2 * (1.0 - u_close) + day * mix(0.035, 0.3, u_close);
col = mix(nightC, lit, dayK);
col += vec3(1.0,0.42,0.14) * 0.16 * exp(-pow(mu/0.07, 2.0)) * (1.0 - u_lens*0.0);
float rim = pow(1.0 - z, 2.6);
col = mix(col, vec3(0.42,0.68,1.0) * (0.25 + 0.9*dayK), rim * 0.62);
}
// Lens grade: 0 cinematic, 1 clear, 2 night, 3 thermal, 4 nvg
vec2 q = f / u_res;
if (u_lens < 0.5) {
col = pow(col, vec3(0.95)) * vec3(1.02,1.0,1.04);
float v = smoothstep(1.25, 0.35, length(q - 0.5) * 1.35);
col *= mix(0.62, 1.0, v);
} else if (u_lens > 2.5 && u_lens < 3.5) {
float l = dot(col, vec3(0.299,0.587,0.114));
col = clamp(vec3(l*2.6-0.2, l*1.6-0.25, sin(l*6.28)*0.5+0.1 - l*0.4), 0.0, 1.0);
} else if (u_lens > 3.5) {
float l = dot(col, vec3(0.299,0.587,0.114));
float gr = hash(f + fract(u_res.x*0.37)) * 0.08;
col = vec3(0.12, 1.0, 0.38) * (pow(l, 0.7)*1.4 + gr);
float v = smoothstep(0.75, 0.3, length(q - 0.5));
col *= v;
} else if (u_lens > 1.5) {
col *= vec3(0.9, 0.95, 1.1);
}
col = col / (1.0 + col * 0.12);
o = vec4(col, 1.0);
}`;
function loadImage(url) {
return new Promise((resolve, reject) => {
const img = new Image();
img.crossOrigin = 'anonymous';
img.decoding = 'async';
img.onload = () => resolve(img);
img.onerror = reject;
img.src = url;
});
}
/* ------------------------------------------------------------------ */
/* createGlobe */
/* ------------------------------------------------------------------ */
export async function createGlobe(container, options = {}) {
const listeners = new Map();
const emit = (ev, data) => listeners.get(ev)?.forEach((fn) => fn(data));
const root = document.createElement('div');
root.className = 'stub-globe';
root.style.cssText =
'position:absolute;inset:0;overflow:hidden;touch-action:none;background:#05070b';
const canvas = document.createElement('canvas');
const overlay = document.createElement('canvas');
for (const c of [canvas, overlay])
c.style.cssText =
'position:absolute;inset:0;width:100%;height:100%;display:block';
overlay.style.pointerEvents = 'none';
root.append(canvas, overlay);
container.appendChild(root);
const gl = canvas.getContext('webgl2', {
antialias: false,
alpha: false,
powerPreference: 'high-performance',
preserveDrawingBuffer: false,
});
const ctx = overlay.getContext('2d');
const quality = options.quality || 'auto';
let dpr = Math.min(
window.devicePixelRatio || 1,
quality === 'battery' ? 1.25 : 2,
);
const cam = { ...HOME, heading: 0 };
let W = 1;
let H = 1;
let paused = false;
let dirty = true;
let lens = 0;
let timeOverride = null;
let selected = null;
let flight = null;
const t0 = Date.now();
const contacts = buildContacts();
const layers = [];
for (const [fam, names] of Object.entries(CATALOG))
for (const name of names) {
const id = `${fam}.${slug(name)}`;
layers.push({
id,
family: fam,
name,
on: DEFAULT_ON.has(id),
count: 0,
status: DEFAULT_ON.has(id) ? 'live' : 'off',
});
}
const layerById = new Map(layers.map((l) => [l.id, l]));
const counts = {};
for (const c of contacts) counts[c.layer] = (counts[c.layer] || 0) + 1;
const r = rng(99);
for (const l of layers) {
l.count = counts[l.id] ?? Math.floor(5 + r() * 900);
if (r() < 0.06 && !l.on) l.status = 'off';
}
layerById.get('ground.alpr-cameras').status = 'off';
let situations = null;
/* ---------- GL ---------- */
let prog = null;
let U = {};
const tex = { day: null, night: null, det: null };
let texOn = 0;
let nightOn = 0;
const det = { on: 0, target: 0, box: [0, 0, 0, 0], key: '', pending: null };
function makeTex(unit, img) {
const t = gl.createTexture();
gl.activeTexture(gl.TEXTURE0 + unit);
gl.bindTexture(gl.TEXTURE_2D, t);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
gl.texParameteri(
gl.TEXTURE_2D,
gl.TEXTURE_MIN_FILTER,
gl.LINEAR_MIPMAP_LINEAR,
);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
if (img) {
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, gl.RGB, gl.UNSIGNED_BYTE, img);
gl.generateMipmap(gl.TEXTURE_2D);
} else {
gl.texImage2D(
gl.TEXTURE_2D,
0,
gl.RGB,
1,
1,
0,
gl.RGB,
gl.UNSIGNED_BYTE,
new Uint8Array([10, 30, 60]),
);
}
const ext = gl.getExtension('EXT_texture_filter_anisotropic');
if (ext) gl.texParameterf(gl.TEXTURE_2D, ext.TEXTURE_MAX_ANISOTROPY_EXT, 8);
return t;
}
if (gl) {
const sh = (type, src) => {
const s = gl.createShader(type);
gl.shaderSource(s, src);
gl.compileShader(s);
if (!gl.getShaderParameter(s, gl.COMPILE_STATUS))
throw new Error(gl.getShaderInfoLog(s));
return s;
};
prog = gl.createProgram();
gl.attachShader(prog, sh(gl.VERTEX_SHADER, VS));
gl.attachShader(prog, sh(gl.FRAGMENT_SHADER, FS));
gl.linkProgram(prog);
gl.useProgram(prog);
const buf = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, buf);
gl.bufferData(
gl.ARRAY_BUFFER,
new Float32Array([-1, -1, 3, -1, -1, 3]),
gl.STATIC_DRAW,
);
const loc = gl.getAttribLocation(prog, 'p');
gl.enableVertexAttribArray(loc);
gl.vertexAttribPointer(loc, 2, gl.FLOAT, false, 0, 0);
for (const n of [
'u_c',
'u_R',
'u_res',
'u_right',
'u_up',
'u_fwd',
'u_sun',
'u_day',
'u_night',
'u_det',
'u_box',
'u_detOn',
'u_tex',
'u_lens',
'u_nightTex',
'u_close',
])
U[n] = gl.getUniformLocation(prog, n);
tex.day = makeTex(0);
tex.night = makeTex(1);
tex.det = makeTex(2);
gl.uniform1i(U.u_day, 0);
gl.uniform1i(U.u_night, 1);
gl.uniform1i(U.u_det, 2);
loadImage(DAY_URL)
.then((img) => {
gl.activeTexture(gl.TEXTURE0);
gl.bindTexture(gl.TEXTURE_2D, tex.day);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, gl.RGB, gl.UNSIGNED_BYTE, img);
gl.generateMipmap(gl.TEXTURE_2D);
texOn = 1;
dirty = true;
emit('ready', { imagery: 'esri' });
})
.catch(() =>
emit('quality', { scale: dpr, fps: 0, note: 'imagery offline' }),
);
loadImage(NIGHT_URL)
.then((img) => {
gl.activeTexture(gl.TEXTURE1);
gl.bindTexture(gl.TEXTURE_2D, tex.night);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, gl.RGB, gl.UNSIGNED_BYTE, img);
gl.generateMipmap(gl.TEXTURE_2D);
nightOn = 1;
dirty = true;
})
.catch(() => {});
} else {
root.style.background =
'radial-gradient(circle at 42% 38%, #3d7fbf 0, #123a66 30%, #071526 46%, #05070b 47%)';
}
function resize() {
const rect = root.getBoundingClientRect();
W = Math.max(1, rect.width);
H = Math.max(1, rect.height);
for (const c of [canvas, overlay]) {
c.width = Math.round(W * dpr);
c.height = Math.round(H * dpr);
}
dirty = true;
}
const ro = new ResizeObserver(resize);
ro.observe(root);
resize();
/* ---------- camera math ---------- */
const radiusPx = (height = cam.height) => {
const d = R_EARTH + height;
const tanT = R_EARTH / Math.sqrt(d * d - R_EARTH * R_EARTH);
return (tanT / FOV_HALF) * (Math.min(W, H) / 2) * 1.05;
};
function basis() {
const lo = cam.lon * D2R;
const la = cam.lat * D2R;
const fwd = toVec(cam.lon, cam.lat);
const e = [-Math.sin(lo), Math.cos(lo), 0];
const nn = [
-Math.sin(la) * Math.cos(lo),
-Math.sin(la) * Math.sin(lo),
Math.cos(la),
];
const h = (cam.heading || 0) * D2R;
const ch = Math.cos(h);
const s = Math.sin(h);
const up = [
nn[0] * ch + e[0] * s,
nn[1] * ch + e[1] * s,
nn[2] * ch + e[2] * s,
];
const right = [
e[0] * ch - nn[0] * s,
e[1] * ch - nn[1] * s,
e[2] * ch - nn[2] * s,
];
return { fwd, up, right };
}
let B = basis();
const centerY = () => H * (options.centerBias ?? 0.5);
function project(lon, lat, altM = 0) {
const v = toVec(lon, lat);
const z = dot(v, B.fwd);
const k = 1 + altM / R_EARTH;
if (z < (altM > 0 ? -0.15 : 0.02)) return null;
const R = radiusPx();
return {
x: W / 2 + R * k * dot(v, B.right),
y: centerY() - R * k * dot(v, B.up),
z,
};
}
function unproject(x, y) {
const R = radiusPx();
const px = (x - W / 2) / R;
const py = (centerY() - y) / R;
const r2 = px * px + py * py;
if (r2 > 1) return null;
const z = Math.sqrt(1 - r2);
const n = [0, 1, 2].map(
(i) => px * B.right[i] + py * B.up[i] + z * B.fwd[i],
);
return { lon: Math.atan2(n[1], n[0]) * R2D, lat: Math.asin(n[2]) * R2D };
}
const now = () => (timeOverride ? timeOverride.getTime() : Date.now());
/* ---------- detail imagery ---------- */
function updateDetail() {
if (!gl || cam.height > 3200e3) {
det.target = 0;
return;
}
const R = radiusPx();
const halfW = Math.min(80, (W / 2 / R) * R2D * 1.25);
const halfH = Math.min(60, (H / 2 / R) * R2D * 1.25);
const clat = Math.cos(cam.lat * D2R);
const box = [
cam.lon - halfW / Math.max(0.15, clat),
Math.max(-85, cam.lat - halfH),
cam.lon + halfW / Math.max(0.15, clat),
Math.min(85, cam.lat + halfH),
];
const key = box.map((v) => v.toFixed(2)).join(',');
if (
det.on > 0.5 &&
det.box[0] <= box[0] &&
det.box[2] >= box[2] &&
det.box[1] <= box[1] &&
det.box[3] >= box[3] &&
det.box[2] - det.box[0] < (box[2] - box[0]) * 3
)
return;
if (key === det.key) return;
det.key = key;
clearTimeout(det.pending);
det.pending = setTimeout(() => {
const pad = 0.15;
const bw = box[2] - box[0];
const bh = box[3] - box[1];
const b = [
box[0] - bw * pad,
Math.max(-85, box[1] - bh * pad),
box[2] + bw * pad,
Math.min(85, box[3] + bh * pad),
];
const url = `https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=${b.map((v) => v.toFixed(5)).join(',')}&bboxSR=4326&imageSR=4326&size=1536,1536&format=jpg&f=image`;
loadImage(url)
.then((img) => {
if (det.key !== key) return;
gl.activeTexture(gl.TEXTURE2);
gl.bindTexture(gl.TEXTURE_2D, tex.det);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texImage2D(
gl.TEXTURE_2D,
0,
gl.RGB,
gl.RGB,
gl.UNSIGNED_BYTE,
img,
);
gl.generateMipmap(gl.TEXTURE_2D);
det.box = b;
det.on = 0;
det.target = 1;
dirty = true;
})
.catch(() => {});
}, 380);
}
/* ---------- render loop ---------- */
let raf = 0;
let lastOverlay = 0;
let frames = 0;
let fpsT = performance.now();
function frame(ts) {
raf = 0;
if (paused) return;
if (flight) stepFlight(ts);
if (inertia) stepInertia();
if (det.on !== det.target) {
det.on += (det.target - det.on) * 0.12;
if (Math.abs(det.on - det.target) < 0.01) det.on = det.target;
dirty = true;
}
if (dirty && gl) {
B = basis();
gl.viewport(0, 0, canvas.width, canvas.height);
const R = radiusPx() * dpr;
gl.uniform2f(U.u_c, (W / 2) * dpr, (H - centerY()) * dpr);
gl.uniform1f(U.u_R, R);
gl.uniform2f(U.u_res, canvas.width, canvas.height);
gl.uniform3fv(U.u_right, B.right);
gl.uniform3fv(U.u_up, B.up);
gl.uniform3fv(U.u_fwd, B.fwd);
gl.uniform3fv(U.u_sun, subsolar(new Date(now())));
gl.uniform4fv(U.u_box, det.box);
gl.uniform1f(U.u_detOn, det.on);
gl.uniform1f(U.u_tex, texOn);
gl.uniform1f(U.u_nightTex, nightOn);
gl.uniform1f(U.u_lens, lens);
// Close in, the 2 km/px night mosaic is mush: fade it for moonlit imagery.
gl.uniform1f(
U.u_close,
Math.max(0, Math.min(1, (900e3 - cam.height) / 700e3)),
);
gl.drawArrays(gl.TRIANGLES, 0, 3);
dirty = false;
} else if (dirty) {
B = basis();
dirty = false;
}
if (ts - lastOverlay > 33) {
lastOverlay = ts;
drawOverlay(ts);
}
frames += 1;
if (ts - fpsT > 2000) {
emit('quality', {
scale: dpr,
fps: Math.round((frames * 1000) / (ts - fpsT)),
});
frames = 0;
fpsT = ts;
}
raf = requestAnimationFrame(frame);
}
const kick = () => {
if (!raf && !paused) raf = requestAnimationFrame(frame);
};
const KIND_COLOR = {
aircraft: '#7CC4FF',
helicopter: '#7CC4FF',
ship: '#38E1C6',
satellite: '#C9A7FF',
quake: '#FF6A3D',
fire: '#FF6A3D',
};
let drawn = [];
function drawOverlay(ts) {
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
ctx.clearRect(0, 0, W, H);
drawn = [];
const t = now();
const planetary = cam.height > 2500e3;
for (const c of contacts) {
const layer = layerById.get(c.layer);
if (!layer?.on) continue;
propagate(c, t0, t);
const p = project(c.lon, c.lat, c.kind === 'satellite' ? c.altM : 0);
if (!p || p.x < -20 || p.y < -20 || p.x > W + 20 || p.y > H + 20)
continue;
const col = KIND_COLOR[c.kind] || '#fff';
const isSel = selected === c.id;
ctx.globalAlpha = planetary ? 0.75 : 1;
if (c.kind === 'aircraft' || c.kind === 'helicopter') {
if (planetary) {
ctx.fillStyle = col;
ctx.fillRect(p.x - 0.8, p.y - 0.8, 1.6, 1.6);
} else {
ctx.save();
ctx.translate(p.x, p.y);
ctx.rotate(((c.headingDeg - (cam.heading || 0)) * Math.PI) / 180);
ctx.fillStyle = col;
ctx.beginPath();
ctx.moveTo(0, -6);
ctx.lineTo(4.2, 5);
ctx.lineTo(0, 2.6);
ctx.lineTo(-4.2, 5);
ctx.closePath();
ctx.fill();
ctx.restore();
}
} else if (c.kind === 'satellite') {
ctx.fillStyle = c.id === 'iss' ? '#fff' : col;
const s = c.id === 'iss' ? 3.2 : 1.8;
ctx.fillRect(p.x - s / 2, p.y - s / 2, s, s);
if (c.id === 'iss') {
ctx.strokeStyle = col;
ctx.lineWidth = 1;
ctx.beginPath();
ctx.arc(p.x, p.y, 6 + Math.sin(ts / 300) * 1.2, 0, Math.PI * 2);
ctx.stroke();
}
} else if (c.kind === 'quake') {
const rr = 3 + (c.mag - 4) * 3.5;
ctx.strokeStyle = col;
ctx.lineWidth = 1.5;
ctx.beginPath();
ctx.arc(p.x, p.y, rr + ((ts / 40) % 14), 0, Math.PI * 2);
ctx.globalAlpha = 1 - ((ts / 40) % 14) / 14;
ctx.stroke();
ctx.globalAlpha = 1;
ctx.fillStyle = col;
ctx.beginPath();
ctx.arc(p.x, p.y, rr * 0.45, 0, Math.PI * 2);
ctx.fill();
} else if (c.kind === 'fire') {
ctx.fillStyle = 'rgba(255,106,61,0.85)';
ctx.beginPath();
ctx.arc(p.x, p.y, planetary ? 1.4 : 2.6, 0, Math.PI * 2);
ctx.fill();
} else {
ctx.fillStyle = col;
ctx.beginPath();
ctx.arc(p.x, p.y, planetary ? 1 : 2.4, 0, Math.PI * 2);
ctx.fill();
}
ctx.globalAlpha = 1;
if (isSel) {
ctx.strokeStyle = '#fff';
ctx.lineWidth = 1.5;
ctx.beginPath();
ctx.arc(p.x, p.y, 13, 0, Math.PI * 2);
ctx.stroke();
if (c.speed) {
ctx.strokeStyle = col;
ctx.setLineDash([2, 3]);
ctx.beginPath();
for (let i = 0; i <= 20; i += 1) {
const [x, y] = destination(
c.lon,
c.lat,
c.headingDeg + 180,
c.speed * i * 30,
);
const q = project(x, y);
if (!q) break;
if (i) ctx.lineTo(q.x, q.y);
else ctx.moveTo(q.x, q.y);
}
ctx.stroke();
ctx.setLineDash([]);
}
}
drawn.push({ c, x: p.x, y: p.y });
}
if (situations && options.showSituations !== false) {
for (const s of situations) {
const p = project(s.lon, s.lat);
if (!p) continue;
const col = {
sky: '#7CC4FF',
sea: '#38E1C6',
orbit: '#C9A7FF',
hazards: '#FF6A3D',
eyes: '#FFD166',
ground: '#9BE15D',
weather: '#8AB4F8',
infra: '#B8C0CC',
}[s.family];
const ph = (((ts / 1600 + s.lon) % 1) + 1) % 1;
ctx.strokeStyle = col;
ctx.globalAlpha = 1 - ph;
ctx.lineWidth = 1.5;
ctx.beginPath();
ctx.arc(p.x, p.y, 5 + ph * 16, 0, Math.PI * 2);
ctx.stroke();
ctx.globalAlpha = 1;
ctx.fillStyle = col;
ctx.beginPath();
ctx.arc(p.x, p.y, 4, 0, Math.PI * 2);
ctx.fill();
ctx.strokeStyle = 'rgba(5,7,11,0.8)';
ctx.lineWidth = 1.5;
ctx.stroke();
drawn.push({ s, x: p.x, y: p.y });
}
}
}
/* ---------- flights ---------- */
function stepFlight(ts) {
const f = flight;
if (!f.start) f.start = ts;
const k = Math.min(1, (ts - f.start) / f.dur);
const e = k < 0.5 ? 4 * k * k * k : 1 - (-2 * k + 2) ** 3 / 2;
let dLon = f.to.lon - f.from.lon;
if (dLon > 180) dLon -= 360;
if (dLon < -180) dLon += 360;
cam.lon = ((f.from.lon + dLon * e + 540) % 360) - 180;
cam.lat = f.from.lat + (f.to.lat - f.from.lat) * e;
const lh0 = Math.log(f.from.height);
const lh1 = Math.log(f.to.height);
const hop = Math.log(Math.max(f.from.height, f.to.height, f.peak));
const lin = lh0 + (lh1 - lh0) * e;
const arc = Math.sin(Math.PI * e) * Math.max(0, hop - Math.max(lh0, lh1));
cam.height = Math.exp(lin + arc);
cam.heading = f.from.heading + (f.to.heading - f.from.heading) * e;
dirty = true;
emitCamera();
if (k >= 1) {
flight = null;
updateDetail();
f.resolve();
}
}
function flyTo({ lon, lat, height, duration } = {}) {
if (flight) flight.resolve();
inertia = null;
const to = {
lon: lon ?? cam.lon,
lat: Math.max(-85, Math.min(85, lat ?? cam.lat)),
height: Math.max(MIN_H, Math.min(MAX_H, height ?? cam.height)),
// The stub renders top-down; heading is honoured by the real engine.
heading: 0,
};
const dist = haversine(cam.lon, cam.lat, to.lon, to.lat);
const dur = (duration ?? Math.min(3.2, 1.2 + dist / 6e6)) * 1000;
return new Promise((resolve) => {
if (dur <= 16) {
Object.assign(cam, to);
dirty = true;
emitCamera();
updateDetail();
kick();
resolve();
return;
}
flight = {
from: { ...cam },
to,
dur,
peak: Math.min(MAX_H, dist * 1.4),
start: 0,
resolve,
};
det.target = cam.height > 3200e3 ? 0 : det.target;
kick();
});
}
let camTimer = 0;
function emitCamera() {
if (camTimer) return;
camTimer = setTimeout(() => {
camTimer = 0;
emit('camera', { lon: cam.lon, lat: cam.lat, height: cam.height });
}, 80);
}
/* ---------- input ---------- */
const pointers = new Map();
let inertia = null;
let lastMove = null;
let pinch0 = null;
let downAt = null;
function onDown(e) {
root.setPointerCapture?.(e.pointerId);
pointers.set(e.pointerId, { x: e.clientX, y: e.clientY });
flight = null;
inertia = null;
downAt = { x: e.clientX, y: e.clientY, t: performance.now(), moved: false };
if (pointers.size === 2) {
const [a, b] = [...pointers.values()];
pinch0 = { d: Math.hypot(a.x - b.x, a.y - b.y), h: cam.height };
}
emit('interact', { type: 'start' });
}
function onMove(e) {
const prev = pointers.get(e.pointerId);
if (!prev) return;
const cur = { x: e.clientX, y: e.clientY };
pointers.set(e.pointerId, cur);
if (downAt && Math.hypot(cur.x - downAt.x, cur.y - downAt.y) > 6)
downAt.moved = true;
if (pointers.size === 2 && pinch0) {
const [a, b] = [...pointers.values()];
const d = Math.hypot(a.x - b.x, a.y - b.y);
cam.height = Math.max(
MIN_H,
Math.min(MAX_H, (pinch0.h * pinch0.d) / Math.max(10, d)),
);
dirty = true;
emitCamera();
kick();
return;
}
const dx = cur.x - prev.x;
const dy = cur.y - prev.y;
pan(dx, dy);
const t = performance.now();
lastMove = { dx, dy, t };
}
function pan(dx, dy) {
const R = radiusPx();
const clat = Math.max(0.1, Math.cos(cam.lat * D2R));
cam.lon = ((cam.lon - ((dx / R) * R2D) / clat + 540) % 360) - 180;
cam.lat = Math.max(-85, Math.min(85, cam.lat + (dy / R) * R2D));
dirty = true;
emitCamera();
kick();
}
function onUp(e) {
pointers.delete(e.pointerId);
if (pointers.size < 2) pinch0 = null;
if (pointers.size) return;
if (downAt && !downAt.moved && performance.now() - downAt.t < 400) {
const rect = root.getBoundingClientRect();
tapAt(e.clientX - rect.left, e.clientY - rect.top);
} else if (lastMove && performance.now() - lastMove.t < 60) {
inertia = { vx: lastMove.dx, vy: lastMove.dy };
kick();
}
updateDetail();
emit('interact', { type: 'end' });
downAt = null;
}
function stepInertia() {
inertia.vx *= 0.92;
inertia.vy *= 0.92;
pan(inertia.vx, inertia.vy);
if (Math.hypot(inertia.vx, inertia.vy) < 0.15) {
inertia = null;
updateDetail();
}
}
function tapAt(x, y) {
let best = null;
let bd = 24;
for (const d of drawn) {
const dd = Math.hypot(d.x - x, d.y - y);
if (dd < bd) {
bd = dd;
best = d;
}
}
if (!best) {
select(null);
emit('pick', null);
return;
}
if (best.s) {
const s = best.s;
emit('pick', {
kind: 'situation',
id: s.id,
title: s.title,
subtitle: s.place,
lon: s.lon,
lat: s.lat,
meta: { situation: s.id, source: s.source },
});
return;
}
const c = best.c;
select(c.id);
const meta = {};
if (c.altM)
meta.altitude =
c.kind === 'satellite'
? `${Math.round(c.altM / 1000)} km`
: `${Math.round(c.altM * 3.28084).toLocaleString()} ft`;
if (c.speed)
meta.speed =
c.kind === 'ship'
? `${(c.speed * 1.944).toFixed(1)} kn`
: `${Math.round(c.speed * 1.944)} kn`;
if (c.speed || c.kind === 'satellite')
meta.heading = `${Math.round(((c.headingDeg % 360) + 360) % 360)}°`;
meta.source = SIM;
const sub = {
aircraft: 'Aircraft',
helicopter: 'Helicopter',
ship: 'Vessel',
satellite: 'Satellite',
quake: 'Earthquake',
fire: 'Active fire',
}[c.kind];
emit('pick', {
kind: c.kind,
id: c.id,
title: c.title,
subtitle: `${sub} · simulated`,
lon: c.lon,
lat: c.lat,
meta,
});
}
function onWheel(e) {
e.preventDefault();
cam.height = Math.max(
MIN_H,
Math.min(MAX_H, cam.height * Math.exp(e.deltaY * 0.0018)),
);
dirty = true;
emitCamera();
kick();
clearTimeout(onWheel.t);
onWheel.t = setTimeout(updateDetail, 200);
}
root.addEventListener('pointerdown', onDown);
root.addEventListener('pointermove', onMove, { passive: true });
root.addEventListener('pointerup', onUp);
root.addEventListener('pointercancel', onUp);
root.addEventListener('wheel', onWheel, { passive: false });
root.addEventListener('dblclick', (e) => {
const rect = root.getBoundingClientRect();
const g = unproject(e.clientX - rect.left, e.clientY - rect.top);
if (g) flyTo({ ...g, height: cam.height / 2.5, duration: 0.6 });
});
/* ---------- API ---------- */
function select(id) {
selected = id;
kick();
}
function setLayer(id, on) {
const l = layerById.get(id);
if (!l) return;
l.on = !!on;
l.status = on ? 'live' : 'off';
emit('layers', layers);
kick();
}
const localSeeded = new Set();
const api = {
isStub: true,
flyTo,
home: () => flyTo({ ...HOME }),
layers: () => layers.map((l) => ({ ...l })),
setLayer,
setFamily(family, on) {
for (const l of layers)
if (l.family === family)
((l.on = !!on), (l.status = on ? 'live' : 'off'));
emit('layers', layers);
kick();
},
setTime(date) {
timeOverride = date ? new Date(date) : null;
dirty = true;
kick();
emit('time', { time: timeOverride });
},
timeWindow() {
const n = Date.now();
return {
start: new Date(n - 72 * 3600e3),
end: new Date(n + 120 * 3600e3),
now: new Date(n),
};
},
setLens(id) {
lens = { cinematic: 0, clear: 1, night: 2, thermal: 3, nvg: 4 }[id] ?? 0;
dirty = true;
kick();
},
async focus(s) {
if (!s) return;
for (const id of s.layers || [])
if (layerById.has(id)) setLayer(id, true);
if (s.live) api.setTime(null);
else if (s.time?.end) api.setTime(new Date(s.time.end));
const c = s.camera || { lon: s.lon, lat: s.lat, height: 400e3 };
return flyTo({
lon: c.lon,
lat: c.lat,
height: c.height,
heading: c.heading,
duration: options.reducedMotion ? 0 : undefined,
});
},
select,
on(ev, fn) {
if (!listeners.has(ev)) listeners.set(ev, new Set());
listeners.get(ev).add(fn);
},
off(ev, fn) {
listeners.get(ev)?.delete(fn);
},
pause() {
paused = true;
if (raf) cancelAnimationFrame(raf);
raf = 0;
},
resume() {
paused = false;
dirty = true;
kick();
},
contactsNear(lon, lat, km) {
const key = `${lon.toFixed(1)},${lat.toFixed(1)}`;
if (!localSeeded.has(key)) {
localSeeded.add(key);
const rr = rng(Math.floor((lon + 180) * 100 + (lat + 90) * 7));
for (let i = 0; i < 14; i += 1) {
const [x, y] = destination(lon, lat, rr() * 360, 4e3 + rr() * 70e3);
contacts.push({
kind: 'aircraft',
layer: 'sky.commercial-flights',
id: `local-${key}-${i}`,
title: `${PREFIX[i % PREFIX.length]}${200 + Math.floor(rr() * 7000)}`,
lon: x,
lat: y,
altM: 900 + rr() * 11000,
headingDeg: rr() * 360,
speed: 120 + rr() * 120,
});
}
for (let i = 0; i < 3; i += 1) {
const [x, y] = destination(lon, lat, rr() * 360, 3e3 + rr() * 20e3);
contacts.push({
kind: 'ship',
layer: 'sea.ais-vessels',
id: `localship-${key}-${i}`,
title: `${SHIP[i]} ${['Star', 'Bay', 'Trader'][i]}`,
lon: x,
lat: y,
altM: 0,
headingDeg: rr() * 360,
speed: 4,
});
}
}
const t = now();
const out = [];
for (const c of contacts) {
propagate(c, t0, t);
const d = haversine(lon, lat, c.lon, c.lat);
const lim =
c.kind === 'satellite' ? Math.max(km * 1000, 2200e3) : km * 1000;
if (d <= lim)
out.push({
kind: c.kind === 'helicopter' ? 'aircraft' : c.kind,
id: c.id,
title: c.title,
lon: c.lon,
lat: c.lat,
altM: c.altM,
headingDeg: c.headingDeg,
});
}
return out;
},
async situations() {
if (!situations) situations = buildSituations(Date.now());
kick();
return situations;
},
credits() {
return [
{
name: 'Esri World Imagery',
text: 'Esri, Maxar, Earthstar Geographics, and the GIS User Community',
url: 'https://www.arcgis.com/home/item.html?id=10df2279f9684e4a9f6a7f08febac2a9',
},
{
name: 'NASA Black Marble',
text: 'NASA Earth Observatory / GIBS, VIIRS Black Marble',
url: 'https://earthdata.nasa.gov/gibs',
},
{
name: 'Simulated contacts',
text: 'Offline stub engine. Aircraft, ships, satellites and situations here are simulated, not live.',
},
];
},
camera: () => ({ ...cam }),
destroy() {
api.pause();
ro.disconnect();
root.remove();
},
};
kick();
setTimeout(
() =>
emit('camera', {
lon: cam.lon,
lat: cam.lat,
height: cam.height,
heading: 0,
pitch: -90,
}),
0,
);
return api;
}