mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-21 10:42:22 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
d37e8cf17d | ||
|
|
3e1070a2cb |
No files matched your search
@@ -1,3 +0,0 @@
|
|||||||
- Shorten the freeze when Submarine cables is switched on from about 1.4 s to
|
|
||||||
about 0.2 s. Landing markers are now shown a few dozen per frame instead of
|
|
||||||
all at once (mazy1998, #1707).
|
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
- A still-image CCTV camera no longer keeps the scene rendering 60 times a
|
||||||
|
second. Only a video feed holds continuous rendering; a still redraws when a
|
||||||
|
new image arrives (mazy1998, #1710).
|
||||||
@@ -1,4 +0,0 @@
|
|||||||
- Submarine cables draw from a few batched primitives instead of thousands of
|
|
||||||
entities. Switching the layer off and back on, and zooming with it on, no
|
|
||||||
longer stall the page, and it holds about 900 MB less memory. Double-click
|
|
||||||
no longer starts Cesium's entity tracking on a cable (mazy1998, #1722).
|
|
||||||
+9
-31
@@ -1541,14 +1541,12 @@ query. Movement within an accepted or pending query reuses it. Markers retain
|
|||||||
their Cesium identity while their geometry is unchanged; refreshes preserve
|
their Cesium identity while their geometry is unchanged; refreshes preserve
|
||||||
selection without replaying a click event.
|
selection without replaying a click event.
|
||||||
|
|
||||||
Data Centers and Dams release their built Cesium data sources
|
Data Centers, Dams and Submarine Cables release their built Cesium data sources
|
||||||
and record references when disabled. Parsed datasets remain cached for the layer
|
and record references when disabled. Parsed datasets remain cached for the layer
|
||||||
lifetime, so re-enable rebuilds entities without downloading or parsing again;
|
lifetime, so re-enable rebuilds entities without downloading or parsing again;
|
||||||
this can take longer than simply revealing hidden entities. Destruction clears
|
this can take longer than simply revealing hidden entities. Destruction clears
|
||||||
the parsed cache as well. A disable during loading cannot leave a completed
|
the parsed cache as well. A disable during loading cannot leave a completed
|
||||||
build hidden in the scene. Submarine Cables draws with its own primitives
|
build hidden in the scene.
|
||||||
instead of entities and only hides them when disabled (see "Bundled geography
|
|
||||||
and submarine cable components").
|
|
||||||
|
|
||||||
CCTV exposes a factory through `./layers/cctv`. Catalog and health requests,
|
CCTV exposes a factory through `./layers/cctv`. Catalog and health requests,
|
||||||
frame/media URLs, camera records, ground placement, geometry queues, playback,
|
frame/media URLs, camera records, ground placement, geometry queues, playback,
|
||||||
@@ -8149,37 +8147,17 @@ an error. Without feeds it keeps the WebUSB statuses. See
|
|||||||
Submarine cables use separate source, geometry, rendering, interaction and
|
Submarine cables use separate source, geometry, rendering, interaction and
|
||||||
lifecycle modules. The layer factory accepts cable and landing-point GeoJSON
|
lifecycle modules. The layer factory accepts cable and landing-point GeoJSON
|
||||||
collections from a source with `fetch(signal)` and a display label. The default
|
collections from a source with `fetch(signal)` and a display label. The default
|
||||||
source loads the same bundled TeleGeography files. Load ownership prevents
|
source loads the same bundled TeleGeography files. Disabling still removes all
|
||||||
cancelled work from adding anything to the scene after teardown: the fetch is
|
three Cesium data sources; enabling rebuilds from the accepted parsed cache,
|
||||||
the load's only await, and everything is built in the turn after it.
|
and destroying clears it. Load ownership prevents cancelled work from adding
|
||||||
|
entities after teardown.
|
||||||
|
|
||||||
The layer draws with four Cesium primitives of its own and creates no entity
|
Every Cesium entity from multipart cable or landing-point geometry stays tied
|
||||||
or data source. Every line is one instance of a single
|
to its source feature, including generated IDs and IDs that collide with
|
||||||
`GroundPolylinePrimitive` (per-line colour and show flag, rhumb lines,
|
Cesium's multipart suffixes. Each segment gets its own feature's styling, click
|
||||||
tessellated in a worker; a map-stack change re-classifies it in place). Every
|
|
||||||
point is a billboard in one `BillboardCollection`. Reference tips are one
|
|
||||||
`PointPrimitiveCollection`, and the stems of the references in view are one
|
|
||||||
static polyline `Primitive`: a horizon sweep that moved a tip or changed which
|
|
||||||
references are in view builds a replacement in a worker, and it replaces the
|
|
||||||
shown stems once it is ready. Disabling hides the lines, markers and tips and
|
|
||||||
keeps them, so enabling again neither fetches nor builds them (only the stems
|
|
||||||
are redrawn, for the new view); destroying removes everything. These are
|
|
||||||
the same primitives Cesium built from the layer's entities, so the layer looks
|
|
||||||
the same. Polygon geometry in a custom source is not drawn, and GeoJSON
|
|
||||||
simplestyle properties (`marker-color`, `stroke` and the like) are not read.
|
|
||||||
|
|
||||||
Every line and marker from multipart cable or landing-point geometry stays tied
|
|
||||||
to its source feature. Each part gets its own feature's styling, click
|
|
||||||
destination and horizon-culling reference, and each source feature has one
|
destination and horizon-culling reference, and each source feature has one
|
||||||
reference stem. The source collections are not modified.
|
reference stem. The source collections are not modified.
|
||||||
|
|
||||||
Landing markers are ground-clamped billboards. A marker starts hidden and
|
|
||||||
unclamped; the horizon sweep clamps and shows the visible ones 48 per rendered
|
|
||||||
frame (`CABLE_LANDING_REVEALS_PER_FRAME`), so the terrain height reads are
|
|
||||||
never one task. A marker is clamped once: Cesium then keeps it on the surface
|
|
||||||
as terrain loads, and hiding or showing it again reads nothing; hiding is
|
|
||||||
immediate.
|
|
||||||
|
|
||||||
Natural Earth regions and neighborhood polygon lookup are package exports.
|
Natural Earth regions and neighborhood polygon lookup are package exports.
|
||||||
Their existing lazy loaders, retry behavior, bundled datasets and attribution
|
Their existing lazy loaders, retry behavior, bundled datasets and attribution
|
||||||
are unchanged. The cable dataset remains CC BY-NC-SA 3.0 and is not covered by
|
are unchanged. The cable dataset remains CC BY-NC-SA 3.0 and is not covered by
|
||||||
|
|||||||
@@ -24,6 +24,7 @@ export {
|
|||||||
createCableOverlayEntry,
|
createCableOverlayEntry,
|
||||||
cableClassificationTypeForStack,
|
cableClassificationTypeForStack,
|
||||||
cableClassificationTypeForScene,
|
cableClassificationTypeForScene,
|
||||||
|
applyTranslucentMarkerBlend,
|
||||||
createCableReferenceSweepGate,
|
createCableReferenceSweepGate,
|
||||||
updateCableReferenceStem,
|
updateCableReferenceStem,
|
||||||
} from '../layers/submarineCables/index.js';
|
} from '../layers/submarineCables/index.js';
|
||||||
File diff suppressed because it is too large.
Load diff
@@ -144,33 +144,35 @@ export function createFrames({ state: layerState, services, parts, source }) {
|
|||||||
* the double-buffer canvas reference, throttled to PROJECTION_TEXTURE_SWAP_MS.
|
* the double-buffer canvas reference, throttled to PROJECTION_TEXTURE_SWAP_MS.
|
||||||
*
|
*
|
||||||
* @param {Object} record - Camera record with an initialized projection runtime.
|
* @param {Object} record - Camera record with an initialized projection runtime.
|
||||||
|
* @returns {boolean} Whether a new image was put on the plane.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
function refreshProjectionTextures(record) {
|
function refreshProjectionTextures(record) {
|
||||||
const runtime = record?.projection;
|
const runtime = record?.projection;
|
||||||
if (!runtime || runtime.mode === 'video') return;
|
if (!runtime || runtime.mode === 'video') return false;
|
||||||
const now = Date.now();
|
const now = Date.now();
|
||||||
if (
|
if (
|
||||||
now - parts.model.safeNumber(runtime.lastTextureSwapAt, 0) <
|
now - parts.model.safeNumber(runtime.lastTextureSwapAt, 0) <
|
||||||
PROJECTION_TEXTURE_SWAP_MS
|
PROJECTION_TEXTURE_SWAP_MS
|
||||||
)
|
)
|
||||||
return;
|
return false;
|
||||||
|
|
||||||
const planeShowing = !!(runtime.planeEntity?.show && runtime.planeMaterial);
|
const planeShowing = !!(runtime.planeEntity?.show && runtime.planeMaterial);
|
||||||
if (!planeShowing) return;
|
if (!planeShowing) return false;
|
||||||
|
|
||||||
// Only swap when the canvas content actually changed since the last swap.
|
// Only swap when the canvas content actually changed since the last swap.
|
||||||
// Frames land every ~10 s but this runs at 1 Hz — swapping an UNCHANGED
|
// Frames land every ~10 s but this runs at 1 Hz — swapping an UNCHANGED
|
||||||
// canvas re-uploads the texture for nothing, and each material image
|
// canvas re-uploads the texture for nothing, and each material image
|
||||||
// reassignment is a flash opportunity on the live plane (owner field test
|
// reassignment is a flash opportunity on the live plane (owner field test
|
||||||
// 2026-07-04: intermittent white flashes on the monitor plane).
|
// 2026-07-04: intermittent white flashes on the monitor plane).
|
||||||
if (runtime.canvasStamp === runtime.lastSwappedCanvasStamp) return;
|
if (runtime.canvasStamp === runtime.lastSwappedCanvasStamp) return false;
|
||||||
|
|
||||||
const buffer = paintNextProjectionBuffer(runtime);
|
const buffer = paintNextProjectionBuffer(runtime);
|
||||||
if (!buffer) return;
|
if (!buffer) return false;
|
||||||
runtime.lastTextureSwapAt = now;
|
runtime.lastTextureSwapAt = now;
|
||||||
runtime.lastSwappedCanvasStamp = runtime.canvasStamp;
|
runtime.lastSwappedCanvasStamp = runtime.canvasStamp;
|
||||||
runtime.planeMaterial.image = buffer;
|
runtime.planeMaterial.image = buffer;
|
||||||
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|||||||
@@ -123,6 +123,11 @@ export const CCTV_CALIBRATION_STORAGE_KEY_V2 =
|
|||||||
|
|
||||||
export const PROJECTION_TEXTURE_SWAP_MS = 1000;
|
export const PROJECTION_TEXTURE_SWAP_MS = 1000;
|
||||||
|
|
||||||
|
// A still-image projection changes only when a new still is swapped onto the
|
||||||
|
// plane, so the scene renders for this long after a swap (Cesium binds the new
|
||||||
|
// image over the next frames) and is otherwise left idle.
|
||||||
|
export const PROJECTION_SWAP_RENDER_MS = 500;
|
||||||
|
|
||||||
// V2 frustum geometry (design §2a/§6): the far-cap center + corners never sink
|
// V2 frustum geometry (design §2a/§6): the far-cap center + corners never sink
|
||||||
// below groundAlt + this clearance, so a fabricated pitch (-24°) cannot bury
|
// below groundAlt + this clearance, so a fabricated pitch (-24°) cannot bury
|
||||||
// the monitor plane in the 3D tiles. Exported for the unit suite.
|
// the monitor plane in the 3D tiles. Exported for the unit suite.
|
||||||
|
|||||||
@@ -6,6 +6,7 @@ import {
|
|||||||
PLANE_OUTLINE_COLOR,
|
PLANE_OUTLINE_COLOR,
|
||||||
PROJECTION_CANVAS_WIDTH,
|
PROJECTION_CANVAS_WIDTH,
|
||||||
PROJECTION_CANVAS_HEIGHT,
|
PROJECTION_CANVAS_HEIGHT,
|
||||||
|
PROJECTION_SWAP_RENDER_MS,
|
||||||
} from './policy.js';
|
} from './policy.js';
|
||||||
|
|
||||||
export function createProjection({
|
export function createProjection({
|
||||||
@@ -14,7 +15,15 @@ export function createProjection({
|
|||||||
parts,
|
parts,
|
||||||
source,
|
source,
|
||||||
}) {
|
}) {
|
||||||
const { holdContinuousRender, releaseContinuousRender } = services.render;
|
const {
|
||||||
|
holdContinuousRender,
|
||||||
|
releaseContinuousRender,
|
||||||
|
governorRequestRender = () => {},
|
||||||
|
} = services.render;
|
||||||
|
// Until this time (performance.now) the projection loop asks for a frame on
|
||||||
|
// every tick: after a still is swapped onto the plane, and after an edge
|
||||||
|
// that re-arms the loop (activation, projection shown).
|
||||||
|
let renderUntil = 0;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Build the protected label associated with one active monitor plane.
|
* Build the protected label associated with one active monitor plane.
|
||||||
@@ -352,12 +361,9 @@ export function createProjection({
|
|||||||
}
|
}
|
||||||
|
|
||||||
function startProjectionLoop() {
|
function startProjectionLoop() {
|
||||||
|
renderUntil = performance.now() + PROJECTION_SWAP_RENDER_MS;
|
||||||
if (layerState._projectionRaf) return;
|
if (layerState._projectionRaf) return;
|
||||||
if (!parts.model.projectionLoopIsNeeded()) return;
|
if (!parts.model.projectionLoopIsNeeded()) return;
|
||||||
// The armed projection loop uploads video textures / runs focus fades per
|
|
||||||
// frame — the scene must render continuously while it runs. Released when
|
|
||||||
// the tick self-stops. (perf wave 2)
|
|
||||||
holdContinuousRender('cctv-projection');
|
|
||||||
|
|
||||||
const tick = () => {
|
const tick = () => {
|
||||||
if (!layerState._viewer || !parts.model.projectionLoopIsNeeded()) {
|
if (!layerState._viewer || !parts.model.projectionLoopIsNeeded()) {
|
||||||
@@ -366,15 +372,30 @@ export function createProjection({
|
|||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
parts.rendering.refreshCctvFocusStyles(performance.now());
|
const now = performance.now();
|
||||||
|
const restyled = parts.rendering.refreshCctvFocusStyles(now);
|
||||||
|
|
||||||
const active = parts.selection.getActiveRecord();
|
const active = parts.selection.getActiveRecord();
|
||||||
|
let video = false;
|
||||||
if (layerState._enabled && layerState._showProjection && active) {
|
if (layerState._enabled && layerState._showProjection && active) {
|
||||||
ensureProjectionRuntime(active);
|
ensureProjectionRuntime(active);
|
||||||
if (active.projection && !active.projection.video) {
|
if (active.projection && !active.projection.video) {
|
||||||
parts.frames.drawProjectionFrame(active);
|
parts.frames.drawProjectionFrame(active);
|
||||||
parts.frames.refreshProjectionTextures(active);
|
if (parts.frames.refreshProjectionTextures(active))
|
||||||
}
|
renderUntil = now + PROJECTION_SWAP_RENDER_MS;
|
||||||
|
} else video = Boolean(active.projection?.video);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Only a video feed changes the scene on every frame, so only video
|
||||||
|
// holds the continuous loop. A still lands about every ten seconds and
|
||||||
|
// a focus fade restyles icons every 80 ms; each asks for the frames it
|
||||||
|
// needs. Holding for stills rendered the scene 60 times a second for as
|
||||||
|
// long as a camera was active. (perf wave 2 held for both.)
|
||||||
|
if (video) holdContinuousRender('cctv-projection');
|
||||||
|
else {
|
||||||
|
releaseContinuousRender('cctv-projection');
|
||||||
|
if (restyled || now < renderUntil)
|
||||||
|
governorRequestRender('cctv-projection');
|
||||||
}
|
}
|
||||||
|
|
||||||
layerState._projectionRaf = requestAnimationFrame(tick);
|
layerState._projectionRaf = requestAnimationFrame(tick);
|
||||||
|
|||||||
@@ -0,0 +1,211 @@
|
|||||||
|
import test from 'node:test';
|
||||||
|
import assert from 'node:assert/strict';
|
||||||
|
import { createProjection } from './projection.js';
|
||||||
|
import { createFrames } from './frames.js';
|
||||||
|
import {
|
||||||
|
PROJECTION_SWAP_RENDER_MS,
|
||||||
|
PROJECTION_TEXTURE_SWAP_MS,
|
||||||
|
} from './policy.js';
|
||||||
|
|
||||||
|
/** The projection loop on a hand-cranked clock, with the render governor's calls recorded. */
|
||||||
|
function harness(t, { video = false, showProjection = true } = {}) {
|
||||||
|
let clock = 1000;
|
||||||
|
const frames = [];
|
||||||
|
const original = {
|
||||||
|
now: performance.now,
|
||||||
|
request: globalThis.requestAnimationFrame,
|
||||||
|
cancel: globalThis.cancelAnimationFrame,
|
||||||
|
};
|
||||||
|
performance.now = () => clock;
|
||||||
|
globalThis.requestAnimationFrame = (step) => frames.push(step);
|
||||||
|
globalThis.cancelAnimationFrame = () => frames.splice(0);
|
||||||
|
t.after(() => {
|
||||||
|
performance.now = original.now;
|
||||||
|
globalThis.requestAnimationFrame = original.request;
|
||||||
|
globalThis.cancelAnimationFrame = original.cancel;
|
||||||
|
});
|
||||||
|
|
||||||
|
const holds = new Set();
|
||||||
|
const calls = { hold: 0, requests: 0, draws: 0 };
|
||||||
|
const record = {
|
||||||
|
camera: { id: 'cam-1' },
|
||||||
|
projection: { video: video ? {} : null, mode: video ? 'video' : 'image' },
|
||||||
|
};
|
||||||
|
const scene = { needed: true, swap: false, restyled: false };
|
||||||
|
const state = {
|
||||||
|
_viewer: {},
|
||||||
|
_enabled: true,
|
||||||
|
_showProjection: showProjection,
|
||||||
|
_projectionRaf: 0,
|
||||||
|
_projectionEntities: [],
|
||||||
|
};
|
||||||
|
const projection = createProjection({
|
||||||
|
state,
|
||||||
|
services: {
|
||||||
|
render: {
|
||||||
|
holdContinuousRender(owner) {
|
||||||
|
calls.hold++;
|
||||||
|
holds.add(owner);
|
||||||
|
},
|
||||||
|
releaseContinuousRender: (owner) => holds.delete(owner),
|
||||||
|
governorRequestRender: () => calls.requests++,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
parts: {
|
||||||
|
model: { projectionLoopIsNeeded: () => scene.needed },
|
||||||
|
rendering: { refreshCctvFocusStyles: () => scene.restyled },
|
||||||
|
selection: { getActiveRecord: () => record },
|
||||||
|
frames: {
|
||||||
|
drawProjectionFrame: () => calls.draws++,
|
||||||
|
refreshProjectionTextures() {
|
||||||
|
const swapped = scene.swap;
|
||||||
|
scene.swap = false;
|
||||||
|
return swapped;
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
source: {},
|
||||||
|
});
|
||||||
|
return {
|
||||||
|
projection,
|
||||||
|
state,
|
||||||
|
record,
|
||||||
|
scene,
|
||||||
|
holds,
|
||||||
|
calls,
|
||||||
|
/** Run `count` animation frames 16 ms apart; returns the frames requested in them. */
|
||||||
|
run(count = 1) {
|
||||||
|
const before = calls.requests;
|
||||||
|
for (let i = 0; i < count; i++) {
|
||||||
|
clock += 16;
|
||||||
|
frames.shift()?.();
|
||||||
|
}
|
||||||
|
return calls.requests - before;
|
||||||
|
},
|
||||||
|
advance(ms) {
|
||||||
|
clock += ms;
|
||||||
|
},
|
||||||
|
get queued() {
|
||||||
|
return frames.length;
|
||||||
|
},
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
test('a still-image camera never holds the continuous render loop', (t) => {
|
||||||
|
const h = harness(t);
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
h.run(600);
|
||||||
|
assert.equal(h.calls.hold, 0);
|
||||||
|
assert.equal(h.holds.size, 0);
|
||||||
|
assert.equal(h.calls.draws, 600, 'the loop still polls for a new still');
|
||||||
|
assert.equal(h.queued, 1, 'and stays armed');
|
||||||
|
});
|
||||||
|
|
||||||
|
test('a new still on the plane is rendered, then the scene goes idle again', (t) => {
|
||||||
|
const h = harness(t);
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
// Arming the loop (activation, projection shown) renders its first frames.
|
||||||
|
assert.ok(h.run(5) === 5);
|
||||||
|
h.advance(PROJECTION_SWAP_RENDER_MS);
|
||||||
|
assert.equal(h.run(120), 0, 'an unchanged still asks for no frame');
|
||||||
|
|
||||||
|
h.scene.swap = true;
|
||||||
|
assert.equal(h.run(1), 1, 'the tick that swaps the image asks for a frame');
|
||||||
|
const settling = Math.floor(PROJECTION_SWAP_RENDER_MS / 16) - 2;
|
||||||
|
assert.equal(h.run(settling), settling, 'and so do the ticks while it binds');
|
||||||
|
h.advance(PROJECTION_SWAP_RENDER_MS);
|
||||||
|
assert.equal(h.run(120), 0);
|
||||||
|
assert.equal(h.holds.size, 0);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('activating another camera while the loop runs renders its first frames', (t) => {
|
||||||
|
const h = harness(t);
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
h.advance(PROJECTION_SWAP_RENDER_MS * 2);
|
||||||
|
assert.equal(h.run(10), 0);
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
assert.equal(h.run(10), 10);
|
||||||
|
assert.equal(h.queued, 1, 'still one loop');
|
||||||
|
});
|
||||||
|
|
||||||
|
test('a video camera holds continuous render until it stops being video', (t) => {
|
||||||
|
const h = harness(t, { video: true });
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
h.run(3);
|
||||||
|
assert.deepEqual([...h.holds], ['cctv-projection']);
|
||||||
|
assert.equal(h.calls.draws, 0, 'Cesium updates the video texture itself');
|
||||||
|
// The stream failed over to stills.
|
||||||
|
h.record.projection.video = null;
|
||||||
|
h.run(1);
|
||||||
|
assert.equal(h.holds.size, 0);
|
||||||
|
h.record.projection.video = {};
|
||||||
|
h.run(1);
|
||||||
|
assert.deepEqual([...h.holds], ['cctv-projection']);
|
||||||
|
h.projection.stopProjectionLoop();
|
||||||
|
assert.equal(h.holds.size, 0);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('a focus fade asks for a frame only on the ticks that restyle an icon', (t) => {
|
||||||
|
const h = harness(t, { showProjection: false });
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
h.advance(PROJECTION_SWAP_RENDER_MS * 2);
|
||||||
|
assert.equal(h.run(10), 0);
|
||||||
|
h.scene.restyled = true;
|
||||||
|
assert.equal(h.run(4), 4);
|
||||||
|
h.scene.restyled = false;
|
||||||
|
assert.equal(h.run(10), 0);
|
||||||
|
assert.equal(h.holds.size, 0);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('the loop releases and stops when it has no work', (t) => {
|
||||||
|
const h = harness(t, { video: true });
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
h.run(2);
|
||||||
|
h.scene.needed = false;
|
||||||
|
h.run(1);
|
||||||
|
assert.equal(h.holds.size, 0);
|
||||||
|
assert.equal(h.state._projectionRaf, 0);
|
||||||
|
assert.equal(h.queued, 0);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('refreshProjectionTextures reports whether it put a new image on the plane', (t) => {
|
||||||
|
const previousDocument = globalThis.document;
|
||||||
|
globalThis.document = {
|
||||||
|
createElement: () => ({
|
||||||
|
getContext: () => ({ clearRect() {}, drawImage() {} }),
|
||||||
|
}),
|
||||||
|
};
|
||||||
|
t.after(() => {
|
||||||
|
if (previousDocument === undefined) delete globalThis.document;
|
||||||
|
else globalThis.document = previousDocument;
|
||||||
|
});
|
||||||
|
const frames = createFrames({
|
||||||
|
state: {},
|
||||||
|
services: {},
|
||||||
|
parts: { model: { safeNumber: (value, fallback) => value ?? fallback } },
|
||||||
|
source: {},
|
||||||
|
});
|
||||||
|
const runtime = {
|
||||||
|
mode: 'image',
|
||||||
|
canvas: {},
|
||||||
|
canvasStamp: 1,
|
||||||
|
planeEntity: { show: true },
|
||||||
|
planeMaterial: { image: null },
|
||||||
|
};
|
||||||
|
const record = { projection: runtime };
|
||||||
|
assert.equal(frames.refreshProjectionTextures(record), true);
|
||||||
|
const first = runtime.planeMaterial.image;
|
||||||
|
assert.ok(first);
|
||||||
|
// Unchanged canvas: nothing to render.
|
||||||
|
runtime.lastTextureSwapAt -= PROJECTION_TEXTURE_SWAP_MS;
|
||||||
|
assert.equal(frames.refreshProjectionTextures(record), false);
|
||||||
|
assert.equal(runtime.planeMaterial.image, first);
|
||||||
|
runtime.canvasStamp = 2;
|
||||||
|
assert.equal(frames.refreshProjectionTextures(record), true);
|
||||||
|
assert.notEqual(runtime.planeMaterial.image, first);
|
||||||
|
runtime.planeEntity.show = false;
|
||||||
|
runtime.canvasStamp = 3;
|
||||||
|
runtime.lastTextureSwapAt -= PROJECTION_TEXTURE_SWAP_MS;
|
||||||
|
assert.equal(frames.refreshProjectionTextures(record), false);
|
||||||
|
assert.equal(frames.refreshProjectionTextures({ projection: { mode: 'video' } }), false);
|
||||||
|
});
|
||||||
@@ -61,8 +61,8 @@ export function createRendering({
|
|||||||
!layerState._viewer ||
|
!layerState._viewer ||
|
||||||
!focusPassIsNeeded(target, layerState._activeFocusStyleCount)
|
!focusPassIsNeeded(target, layerState._activeFocusStyleCount)
|
||||||
)
|
)
|
||||||
return;
|
return false;
|
||||||
if (nowMs - layerState._lastFocusStyleAt < 80) return;
|
if (nowMs - layerState._lastFocusStyleAt < 80) return false;
|
||||||
layerState._lastFocusStyleAt = nowMs;
|
layerState._lastFocusStyleAt = nowMs;
|
||||||
const scene = layerState._viewer.scene;
|
const scene = layerState._viewer.scene;
|
||||||
const camera = layerState._viewer.camera;
|
const camera = layerState._viewer.camera;
|
||||||
@@ -82,6 +82,8 @@ export function createRendering({
|
|||||||
baseColorFor: cameraColorFor,
|
baseColorFor: cameraColorFor,
|
||||||
});
|
});
|
||||||
layerState._activeFocusStyleCount = result.activeCount;
|
layerState._activeFocusStyleCount = result.activeCount;
|
||||||
|
// Whether an icon was restyled, so the caller can ask for a frame.
|
||||||
|
return result.writes > 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|||||||
@@ -77,58 +77,3 @@ export function normalizeFeatures(json, kind) {
|
|||||||
};
|
};
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
|
||||||
function partPosition(value) {
|
|
||||||
if (!Array.isArray(value)) return null;
|
|
||||||
const lon = Number(value[0]);
|
|
||||||
const lat = Number(value[1]);
|
|
||||||
if (!Number.isFinite(lon) || !Number.isFinite(lat)) return null;
|
|
||||||
const height = Number(value[2]);
|
|
||||||
return Number.isFinite(height) ? [lon, lat, height] : [lon, lat];
|
|
||||||
}
|
|
||||||
|
|
||||||
function collectParts(geometry, out) {
|
|
||||||
const coordinates = geometry?.coordinates;
|
|
||||||
switch (geometry?.type) {
|
|
||||||
case 'Point': {
|
|
||||||
const point = partPosition(coordinates);
|
|
||||||
if (point) out.points.push(point);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 'MultiPoint':
|
|
||||||
for (const value of coordinates || []) {
|
|
||||||
const point = partPosition(value);
|
|
||||||
if (point) out.points.push(point);
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case 'LineString': {
|
|
||||||
const line = (coordinates || []).map(partPosition).filter(Boolean);
|
|
||||||
if (line.length >= 2) out.lines.push(line);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 'MultiLineString':
|
|
||||||
for (const part of coordinates || []) {
|
|
||||||
const line = (part || []).map(partPosition).filter(Boolean);
|
|
||||||
if (line.length >= 2) out.lines.push(line);
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case 'GeometryCollection':
|
|
||||||
for (const child of geometry.geometries || []) collectParts(child, out);
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* The parts of a feature the layer draws: every line of a LineString or
|
|
||||||
* MultiLineString and every point of a Point or MultiPoint, also inside a
|
|
||||||
* GeometryCollection. Each is [lon, lat] or [lon, lat, height] in degrees
|
|
||||||
* and metres. Polygons are not drawn.
|
|
||||||
* @returns {{lines:number[][][],points:number[][]}}
|
|
||||||
*/
|
|
||||||
export function featureParts(feature) {
|
|
||||||
const out = { lines: [], points: [] };
|
|
||||||
collectParts(feature?.geometry, out);
|
|
||||||
return out;
|
|
||||||
}
|
|
||||||
@@ -10,7 +10,6 @@ export function createSubmarineCableLayer({
|
|||||||
screenSpaceEventHandlerFactory,
|
screenSpaceEventHandlerFactory,
|
||||||
mapStackEventTarget = null,
|
mapStackEventTarget = null,
|
||||||
sweepClock = defaultSweepClock,
|
sweepClock = defaultSweepClock,
|
||||||
createMarkerImage,
|
|
||||||
}) {
|
}) {
|
||||||
if (!source?.fetch || !source.label)
|
if (!source?.fetch || !source.label)
|
||||||
throw new TypeError(
|
throw new TypeError(
|
||||||
@@ -24,7 +23,6 @@ export function createSubmarineCableLayer({
|
|||||||
source,
|
source,
|
||||||
screenSpaceEventHandlerFactory,
|
screenSpaceEventHandlerFactory,
|
||||||
mapStackEventTarget,
|
mapStackEventTarget,
|
||||||
createMarkerImage,
|
|
||||||
};
|
};
|
||||||
parts.rendering = createRendering(context);
|
parts.rendering = createRendering(context);
|
||||||
parts.ingestion = createIngestion(context);
|
parts.ingestion = createIngestion(context);
|
||||||
@@ -42,6 +40,7 @@ export {
|
|||||||
export {
|
export {
|
||||||
cableClassificationTypeForStack,
|
cableClassificationTypeForStack,
|
||||||
cableClassificationTypeForScene,
|
cableClassificationTypeForScene,
|
||||||
|
applyTranslucentMarkerBlend,
|
||||||
} from './surface.js';
|
} from './surface.js';
|
||||||
export {
|
export {
|
||||||
CABLE_REFERENCE_LABEL_WINNER_CAP,
|
CABLE_REFERENCE_LABEL_WINNER_CAP,
|
||||||
|
|||||||
@@ -1,82 +1,27 @@
|
|||||||
import { msg, t } from '../../i18n/index.js';
|
import { msg, t } from '../../i18n/index.js';
|
||||||
import {
|
import {
|
||||||
featureLabel,
|
featureLabel,
|
||||||
featureParts,
|
|
||||||
featureReference,
|
featureReference,
|
||||||
normalizeFeatures,
|
normalizeFeatures,
|
||||||
} from './geometry.js';
|
} from './geometry.js';
|
||||||
import * as Cesium from 'cesium';
|
import * as Cesium from 'cesium';
|
||||||
|
|
||||||
const toCartesian = ([lon, lat, height]) =>
|
const SOURCE_FEATURE_INDEX = '__gevSourceFeatureIndex';
|
||||||
Cesium.Cartesian3.fromDegrees(lon, lat, height ?? 0);
|
|
||||||
|
function indexedCollection(features) {
|
||||||
|
return {
|
||||||
|
type: 'FeatureCollection',
|
||||||
|
features: features.map((feature, index) => ({
|
||||||
|
...feature,
|
||||||
|
properties: {
|
||||||
|
...feature.properties,
|
||||||
|
[SOURCE_FEATURE_INDEX]: index,
|
||||||
|
},
|
||||||
|
})),
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
export function createIngestion({ state, parts, source }) {
|
export function createIngestion({ state, parts, source }) {
|
||||||
/**
|
|
||||||
* Turn the two feature collections into what rendering draws. Every part
|
|
||||||
* of a multipart feature is its own line or marker with its own pick
|
|
||||||
* record, all sharing the feature's reference; a feature gets one
|
|
||||||
* reference stem however many parts it has.
|
|
||||||
*/
|
|
||||||
function describeScene(cableFeatures, landingFeatures) {
|
|
||||||
const lines = [];
|
|
||||||
const markers = [];
|
|
||||||
const references = [];
|
|
||||||
const add = (features, kind, style) => {
|
|
||||||
for (const feature of features) {
|
|
||||||
const reference = featureReference(feature);
|
|
||||||
if (!reference) continue;
|
|
||||||
const label = featureLabel(feature);
|
|
||||||
const base = Cesium.Cartesian3.fromDegrees(
|
|
||||||
reference.lon,
|
|
||||||
reference.lat,
|
|
||||||
0,
|
|
||||||
);
|
|
||||||
const drawn = featureParts(feature);
|
|
||||||
const pick = () =>
|
|
||||||
parts.interaction.registerPick({ kind, reference, label });
|
|
||||||
for (const line of drawn.lines)
|
|
||||||
lines.push({
|
|
||||||
info: pick(),
|
|
||||||
base,
|
|
||||||
positions: line.map(toCartesian),
|
|
||||||
color: style.lineColor(feature),
|
|
||||||
width: style.lineWidth,
|
|
||||||
});
|
|
||||||
for (const point of drawn.points)
|
|
||||||
markers.push({
|
|
||||||
info: pick(),
|
|
||||||
base,
|
|
||||||
position: toCartesian(point),
|
|
||||||
hasHeight: point.length > 2,
|
|
||||||
color: style.color,
|
|
||||||
});
|
|
||||||
references.push({
|
|
||||||
reference,
|
|
||||||
label,
|
|
||||||
kind,
|
|
||||||
color: style.color,
|
|
||||||
feature,
|
|
||||||
});
|
|
||||||
}
|
|
||||||
};
|
|
||||||
add(cableFeatures, 'cable', {
|
|
||||||
color: state.cableColor,
|
|
||||||
lineWidth: 2.5,
|
|
||||||
lineColor: (feature) => {
|
|
||||||
const css = feature?.properties?.color;
|
|
||||||
const color = css && Cesium.Color.fromCssColorString(String(css));
|
|
||||||
return (color || state.cableColor).withAlpha(0.92);
|
|
||||||
},
|
|
||||||
});
|
|
||||||
const landingLine = state.landingColor.withAlpha(0.9);
|
|
||||||
add(landingFeatures, 'landing-point', {
|
|
||||||
color: state.landingColor,
|
|
||||||
lineWidth: 2,
|
|
||||||
lineColor: () => landingLine,
|
|
||||||
});
|
|
||||||
return { lines, markers, references };
|
|
||||||
}
|
|
||||||
|
|
||||||
async function load(viewer) {
|
async function load(viewer) {
|
||||||
if (state._loading || state._loaded) return;
|
if (state._loading || state._loaded) return;
|
||||||
|
|
||||||
@@ -85,10 +30,10 @@ export function createIngestion({ state, parts, source }) {
|
|||||||
state._loadingLabel = t('loading...');
|
state._loadingLabel = t('loading...');
|
||||||
// Ownership token (the militaryAwareness activationId pattern): a
|
// Ownership token (the militaryAwareness activationId pattern): a
|
||||||
// disable/abort followed by a fresh enable starts a NEWER load while this
|
// disable/abort followed by a fresh enable starts a NEWER load while this
|
||||||
// one is still settling. The stale load must bail after its await and
|
// one is still settling. The stale load must bail after every await and
|
||||||
// must never touch shared lifecycle state or the viewer it no longer
|
// must never touch shared lifecycle state or the viewer it no longer
|
||||||
// owns — clearing `_loading`/`_abort` for the successor is how duplicate
|
// owns — clearing `_loading`/`_abort` for the successor is how duplicate
|
||||||
// or post-destroy primitives would get added.
|
// or post-destroy data sources got added.
|
||||||
const generation = ++state._loadGeneration;
|
const generation = ++state._loadGeneration;
|
||||||
const abort = new AbortController();
|
const abort = new AbortController();
|
||||||
state._abort = abort;
|
state._abort = abort;
|
||||||
@@ -96,34 +41,170 @@ export function createIngestion({ state, parts, source }) {
|
|||||||
generation === state._loadGeneration && !abort.signal.aborted;
|
generation === state._loadGeneration && !abort.signal.aborted;
|
||||||
|
|
||||||
try {
|
try {
|
||||||
const { cables: cableJson, landingPoints: landingJson } =
|
let cableJson = state._cachedCableJson;
|
||||||
await source.fetch(abort.signal);
|
let landingJson = state._cachedLandingJson;
|
||||||
// The fetch is the only await: everything after it runs in this one
|
if (!cableJson || !landingJson) {
|
||||||
// turn, so no disable or destroy can land between the ownership check
|
({ cables: cableJson, landingPoints: landingJson } = await source.fetch(
|
||||||
// and the primitives reaching the scene.
|
abort.signal,
|
||||||
if (!owns()) return;
|
));
|
||||||
if (
|
if (!owns()) return;
|
||||||
!Array.isArray(cableJson?.features) ||
|
if (
|
||||||
!Array.isArray(landingJson?.features)
|
!Array.isArray(cableJson?.features) ||
|
||||||
) {
|
!Array.isArray(landingJson?.features)
|
||||||
throw new TypeError(
|
) {
|
||||||
'A cable source must return cables and landingPoints GeoJSON collections',
|
throw new TypeError(
|
||||||
);
|
'A cable source must return cables and landingPoints GeoJSON collections',
|
||||||
|
);
|
||||||
|
}
|
||||||
|
state._cachedCableJson = cableJson;
|
||||||
|
state._cachedLandingJson = landingJson;
|
||||||
}
|
}
|
||||||
|
|
||||||
const cableFeatures = normalizeFeatures(cableJson, 'cable');
|
const cableFeatures = normalizeFeatures(cableJson, 'cable');
|
||||||
const landingFeatures = normalizeFeatures(landingJson, 'landing');
|
const landingFeatures = normalizeFeatures(landingJson, 'landing');
|
||||||
try {
|
|
||||||
parts.rendering.buildScene(
|
const cableDataSource = await Cesium.GeoJsonDataSource.load(
|
||||||
viewer,
|
indexedCollection(cableFeatures),
|
||||||
describeScene(cableFeatures, landingFeatures),
|
{
|
||||||
);
|
clampToGround: true,
|
||||||
} catch (error) {
|
stroke: state.cableColor.withAlpha(0.95),
|
||||||
// Leave nothing half built in the scene.
|
fill: state.cableColor.withAlpha(0.18),
|
||||||
parts.rendering.destroyScene(viewer);
|
strokeWidth: 2,
|
||||||
throw error;
|
markerColor: state.cableColor,
|
||||||
|
markerSize: 6,
|
||||||
|
},
|
||||||
|
);
|
||||||
|
if (!owns()) return;
|
||||||
|
const landingDataSource = await Cesium.GeoJsonDataSource.load(
|
||||||
|
indexedCollection(landingFeatures),
|
||||||
|
{
|
||||||
|
clampToGround: true,
|
||||||
|
stroke: state.landingColor.withAlpha(0.9),
|
||||||
|
fill: state.landingColor.withAlpha(0.35),
|
||||||
|
strokeWidth: 2,
|
||||||
|
markerColor: state.landingColor,
|
||||||
|
markerSize: 6,
|
||||||
|
},
|
||||||
|
);
|
||||||
|
if (!owns()) return;
|
||||||
|
|
||||||
|
cableDataSource.name = `${source.label} Submarine Cables`;
|
||||||
|
landingDataSource.name = `${source.label} Landing Points`;
|
||||||
|
const referenceDataSource = new Cesium.CustomDataSource(
|
||||||
|
`${source.label} Cable References`,
|
||||||
|
);
|
||||||
|
const addedSources = [
|
||||||
|
cableDataSource,
|
||||||
|
landingDataSource,
|
||||||
|
referenceDataSource,
|
||||||
|
];
|
||||||
|
|
||||||
|
// dataSources.add() is itself an await point: Cesium mutates the
|
||||||
|
// collection on a DEFERRED tick, so a disable/destroy racing this
|
||||||
|
// window finds nothing to remove and the adds still materialize
|
||||||
|
// afterwards. Await every add to settlement (allSettled so a partial
|
||||||
|
// failure cannot leave an unawaited add materializing later), then
|
||||||
|
// re-check ownership. Pinned teardown mechanism: disable/destroy never
|
||||||
|
// wait for in-flight adds — the stale generation's own post-await
|
||||||
|
// check here guarantees cleanup by removing exactly the sources THIS
|
||||||
|
// generation added.
|
||||||
|
const addResults = await Promise.allSettled([
|
||||||
|
viewer.dataSources.add(cableDataSource),
|
||||||
|
viewer.dataSources.add(landingDataSource),
|
||||||
|
viewer.dataSources.add(referenceDataSource),
|
||||||
|
]);
|
||||||
|
const rejectedAdd = addResults.find(
|
||||||
|
(result) => result.status === 'rejected',
|
||||||
|
);
|
||||||
|
if (!owns() || rejectedAdd) {
|
||||||
|
// Compensate: every add has settled by now, so removal is effective
|
||||||
|
// (a remove inside the deferred window would have been a no-op).
|
||||||
|
// Remove EVERY generation-local source regardless of settle status:
|
||||||
|
// Cesium's add() pushes into the collection BEFORE raising
|
||||||
|
// dataSourceAdded, so a REJECTED add may still have landed its
|
||||||
|
// mutation. remove() of a never-added source is a harmless no-op.
|
||||||
|
for (const source of addedSources) {
|
||||||
|
try {
|
||||||
|
viewer.dataSources.remove(source, true);
|
||||||
|
} catch {
|
||||||
|
/* collection gone */
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (owns() && rejectedAdd) throw rejectedAdd.reason;
|
||||||
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Await-free commit: the viewer accepted all three sources and this
|
||||||
|
// load still owns the lifecycle.
|
||||||
|
state._cableDataSource = cableDataSource;
|
||||||
|
state._landingDataSource = landingDataSource;
|
||||||
|
state._referenceDataSource = referenceDataSource;
|
||||||
|
|
||||||
|
const cableEntities = state._cableDataSource.entities.values;
|
||||||
|
const landingEntities = state._landingDataSource.entities.values;
|
||||||
|
state._pickByEntity = new WeakMap();
|
||||||
|
state._referenceRecords = [];
|
||||||
|
state._surfaceRecords = [];
|
||||||
|
|
||||||
|
// Cesium expands multipart geometry into several entities and suffixes
|
||||||
|
// colliding IDs. Its copied properties retain this source index even
|
||||||
|
// when a provider has no ID, so every segment keeps the right owner.
|
||||||
|
const cableReferences = new Set();
|
||||||
|
cableEntities.forEach((entity) => {
|
||||||
|
const index = entity.properties?.[SOURCE_FEATURE_INDEX]?.getValue();
|
||||||
|
const feature = cableFeatures[index];
|
||||||
|
const reference = featureReference(feature);
|
||||||
|
if (!reference) return;
|
||||||
|
|
||||||
|
parts.rendering.styleCableEntity(entity, feature);
|
||||||
|
parts.interaction.registerPickEntity(entity, {
|
||||||
|
kind: 'cable',
|
||||||
|
reference,
|
||||||
|
label: featureLabel(feature),
|
||||||
|
});
|
||||||
|
state._surfaceRecords.push({
|
||||||
|
entity,
|
||||||
|
base: Cesium.Cartesian3.fromDegrees(reference.lon, reference.lat, 0),
|
||||||
|
});
|
||||||
|
if (cableReferences.has(index)) return;
|
||||||
|
cableReferences.add(index);
|
||||||
|
parts.rendering.addReferenceStem({
|
||||||
|
reference,
|
||||||
|
label: featureLabel(feature),
|
||||||
|
kind: 'cable',
|
||||||
|
color: state.cableColor,
|
||||||
|
feature,
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
const landingReferences = new Set();
|
||||||
|
landingEntities.forEach((entity) => {
|
||||||
|
const index = entity.properties?.[SOURCE_FEATURE_INDEX]?.getValue();
|
||||||
|
const feature = landingFeatures[index];
|
||||||
|
const reference = featureReference(feature);
|
||||||
|
if (!reference) return;
|
||||||
|
|
||||||
|
parts.rendering.styleLandingEntity(entity, feature);
|
||||||
|
parts.interaction.registerPickEntity(entity, {
|
||||||
|
kind: 'landing-point',
|
||||||
|
reference,
|
||||||
|
label: featureLabel(feature),
|
||||||
|
});
|
||||||
|
state._surfaceRecords.push({
|
||||||
|
entity,
|
||||||
|
base: Cesium.Cartesian3.fromDegrees(reference.lon, reference.lat, 0),
|
||||||
|
});
|
||||||
|
if (landingReferences.has(index)) return;
|
||||||
|
landingReferences.add(index);
|
||||||
|
parts.rendering.addReferenceStem({
|
||||||
|
reference,
|
||||||
|
label: featureLabel(feature),
|
||||||
|
kind: 'landing-point',
|
||||||
|
color: state.landingColor,
|
||||||
|
feature,
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
state._count = cableFeatures.length + landingFeatures.length;
|
state._count = cableFeatures.length + landingFeatures.length;
|
||||||
state._loaded = true;
|
state._loaded = true;
|
||||||
state._lastUpdate = Date.now();
|
state._lastUpdate = Date.now();
|
||||||
|
|||||||
@@ -2,10 +2,9 @@ import * as Cesium from 'cesium';
|
|||||||
import { isPointerFree } from '../../data/inputOwnership.js';
|
import { isPointerFree } from '../../data/inputOwnership.js';
|
||||||
|
|
||||||
export function createInteraction({ state, screenSpaceEventHandlerFactory }) {
|
export function createInteraction({ state, screenSpaceEventHandlerFactory }) {
|
||||||
/** Every drawn part carries its own record as the Cesium pick id. */
|
function registerPickEntity(entity, info) {
|
||||||
function registerPick(info) {
|
entity.__gevTeleGeography = info;
|
||||||
state._pickRecords.add(info);
|
state._pickByEntity.set(entity, info);
|
||||||
return info;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
function beginInteraction(viewer) {
|
function beginInteraction(viewer) {
|
||||||
@@ -23,8 +22,32 @@ export function createInteraction({ state, screenSpaceEventHandlerFactory }) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
function resolvePickRecord(picked) {
|
function resolvePickRecord(picked) {
|
||||||
const info = picked?.id;
|
if (!picked) return null;
|
||||||
return info && state._pickRecords.has(info) ? info : null;
|
const primitive = picked.primitive;
|
||||||
|
if (primitive) {
|
||||||
|
const primitiveInfo = state._pickByEntity.get(primitive);
|
||||||
|
if (primitiveInfo) return primitiveInfo;
|
||||||
|
if (primitive.__gevTeleGeography) return primitive.__gevTeleGeography;
|
||||||
|
if (
|
||||||
|
primitive.id &&
|
||||||
|
typeof primitive.id === 'object' &&
|
||||||
|
primitive.id.reference
|
||||||
|
) {
|
||||||
|
return primitive.id;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
const entity = picked.id;
|
||||||
|
if (entity) {
|
||||||
|
const entityInfo = state._pickByEntity.get(entity);
|
||||||
|
if (entityInfo) return entityInfo;
|
||||||
|
if (entity.__gevTeleGeography) return entity.__gevTeleGeography;
|
||||||
|
if (entity.id && typeof entity.id === 'object' && entity.id.reference) {
|
||||||
|
return entity.id;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return null;
|
||||||
}
|
}
|
||||||
|
|
||||||
function flyToReference(viewer, reference) {
|
function flyToReference(viewer, reference) {
|
||||||
@@ -47,7 +70,7 @@ export function createInteraction({ state, screenSpaceEventHandlerFactory }) {
|
|||||||
});
|
});
|
||||||
}
|
}
|
||||||
return {
|
return {
|
||||||
registerPick,
|
registerPickEntity,
|
||||||
beginInteraction,
|
beginInteraction,
|
||||||
resolvePickRecord,
|
resolvePickRecord,
|
||||||
flyToReference,
|
flyToReference,
|
||||||
|
|||||||
@@ -38,13 +38,12 @@ export function createLifecycle({ state, parts, source, mapStackEventTarget }) {
|
|||||||
// never emit moveEnd — reach the motion fallback. No render is
|
// never emit moveEnd — reach the motion fallback. No render is
|
||||||
// requested for a fallback sweep: it only fires while the camera is
|
// requested for a fallback sweep: it only fires while the camera is
|
||||||
// already moving, so frames are flowing by construction.
|
// already moving, so frames are flowing by construction.
|
||||||
if (!state._enabled || !state._loaded) return;
|
if (
|
||||||
// Markers left over from the last sweep, a few per frame; line
|
!state._enabled ||
|
||||||
// shows and rebuilt stems waiting for their geometry.
|
!state._loaded ||
|
||||||
parts.rendering.revealLandingMarkers();
|
!state._referenceSweepGate.shouldRun(viewer.camera)
|
||||||
parts.rendering.syncLineShow();
|
)
|
||||||
parts.rendering.settleStems();
|
return;
|
||||||
if (!state._referenceSweepGate.shouldRun(viewer.camera)) return;
|
|
||||||
parts.rendering.updateReferenceVisibility();
|
parts.rendering.updateReferenceVisibility();
|
||||||
},
|
},
|
||||||
);
|
);
|
||||||
@@ -81,15 +80,10 @@ export function createLifecycle({ state, parts, source, mapStackEventTarget }) {
|
|||||||
state._loading = false;
|
state._loading = false;
|
||||||
state._loadingLabel = '';
|
state._loadingLabel = '';
|
||||||
}
|
}
|
||||||
// Hide what is built and keep it: a hidden primitive is skipped by
|
// Free the entities rather than hide them; enable() rebuilds from the
|
||||||
// the scene, so it costs nothing per frame, and the next enable shows
|
// cached JSON. An in-flight load's own post-await ownership check
|
||||||
// it again without a rebuild. Only the stems go: they are sized for
|
// removes whatever that stale generation adds later.
|
||||||
// the view and the next sweep redraws them in a worker. An in-flight load's own post-await
|
parts.rendering.releaseDataSources(state._viewer);
|
||||||
// ownership check stops that stale generation from building anything.
|
|
||||||
state._pendingLandingReveals.length = 0;
|
|
||||||
parts.rendering.dropStems();
|
|
||||||
parts.rendering.updateVisibility();
|
|
||||||
state._viewer?.scene?.requestRender?.();
|
|
||||||
},
|
},
|
||||||
|
|
||||||
update(viewer) {
|
update(viewer) {
|
||||||
@@ -98,7 +92,9 @@ export function createLifecycle({ state, parts, source, mapStackEventTarget }) {
|
|||||||
|
|
||||||
destroy(viewer) {
|
destroy(viewer) {
|
||||||
if (state._abort) state._abort.abort();
|
if (state._abort) state._abort.abort();
|
||||||
parts.rendering.destroyScene(viewer || state._viewer);
|
parts.rendering.releaseDataSources(viewer || state._viewer);
|
||||||
|
state._cachedCableJson = null;
|
||||||
|
state._cachedLandingJson = null;
|
||||||
// hide() clears every published host entry and goes invisible while
|
// hide() clears every published host entry and goes invisible while
|
||||||
// keeping the publisher reusable — the legacy layer supported re-init
|
// keeping the publisher reusable — the legacy layer supported re-init
|
||||||
// after destroy, and hidden publishers already drop late publishes.
|
// after destroy, and hidden publishers already drop late publishes.
|
||||||
@@ -132,6 +128,16 @@ export function createLifecycle({ state, parts, source, mapStackEventTarget }) {
|
|||||||
state._error = null;
|
state._error = null;
|
||||||
state._lastUpdate = null;
|
state._lastUpdate = null;
|
||||||
state._loadingLabel = '';
|
state._loadingLabel = '';
|
||||||
|
state._cableDataSource = null;
|
||||||
|
state._landingDataSource = null;
|
||||||
|
state._referenceDataSource = null;
|
||||||
|
state._referenceRecords = [];
|
||||||
|
state._surfaceRecords = [];
|
||||||
|
state._pickByEntity = new WeakMap();
|
||||||
|
state._referenceLabelCount = 0;
|
||||||
|
state._publishScratch.length = 0;
|
||||||
|
state._markerBlendDone = false;
|
||||||
|
state._markerBlendInvariantWarned = false;
|
||||||
parts.rendering.resetPublishSignature();
|
parts.rendering.resetPublishSignature();
|
||||||
state._referenceSweepGate.reset();
|
state._referenceSweepGate.reset();
|
||||||
},
|
},
|
||||||
|
|||||||
@@ -41,7 +41,7 @@ export function selectCableReferenceLabelWinners(
|
|||||||
.sort(
|
.sort(
|
||||||
(a, b) =>
|
(a, b) =>
|
||||||
a.distanceM - b.distanceM ||
|
a.distanceM - b.distanceM ||
|
||||||
String(a.id || '').localeCompare(String(b.id || '')),
|
String(a.entity?.id || '').localeCompare(String(b.entity?.id || '')),
|
||||||
)
|
)
|
||||||
.slice(0, cap);
|
.slice(0, cap);
|
||||||
}
|
}
|
||||||
@@ -248,15 +248,16 @@ export function createCableReferenceSweepGate({
|
|||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Recompute one stem tip on the sweep cadence. The tip is moved in place, so
|
* Recompute one staticized stem on the sweep cadence. Replaces the former
|
||||||
* the label entry keeps pointing at it, and only when the camera-scaled tip
|
* per-frame `CallbackProperty` pair: constant properties are redefined only
|
||||||
* moved beyond the settle epsilon; the tip point follows with one buffer
|
* when the camera-scaled tip moved beyond the settle epsilon, and the two
|
||||||
* write, and the caller redraws the stems when any tip moved.
|
* preallocated position buffers alternate so each real change raises exactly
|
||||||
* @param {object} record Reference record with point/base/tip/nextTip.
|
* one geometry notification (the localGeojson double-buffer pattern).
|
||||||
|
* @param {object} record Reference record with entity/base/tip/nextTip/buffers.
|
||||||
* @param {Cesium.Cartesian3} cameraPositionWC
|
* @param {Cesium.Cartesian3} cameraPositionWC
|
||||||
* @param {number} canvasHeight CSS-pixel canvas height.
|
* @param {number} canvasHeight CSS-pixel canvas height.
|
||||||
* @param {number} fov Camera frustum field of view (radians).
|
* @param {number} fov Camera frustum field of view (radians).
|
||||||
* @returns {boolean} True when the tip moved.
|
* @returns {boolean} True when the stem geometry was redefined.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
export function updateCableReferenceStem(
|
export function updateCableReferenceStem(
|
||||||
@@ -288,7 +289,13 @@ export function updateCableReferenceStem(
|
|||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
Cesium.Cartesian3.clone(record.nextTip, record.tip);
|
Cesium.Cartesian3.clone(record.nextTip, record.tip);
|
||||||
record.point.position = record.tip;
|
record.stemPositionBufferIndex = 1 - record.stemPositionBufferIndex;
|
||||||
|
const stemPositions =
|
||||||
|
record.stemPositionBuffers[record.stemPositionBufferIndex];
|
||||||
|
stemPositions[0] = record.base;
|
||||||
|
stemPositions[1] = record.tip;
|
||||||
|
record.entity.position.setValue(record.tip);
|
||||||
|
record.entity.polyline.positions.setValue(stemPositions);
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -1,3 +1,5 @@
|
|||||||
|
import * as Cesium from 'cesium';
|
||||||
|
|
||||||
export const BASE_CABLE_COLOR = '#39d5ff';
|
export const BASE_CABLE_COLOR = '#39d5ff';
|
||||||
|
|
||||||
export const BASE_LANDING_COLOR = '#8fffd2';
|
export const BASE_LANDING_COLOR = '#8fffd2';
|
||||||
@@ -64,22 +66,6 @@ export const CABLE_LABEL_DEPTH_DECISION = Object.freeze({
|
|||||||
depthTested: false,
|
depthTested: false,
|
||||||
});
|
});
|
||||||
|
|
||||||
/**
|
|
||||||
* Landing markers clamped to the ground per rendered frame. A marker is put
|
|
||||||
* on the surface the first time it comes into view, and that reads the
|
|
||||||
* terrain height under it. Doing it for all 1,917 in the frame after the
|
|
||||||
* layer was switched on was a single task (measured 1.2 s on a loaded
|
|
||||||
* globe); a few dozen per frame keeps each frame short and the markers still
|
|
||||||
* fill in within a second. A marker is clamped once: after that Cesium moves
|
|
||||||
* it as terrain loads, and hiding or showing it reads nothing.
|
|
||||||
*/
|
|
||||||
|
|
||||||
export const CABLE_LANDING_REVEALS_PER_FRAME = 48;
|
|
||||||
|
|
||||||
/** Pixel size of the marker drawn for point geometry (GeoJSON's small pin). */
|
|
||||||
|
|
||||||
export const CABLE_MARKER_SIZE = 6;
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* `MAP_STACKS` ids that render imagery on the SHOWN Cesium globe (the ion
|
* `MAP_STACKS` ids that render imagery on the SHOWN Cesium globe (the ion
|
||||||
* Bing stacks + OSM). Deliberately an explicit allowlist, not "anything that
|
* Bing stacks + OSM). Deliberately an explicit allowlist, not "anything that
|
||||||
@@ -95,6 +81,19 @@ export const CABLE_GLOBE_STACK_IDS = Object.freeze(
|
|||||||
new Set(['bing-aerial', 'bing-labels', 'esri-imagery', 'osm']),
|
new Set(['bing-aerial', 'bing-labels', 'esri-imagery', 'osm']),
|
||||||
);
|
);
|
||||||
|
|
||||||
|
/** EntityCluster's private marker collections and their required types. */
|
||||||
|
|
||||||
|
export const MARKER_COLLECTION_EXPECTATIONS = Object.freeze([
|
||||||
|
Object.freeze({
|
||||||
|
key: '_billboardCollection',
|
||||||
|
type: Cesium.BillboardCollection,
|
||||||
|
}),
|
||||||
|
Object.freeze({
|
||||||
|
key: '_pointCollection',
|
||||||
|
type: Cesium.PointPrimitiveCollection,
|
||||||
|
}),
|
||||||
|
]);
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Monotonic clock for the sweep gate's motion probe. A hoisted declaration:
|
* Monotonic clock for the sweep gate's motion probe. A hoisted declaration:
|
||||||
* the module's `export default createTeleGeographySubmarineCableLayer()`
|
* the module's `export default createTeleGeographySubmarineCableLayer()`
|
||||||
|
|||||||
@@ -1,8 +1,8 @@
|
|||||||
import * as Cesium from 'cesium';
|
import * as Cesium from 'cesium';
|
||||||
import {
|
import {
|
||||||
CABLE_LANDING_REVEALS_PER_FRAME,
|
probeTranslucentMarkerBlend,
|
||||||
CABLE_MARKER_SIZE,
|
commitTranslucentMarkerBlend,
|
||||||
} from './policy.js';
|
} from './surface.js';
|
||||||
import {
|
import {
|
||||||
clampLabel,
|
clampLabel,
|
||||||
createCableOverlayEntry,
|
createCableOverlayEntry,
|
||||||
@@ -11,13 +11,7 @@ import {
|
|||||||
cableReferencePriority,
|
cableReferencePriority,
|
||||||
} from './overlay.js';
|
} from './overlay.js';
|
||||||
|
|
||||||
const defaultMarkerImage = (color) =>
|
export function createRendering({ state }) {
|
||||||
new Cesium.PinBuilder().fromColor(color, CABLE_MARKER_SIZE);
|
|
||||||
|
|
||||||
export function createRendering({
|
|
||||||
state,
|
|
||||||
createMarkerImage = defaultMarkerImage,
|
|
||||||
}) {
|
|
||||||
function resetPublishSignature() {
|
function resetPublishSignature() {
|
||||||
state._lastPublishedIds.length = 0;
|
state._lastPublishedIds.length = 0;
|
||||||
state._lastPublishedPriorities.length = 0;
|
state._lastPublishedPriorities.length = 0;
|
||||||
@@ -25,131 +19,129 @@ export function createRendering({
|
|||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Build everything the layer draws, in one synchronous pass with no entity
|
* Remove the three data sources from the viewer and forget the built
|
||||||
* per feature. The layer used to load two GeoJsonDataSources and a
|
* entities. Hiding them (`show = false`) is NOT enough: Cesium's
|
||||||
* CustomDataSource: 6,459 entities whose creation held about 1 GB of
|
* DataSourceDisplay still walks every visualizer of a hidden source on
|
||||||
* short-lived heap, whose visualizers ran 100–250 ms tasks whenever shows
|
* every frame, and the thousands of hidden polylines/billboards keep
|
||||||
* or stems changed, and whose removal on disable was a 150 ms task. These
|
* costing CPU and GC pressure long after the user toggled the layer off —
|
||||||
* are the primitives Cesium built from those entities, made directly:
|
* that is the "everything gets sluggish after I turn layers off" report.
|
||||||
*
|
* The fetched JSON stays cached, so the next enable rebuilds without a
|
||||||
* - lines: one GroundPolylinePrimitive, a colour and a show flag per line
|
* network round trip or a re-parse.
|
||||||
* (Cesium's own batch for clamped colour polylines), tessellated in a
|
|
||||||
* worker;
|
|
||||||
* - point markers: one BillboardCollection, each billboard hidden and
|
|
||||||
* unclamped until revealLandingMarkers puts it on the ground;
|
|
||||||
* - references: one PointPrimitiveCollection for the tips, whose positions
|
|
||||||
* and shows are plain buffer writes, and one Primitive of polylines for
|
|
||||||
* the stems (see rebuildStems).
|
|
||||||
*
|
|
||||||
* `lines`, `markers` and `references` come from ingestion; each line and
|
|
||||||
* marker carries the pick record Cesium returns as the pick id.
|
|
||||||
*/
|
*/
|
||||||
|
|
||||||
function buildScene(viewer, { lines, markers, references }) {
|
function releaseDataSources(viewer) {
|
||||||
const scene = viewer.scene;
|
const sources = [
|
||||||
state._lineRecords = [];
|
state._cableDataSource,
|
||||||
state._markerRecords = [];
|
state._landingDataSource,
|
||||||
|
state._referenceDataSource,
|
||||||
|
];
|
||||||
|
state._cableDataSource = null;
|
||||||
|
state._landingDataSource = null;
|
||||||
|
state._referenceDataSource = null;
|
||||||
state._referenceRecords = [];
|
state._referenceRecords = [];
|
||||||
state._pendingLandingReveals.length = 0;
|
state._surfaceRecords = [];
|
||||||
|
state._pickByEntity = new WeakMap();
|
||||||
if (lines.length) {
|
state._referenceLabelCount = 0;
|
||||||
// The entity display gave every line this attribute too. It is a float
|
state._publishScratch.length = 0;
|
||||||
// attribute, and with one present Cesium keeps the per-line width as a
|
// The blend pass targets the collections being dropped; the rebuilt
|
||||||
// float; without it the 2.5 px width is stored as a byte and draws 2 px.
|
// sources need their own pass.
|
||||||
const always =
|
state._markerBlendDone = false;
|
||||||
Cesium.DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition(
|
state._loaded = false;
|
||||||
new Cesium.DistanceDisplayCondition(),
|
state._referenceSweepGate.reset();
|
||||||
);
|
for (const source of sources) {
|
||||||
const instances = lines.map(
|
if (!source) continue;
|
||||||
(line) =>
|
try {
|
||||||
new Cesium.GeometryInstance({
|
viewer?.dataSources?.remove(source, true);
|
||||||
id: line.info,
|
} catch {
|
||||||
geometry: new Cesium.GroundPolylineGeometry({
|
/* collection gone */
|
||||||
positions: line.positions,
|
|
||||||
width: line.width,
|
|
||||||
// GeoJSON lines are rhumb lines (GeoJsonDataSource's choice).
|
|
||||||
arcType: Cesium.ArcType.RHUMB,
|
|
||||||
}),
|
|
||||||
attributes: {
|
|
||||||
color: Cesium.ColorGeometryInstanceAttribute.fromColor(
|
|
||||||
line.color,
|
|
||||||
),
|
|
||||||
show: new Cesium.ShowGeometryInstanceAttribute(true),
|
|
||||||
distanceDisplayCondition: always,
|
|
||||||
},
|
|
||||||
}),
|
|
||||||
);
|
|
||||||
state._cablePrimitive = scene.groundPrimitives.add(
|
|
||||||
new Cesium.GroundPolylinePrimitive({
|
|
||||||
geometryInstances: instances,
|
|
||||||
appearance: new Cesium.PolylineColorAppearance(),
|
|
||||||
classificationType: state._classificationType,
|
|
||||||
asynchronous: true,
|
|
||||||
show: state._enabled,
|
|
||||||
}),
|
|
||||||
);
|
|
||||||
for (const line of lines)
|
|
||||||
state._lineRecords.push({
|
|
||||||
info: line.info,
|
|
||||||
base: line.base,
|
|
||||||
visible: true,
|
|
||||||
shown: true,
|
|
||||||
attributes: null,
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
if (markers.length) {
|
|
||||||
// Every marker is translucent, so one blend pass, not Cesium's two.
|
|
||||||
const billboards = scene.primitives.add(
|
|
||||||
new Cesium.BillboardCollection({
|
|
||||||
scene,
|
|
||||||
blendOption: Cesium.BlendOption.TRANSLUCENT,
|
|
||||||
show: state._enabled,
|
|
||||||
}),
|
|
||||||
);
|
|
||||||
state._markerBillboards = billboards;
|
|
||||||
const images = new Map();
|
|
||||||
for (const marker of markers) {
|
|
||||||
const key = marker.color.toCssHexString();
|
|
||||||
let image = images.get(key);
|
|
||||||
if (!image) {
|
|
||||||
image = {
|
|
||||||
id: `gev-cable-marker-${key}`,
|
|
||||||
source: createMarkerImage(marker.color),
|
|
||||||
};
|
|
||||||
images.set(key, image);
|
|
||||||
}
|
|
||||||
const billboard = billboards.add({
|
|
||||||
id: marker.info,
|
|
||||||
position: marker.position,
|
|
||||||
verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
|
|
||||||
show: false,
|
|
||||||
});
|
|
||||||
billboard.setImage(image.id, image.source);
|
|
||||||
state._markerRecords.push({
|
|
||||||
info: marker.info,
|
|
||||||
marker: billboard,
|
|
||||||
base: marker.base,
|
|
||||||
// A position with its own height is drawn there, as before.
|
|
||||||
clamped: marker.hasHeight,
|
|
||||||
visible: false,
|
|
||||||
});
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
if (references.length) {
|
function updateVisibility() {
|
||||||
state._referencePoints = scene.primitives.add(
|
if (state._cableDataSource) state._cableDataSource.show = state._enabled;
|
||||||
new Cesium.PointPrimitiveCollection({
|
if (state._landingDataSource)
|
||||||
blendOption: Cesium.BlendOption.TRANSLUCENT,
|
state._landingDataSource.show = state._enabled;
|
||||||
show: state._enabled,
|
if (state._referenceDataSource)
|
||||||
}),
|
state._referenceDataSource.show = state._enabled;
|
||||||
);
|
}
|
||||||
for (const reference of references) addReferenceStem(reference);
|
|
||||||
|
function styleCableEntity(entity, feature) {
|
||||||
|
if (!entity?.polyline) return;
|
||||||
|
const color = feature?.properties?.color
|
||||||
|
? Cesium.Color.fromCssColorString(String(feature.properties.color))
|
||||||
|
: state.cableColor;
|
||||||
|
entity.polyline.material = color.withAlpha(0.92);
|
||||||
|
entity.polyline.width = 2.5;
|
||||||
|
entity.polyline.clampToGround = true;
|
||||||
|
entity.polyline.classificationType = state._classificationType;
|
||||||
|
entity.show = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Apply the single translucent blend pass to the landing-billboard and
|
||||||
|
* reference-point collections. Landing entities carry only billboards and
|
||||||
|
* reference entities only points, so completion is one applied collection
|
||||||
|
* per source; a failed shape probe disables the optimization permanently
|
||||||
|
* for this session and says so loudly in dev builds.
|
||||||
|
* Both sources are probed BEFORE either is committed, so the helper's
|
||||||
|
* "defaults untouched on shape drift" fallback holds across the pair too —
|
||||||
|
* a reference-source failure can never leave the landing source already
|
||||||
|
* forced to TRANSLUCENT.
|
||||||
|
*/
|
||||||
|
|
||||||
|
function applyMarkerBlendOnce() {
|
||||||
|
const landing = probeTranslucentMarkerBlend(state._landingDataSource);
|
||||||
|
const reference = probeTranslucentMarkerBlend(state._referenceDataSource);
|
||||||
|
if (landing.invariantFailed || reference.invariantFailed) {
|
||||||
|
state._markerBlendDone = true;
|
||||||
|
if (!state._markerBlendInvariantWarned && import.meta.env?.DEV === true) {
|
||||||
|
state._markerBlendInvariantWarned = true;
|
||||||
|
console.error(
|
||||||
|
'[Data:telegeography-submarine-cables] EntityCluster marker-collection ' +
|
||||||
|
'shape changed — single-pass translucent blend skipped; markers fall ' +
|
||||||
|
"back to Cesium's default two-pass blend.",
|
||||||
|
);
|
||||||
|
}
|
||||||
|
return;
|
||||||
}
|
}
|
||||||
state._lineShowDirty = false;
|
const landingBlend = commitTranslucentMarkerBlend(landing);
|
||||||
|
const referenceBlend = commitTranslucentMarkerBlend(reference);
|
||||||
|
if (landingBlend.applied > 0 && referenceBlend.applied > 0)
|
||||||
|
state._markerBlendDone = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Re-classify every cable ground line for the active surface. One batched
|
||||||
|
* ground-primitive rebuild per stack switch — never per frame.
|
||||||
|
* @param {Cesium.ClassificationType} next
|
||||||
|
*/
|
||||||
|
|
||||||
|
function applyCableClassification(next) {
|
||||||
|
if (next === undefined || next === state._classificationType) return;
|
||||||
|
state._classificationType = next;
|
||||||
|
if (!state._cableDataSource) return;
|
||||||
|
const entities = state._cableDataSource.entities.values;
|
||||||
|
for (let i = 0; i < entities.length; i++) {
|
||||||
|
const polyline = entities[i].polyline;
|
||||||
|
if (polyline) polyline.classificationType = next;
|
||||||
|
}
|
||||||
|
state._viewer?.scene?.requestRender?.();
|
||||||
|
}
|
||||||
|
|
||||||
|
function styleLandingEntity(entity, feature) {
|
||||||
|
if (!entity?.point) return;
|
||||||
|
entity.point.color = state.landingColor.withAlpha(0.92);
|
||||||
|
entity.point.pixelSize = feature?.properties?.is_tbd ? 6 : 7;
|
||||||
|
entity.point.outlineColor = state.cableOutline;
|
||||||
|
entity.point.outlineWidth = 1;
|
||||||
|
entity.point.disableDepthTestDistance = 0;
|
||||||
|
entity.show = true;
|
||||||
}
|
}
|
||||||
|
|
||||||
function addReferenceStem({ reference, label, kind, color, feature }) {
|
function addReferenceStem({ reference, label, kind, color, feature }) {
|
||||||
|
if (!state._referenceDataSource || !reference) return;
|
||||||
|
|
||||||
const base = Cesium.Cartesian3.fromDegrees(reference.lon, reference.lat, 0);
|
const base = Cesium.Cartesian3.fromDegrees(reference.lon, reference.lat, 0);
|
||||||
const tip = Cesium.Cartesian3.fromDegrees(
|
const tip = Cesium.Cartesian3.fromDegrees(
|
||||||
reference.lon,
|
reference.lon,
|
||||||
@@ -162,31 +154,42 @@ export function createRendering({
|
|||||||
label,
|
label,
|
||||||
featureId: feature?.id || feature?.properties?.id || null,
|
featureId: feature?.id || feature?.properties?.id || null,
|
||||||
};
|
};
|
||||||
state._pickRecords.add(info);
|
|
||||||
const pointColor = color.withAlpha(kind === 'cable' ? 0.84 : 0.94);
|
const pointColor = color.withAlpha(kind === 'cable' ? 0.84 : 0.94);
|
||||||
// The tip is moved in place on the sweep cadence (overlay.js), never by a
|
const stemColor = color.withAlpha(kind === 'cable' ? 0.58 : 0.68);
|
||||||
// per-frame callback.
|
// Constant properties on the sweep cadence, never per-frame callbacks:
|
||||||
const point = state._referencePoints.add({
|
// the sweep redefines them through the alternating buffers below.
|
||||||
id: info,
|
const stemPositionBuffers = [
|
||||||
position: tip,
|
[base, tip],
|
||||||
pixelSize: kind === 'cable' ? 7 : 8,
|
[base, tip],
|
||||||
color: pointColor,
|
];
|
||||||
outlineColor: Cesium.Color.BLACK.withAlpha(0.65),
|
|
||||||
outlineWidth: 1,
|
const entity = state._referenceDataSource.entities.add({
|
||||||
disableDepthTestDistance: 0,
|
|
||||||
show: false,
|
|
||||||
});
|
|
||||||
const record = {
|
|
||||||
id: `${kind}-reference-${state._referenceRecords.length}-${info.featureId || 'feature'}`,
|
id: `${kind}-reference-${state._referenceRecords.length}-${info.featureId || 'feature'}`,
|
||||||
info,
|
position: tip,
|
||||||
point,
|
polyline: {
|
||||||
|
positions: stemPositionBuffers[0],
|
||||||
|
width: kind === 'cable' ? 2 : 2.4,
|
||||||
|
material: new Cesium.ColorMaterialProperty(stemColor),
|
||||||
|
},
|
||||||
|
point: {
|
||||||
|
pixelSize: kind === 'cable' ? 7 : 8,
|
||||||
|
color: pointColor,
|
||||||
|
outlineColor: Cesium.Color.BLACK.withAlpha(0.65),
|
||||||
|
outlineWidth: 1,
|
||||||
|
disableDepthTestDistance: 0,
|
||||||
|
},
|
||||||
|
});
|
||||||
|
|
||||||
|
entity.__gevTeleGeography = info;
|
||||||
|
state._pickByEntity.set(entity, info);
|
||||||
|
const record = {
|
||||||
|
id: entity.id,
|
||||||
|
entity,
|
||||||
base,
|
base,
|
||||||
tip,
|
tip,
|
||||||
nextTip: Cesium.Cartesian3.clone(tip),
|
nextTip: Cesium.Cartesian3.clone(tip),
|
||||||
stemColor: Cesium.ColorGeometryInstanceAttribute.fromColor(
|
stemPositionBuffers,
|
||||||
color.withAlpha(kind === 'cable' ? 0.58 : 0.68),
|
stemPositionBufferIndex: 0,
|
||||||
),
|
|
||||||
stemWidth: kind === 'cable' ? 2 : 2.4,
|
|
||||||
reference,
|
reference,
|
||||||
kind,
|
kind,
|
||||||
label: clampLabel(label),
|
label: clampLabel(label),
|
||||||
@@ -198,212 +201,6 @@ export function createRendering({
|
|||||||
state._referenceRecords.push(record);
|
state._referenceRecords.push(record);
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
|
||||||
* Draw the stems of the references now in view, base to tip. Stems are one
|
|
||||||
* static polyline primitive, as the entity display batched them: nothing
|
|
||||||
* runs for it per frame, and a stem's length cannot change without new
|
|
||||||
* geometry. So a sweep that moved a tip or changed which references are
|
|
||||||
* in view builds a replacement in a worker, and settleStems swaps it in
|
|
||||||
* once it is ready; the previous stems stay until then. A sweep that
|
|
||||||
* changed nothing builds nothing.
|
|
||||||
*/
|
|
||||||
|
|
||||||
function rebuildStems() {
|
|
||||||
const primitives = state._viewer?.scene?.primitives;
|
|
||||||
if (!primitives) return;
|
|
||||||
if (state._stemPrimitivePending) {
|
|
||||||
// Superseded before it was ever shown.
|
|
||||||
primitives.remove(state._stemPrimitivePending);
|
|
||||||
state._stemPrimitivePending = null;
|
|
||||||
}
|
|
||||||
const instances = [];
|
|
||||||
for (const record of state._referenceRecords) {
|
|
||||||
if (!record.visible) continue;
|
|
||||||
instances.push(
|
|
||||||
new Cesium.GeometryInstance({
|
|
||||||
id: record.info,
|
|
||||||
geometry: new Cesium.PolylineGeometry({
|
|
||||||
positions: [record.base, record.tip],
|
|
||||||
width: record.stemWidth,
|
|
||||||
vertexFormat: Cesium.PolylineColorAppearance.VERTEX_FORMAT,
|
|
||||||
}),
|
|
||||||
attributes: { color: record.stemColor },
|
|
||||||
}),
|
|
||||||
);
|
|
||||||
}
|
|
||||||
state._stemsDirty = false;
|
|
||||||
if (!instances.length) {
|
|
||||||
if (state._stemPrimitive) primitives.remove(state._stemPrimitive);
|
|
||||||
state._stemPrimitive = null;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
state._stemPrimitivePending = primitives.add(
|
|
||||||
new Cesium.Primitive({
|
|
||||||
geometryInstances: instances,
|
|
||||||
appearance: new Cesium.PolylineColorAppearance({ translucent: true }),
|
|
||||||
asynchronous: true,
|
|
||||||
// Hidden while it builds; settleStems shows it.
|
|
||||||
show: false,
|
|
||||||
}),
|
|
||||||
);
|
|
||||||
state._viewer.scene.requestRender?.();
|
|
||||||
}
|
|
||||||
|
|
||||||
/** Swap in rebuilt stems once their geometry is ready; called per frame. */
|
|
||||||
|
|
||||||
function settleStems() {
|
|
||||||
const pending = state._stemPrimitivePending;
|
|
||||||
if (!pending) return;
|
|
||||||
const scene = state._viewer?.scene;
|
|
||||||
if (!pending.ready) {
|
|
||||||
// Keep frames coming until the geometry is in.
|
|
||||||
scene?.requestRender?.();
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
pending.show = state._enabled;
|
|
||||||
if (state._stemPrimitive) scene?.primitives?.remove(state._stemPrimitive);
|
|
||||||
state._stemPrimitive = pending;
|
|
||||||
state._stemPrimitivePending = null;
|
|
||||||
scene?.requestRender?.();
|
|
||||||
}
|
|
||||||
|
|
||||||
/** Remove and destroy everything buildScene made. Only destroy() does this;
|
|
||||||
* a disable hides the primitives and keeps them for the next enable. */
|
|
||||||
|
|
||||||
function destroyScene(viewer) {
|
|
||||||
const scene = viewer?.scene;
|
|
||||||
const owned = [
|
|
||||||
[scene?.groundPrimitives, state._cablePrimitive],
|
|
||||||
[scene?.primitives, state._markerBillboards],
|
|
||||||
[scene?.primitives, state._stemPrimitive],
|
|
||||||
[scene?.primitives, state._stemPrimitivePending],
|
|
||||||
[scene?.primitives, state._referencePoints],
|
|
||||||
];
|
|
||||||
state._cablePrimitive = null;
|
|
||||||
state._markerBillboards = null;
|
|
||||||
state._stemPrimitive = null;
|
|
||||||
state._stemPrimitivePending = null;
|
|
||||||
state._stemsDirty = false;
|
|
||||||
state._referencePoints = null;
|
|
||||||
state._referenceRecords = [];
|
|
||||||
state._lineRecords = [];
|
|
||||||
state._markerRecords = [];
|
|
||||||
state._lineShowDirty = false;
|
|
||||||
state._pendingLandingReveals.length = 0;
|
|
||||||
state._pickRecords = new WeakSet();
|
|
||||||
state._referenceLabelCount = 0;
|
|
||||||
state._publishScratch.length = 0;
|
|
||||||
state._loaded = false;
|
|
||||||
state._referenceSweepGate.reset();
|
|
||||||
for (const [collection, primitive] of owned) {
|
|
||||||
if (!primitive) continue;
|
|
||||||
try {
|
|
||||||
// A collection destroys what it removes; one that is already gone
|
|
||||||
// has destroyed it too.
|
|
||||||
if (!collection?.remove?.(primitive) && !primitive.isDestroyed())
|
|
||||||
primitive.destroy();
|
|
||||||
} catch {
|
|
||||||
/* collection gone */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Drop the stems, shown and building, so the next sweep draws them afresh.
|
|
||||||
* A disable does this: stems kept from the view the layer was switched off
|
|
||||||
* in would show at their old lengths until the rebuild for the new view
|
|
||||||
* was ready.
|
|
||||||
*/
|
|
||||||
|
|
||||||
function dropStems() {
|
|
||||||
const primitives = state._viewer?.scene?.primitives;
|
|
||||||
for (const primitive of [state._stemPrimitive, state._stemPrimitivePending])
|
|
||||||
if (primitive) primitives?.remove(primitive);
|
|
||||||
state._stemPrimitive = null;
|
|
||||||
state._stemPrimitivePending = null;
|
|
||||||
state._stemsDirty = true;
|
|
||||||
}
|
|
||||||
|
|
||||||
function updateVisibility() {
|
|
||||||
for (const primitive of [
|
|
||||||
state._cablePrimitive,
|
|
||||||
state._markerBillboards,
|
|
||||||
state._stemPrimitive,
|
|
||||||
state._referencePoints,
|
|
||||||
])
|
|
||||||
if (primitive) primitive.show = state._enabled;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Re-classify the cable ground lines for the active surface. The primitive
|
|
||||||
* reads its classification as it queues commands, so this is one
|
|
||||||
* assignment per stack switch and no rebuild.
|
|
||||||
* @param {Cesium.ClassificationType} next
|
|
||||||
*/
|
|
||||||
|
|
||||||
function applyCableClassification(next) {
|
|
||||||
if (next === undefined || next === state._classificationType) return;
|
|
||||||
state._classificationType = next;
|
|
||||||
if (!state._cablePrimitive) return;
|
|
||||||
state._cablePrimitive.classificationType = next;
|
|
||||||
state._viewer?.scene?.requestRender?.();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Write the line show states the last sweep worked out. The primitive
|
|
||||||
* builds its geometry in a worker and has no per-line attributes until it
|
|
||||||
* is ready, so the states wait in the records until then.
|
|
||||||
*/
|
|
||||||
|
|
||||||
function syncLineShow() {
|
|
||||||
if (!state._lineShowDirty) return;
|
|
||||||
const primitive = state._cablePrimitive;
|
|
||||||
if (!primitive?.ready) {
|
|
||||||
// Keep frames coming until the geometry is in.
|
|
||||||
if (primitive) state._viewer?.scene?.requestRender?.();
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
for (const record of state._lineRecords) {
|
|
||||||
if (record.shown === record.visible) continue;
|
|
||||||
record.attributes ??= primitive.getGeometryInstanceAttributes(
|
|
||||||
record.info,
|
|
||||||
);
|
|
||||||
if (!record.attributes) continue;
|
|
||||||
record.attributes.show = Cesium.ShowGeometryInstanceAttribute.toValue(
|
|
||||||
record.visible,
|
|
||||||
record.attributes.show,
|
|
||||||
);
|
|
||||||
record.shown = record.visible;
|
|
||||||
}
|
|
||||||
state._lineShowDirty = false;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Put the next few markers the last sweep found visible on the ground and
|
|
||||||
* show them, and ask for another frame while any are left. Called from the
|
|
||||||
* sweep and then once per rendered frame, so a parked camera costs nothing
|
|
||||||
* once the list is empty. Clamping is what reads the terrain height, once
|
|
||||||
* per marker; Cesium then keeps the marker on the surface as terrain loads,
|
|
||||||
* within its own per-frame time budget.
|
|
||||||
*/
|
|
||||||
|
|
||||||
function revealLandingMarkers() {
|
|
||||||
const pending = state._pendingLandingReveals;
|
|
||||||
if (!pending.length) return;
|
|
||||||
let budget = CABLE_LANDING_REVEALS_PER_FRAME;
|
|
||||||
while (pending.length && budget > 0) {
|
|
||||||
const record = pending.pop();
|
|
||||||
if (!record.visible || record.marker.show) continue;
|
|
||||||
if (!record.clamped) {
|
|
||||||
record.marker.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
|
|
||||||
record.clamped = true;
|
|
||||||
budget--;
|
|
||||||
}
|
|
||||||
record.marker.show = true;
|
|
||||||
}
|
|
||||||
if (pending.length) state._viewer?.scene?.requestRender?.();
|
|
||||||
}
|
|
||||||
|
|
||||||
function updateReferenceVisibility() {
|
function updateReferenceVisibility() {
|
||||||
if (!state._enabled || !state._viewer?.camera) return;
|
if (!state._enabled || !state._viewer?.camera) return;
|
||||||
const cameraPos = state._viewer.camera.positionWC;
|
const cameraPos = state._viewer.camera.positionWC;
|
||||||
@@ -419,35 +216,20 @@ export function createRendering({
|
|||||||
const visible = occluder.isPointVisible(record.base);
|
const visible = occluder.isPointVisible(record.base);
|
||||||
record.visible = visible;
|
record.visible = visible;
|
||||||
record.distanceM = Cesium.Cartesian3.distance(cameraPos, record.base);
|
record.distanceM = Cesium.Cartesian3.distance(cameraPos, record.base);
|
||||||
if (record.point.show !== visible) {
|
if (record.entity.show !== visible) {
|
||||||
record.point.show = visible;
|
record.entity.show = visible;
|
||||||
state._stemsDirty = true;
|
|
||||||
}
|
}
|
||||||
// Hidden stems keep their last tip; this same sweep refreshes them in
|
// Hidden stems keep their last geometry; this same sweep refreshes them
|
||||||
// the pass where they turn visible again.
|
// in the pass where they turn visible again.
|
||||||
if (
|
if (visible)
|
||||||
visible &&
|
updateCableReferenceStem(record, cameraPos, canvasHeight, fov);
|
||||||
updateCableReferenceStem(record, cameraPos, canvasHeight, fov)
|
|
||||||
)
|
|
||||||
state._stemsDirty = true;
|
|
||||||
}
|
}
|
||||||
if (state._stemsDirty) rebuildStems();
|
for (const record of state._surfaceRecords) {
|
||||||
for (const record of state._lineRecords) {
|
|
||||||
record.visible = occluder.isPointVisible(record.base);
|
|
||||||
if (record.visible !== record.shown) state._lineShowDirty = true;
|
|
||||||
}
|
|
||||||
syncLineShow();
|
|
||||||
state._pendingLandingReveals.length = 0;
|
|
||||||
for (const record of state._markerRecords) {
|
|
||||||
const visible = occluder.isPointVisible(record.base);
|
const visible = occluder.isPointVisible(record.base);
|
||||||
record.visible = visible;
|
if (record.entity.show !== visible) {
|
||||||
if (record.marker.show === visible) continue;
|
record.entity.show = visible;
|
||||||
// A marker not yet on the ground waits its turn; one that already is
|
}
|
||||||
// shows at once, and hiding is immediate.
|
|
||||||
if (visible && !record.clamped) state._pendingLandingReveals.push(record);
|
|
||||||
else record.marker.show = visible;
|
|
||||||
}
|
}
|
||||||
revealLandingMarkers();
|
|
||||||
const winners = selectCableReferenceLabelWinners(state._referenceRecords);
|
const winners = selectCableReferenceLabelWinners(state._referenceRecords);
|
||||||
let changed = winners.length !== state._lastPublishedCount;
|
let changed = winners.length !== state._lastPublishedCount;
|
||||||
for (let i = 0; i < winners.length; i++) {
|
for (let i = 0; i < winners.length; i++) {
|
||||||
@@ -465,6 +247,9 @@ export function createRendering({
|
|||||||
}
|
}
|
||||||
state._publishScratch.length = winners.length;
|
state._publishScratch.length = winners.length;
|
||||||
state._referenceLabelCount = winners.length;
|
state._referenceLabelCount = winners.length;
|
||||||
|
// The marker collections are created lazily by the visualizers, so the
|
||||||
|
// single-pass blend is applied on the sweep cadence until both landed.
|
||||||
|
if (!state._markerBlendDone) applyMarkerBlendOnce();
|
||||||
if (!changed) return;
|
if (!changed) return;
|
||||||
state._overlayPublisher.publish(state._publishScratch);
|
state._overlayPublisher.publish(state._publishScratch);
|
||||||
state._lastPublishedCount = winners.length;
|
state._lastPublishedCount = winners.length;
|
||||||
@@ -477,14 +262,13 @@ export function createRendering({
|
|||||||
}
|
}
|
||||||
return {
|
return {
|
||||||
resetPublishSignature,
|
resetPublishSignature,
|
||||||
buildScene,
|
releaseDataSources,
|
||||||
destroyScene,
|
|
||||||
updateVisibility,
|
updateVisibility,
|
||||||
|
styleCableEntity,
|
||||||
|
applyMarkerBlendOnce,
|
||||||
applyCableClassification,
|
applyCableClassification,
|
||||||
syncLineShow,
|
styleLandingEntity,
|
||||||
settleStems,
|
addReferenceStem,
|
||||||
dropStems,
|
|
||||||
revealLandingMarkers,
|
|
||||||
updateReferenceVisibility,
|
updateReferenceVisibility,
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
@@ -30,50 +30,26 @@ export function createState({ sweepClock, overlayHost }) {
|
|||||||
|
|
||||||
state._loadGeneration = 0;
|
state._loadGeneration = 0;
|
||||||
|
|
||||||
|
state._cableDataSource = null;
|
||||||
|
|
||||||
|
state._landingDataSource = null;
|
||||||
|
|
||||||
|
state._referenceDataSource = null;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* What the layer draws, built once per load and kept across disable/enable
|
* Fetched cable/landing JSON kept across disable/enable. A disable RELEASES
|
||||||
* (a disable only hides them, which costs nothing per frame):
|
* the three data sources (see releaseDataSources) instead of hiding them,
|
||||||
* one ground polyline primitive for every line, one billboard collection
|
* so a re-enable has to rebuild the entities; the network/parse half of
|
||||||
* for every point marker, a point collection for the reference tips and
|
* that rebuild is the expensive part users would notice, so it is cached.
|
||||||
* one polyline primitive for the reference stems.
|
|
||||||
*/
|
*/
|
||||||
|
|
||||||
state._cablePrimitive = null;
|
state._cachedCableJson = null;
|
||||||
|
|
||||||
state._markerBillboards = null;
|
state._cachedLandingJson = null;
|
||||||
|
|
||||||
state._referencePoints = null;
|
|
||||||
|
|
||||||
/** The stems now drawn, and their replacement while it builds. */
|
|
||||||
|
|
||||||
state._stemPrimitive = null;
|
|
||||||
|
|
||||||
state._stemPrimitivePending = null;
|
|
||||||
|
|
||||||
state._stemsDirty = false;
|
|
||||||
|
|
||||||
state._referenceRecords = [];
|
state._referenceRecords = [];
|
||||||
|
|
||||||
/** One record per drawn line: its pick record, horizon base and show state. */
|
state._surfaceRecords = [];
|
||||||
|
|
||||||
state._lineRecords = [];
|
|
||||||
|
|
||||||
/** Line show states still to be written once the primitive is ready. */
|
|
||||||
|
|
||||||
state._lineShowDirty = false;
|
|
||||||
|
|
||||||
/** One record per point marker: its billboard and horizon base. */
|
|
||||||
|
|
||||||
state._markerRecords = [];
|
|
||||||
|
|
||||||
/** Markers the last sweep found visible but not on the ground yet; drained
|
|
||||||
* a few per frame (CABLE_LANDING_REVEALS_PER_FRAME). */
|
|
||||||
|
|
||||||
state._pendingLandingReveals = [];
|
|
||||||
|
|
||||||
/** The pick records handed to Cesium as ids, so a pick is known to be ours. */
|
|
||||||
|
|
||||||
state._pickRecords = new WeakSet();
|
|
||||||
|
|
||||||
state._clickHandler = null;
|
state._clickHandler = null;
|
||||||
|
|
||||||
@@ -87,6 +63,14 @@ export function createState({ sweepClock, overlayHost }) {
|
|||||||
|
|
||||||
state._classificationType = Cesium.ClassificationType.BOTH;
|
state._classificationType = Cesium.ClassificationType.BOTH;
|
||||||
|
|
||||||
|
/** True once both marker collections blend translucent (or the shape probe failed). */
|
||||||
|
|
||||||
|
state._markerBlendDone = false;
|
||||||
|
|
||||||
|
state._markerBlendInvariantWarned = false;
|
||||||
|
|
||||||
|
state._pickByEntity = new WeakMap();
|
||||||
|
|
||||||
state._referenceLabelCount = 0;
|
state._referenceLabelCount = 0;
|
||||||
|
|
||||||
state._referenceSweepGate = createCableReferenceSweepGate({
|
state._referenceSweepGate = createCableReferenceSweepGate({
|
||||||
|
|||||||
@@ -1,5 +1,8 @@
|
|||||||
import * as Cesium from 'cesium';
|
import * as Cesium from 'cesium';
|
||||||
import { CABLE_GLOBE_STACK_IDS } from './policy.js';
|
import {
|
||||||
|
CABLE_GLOBE_STACK_IDS,
|
||||||
|
MARKER_COLLECTION_EXPECTATIONS,
|
||||||
|
} from './policy.js';
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Ground-line classification for one map stack. The photoreal stack renders
|
* Ground-line classification for one map stack. The photoreal stack renders
|
||||||
@@ -7,7 +10,7 @@ import { CABLE_GLOBE_STACK_IDS } from './policy.js';
|
|||||||
* need the 3D-tile classification pass there; every other known stack (the
|
* need the 3D-tile classification pass there; every other known stack (the
|
||||||
* bing stacks and osm) renders imagery on the shown globe, so only the
|
* bing stacks and osm) renders imagery on the shown globe, so only the
|
||||||
* terrain pass applies.
|
* terrain pass applies.
|
||||||
* Classifying against just the active surface halves the
|
* Classifying against just the active surface halves the batched
|
||||||
* GroundPolylinePrimitive's emitted command sets. BOTH is the safe fallback
|
* GroundPolylinePrimitive's emitted command sets. BOTH is the safe fallback
|
||||||
* for an unknown stack — it renders on every surface, exactly the shipped
|
* for an unknown stack — it renders on every surface, exactly the shipped
|
||||||
* pre-optimization behavior.
|
* pre-optimization behavior.
|
||||||
@@ -37,3 +40,87 @@ export function cableClassificationTypeForScene(scene) {
|
|||||||
? Cesium.ClassificationType.CESIUM_3D_TILE
|
? Cesium.ClassificationType.CESIUM_3D_TILE
|
||||||
: Cesium.ClassificationType.TERRAIN;
|
: Cesium.ClassificationType.TERRAIN;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Validate one data source's marker collections WITHOUT mutating anything.
|
||||||
|
* Splitting validation from mutation is what makes the fallback honest: a
|
||||||
|
* shape failure on the SECOND collection (or the second data source) must
|
||||||
|
* not leave the first one already forced to TRANSLUCENT.
|
||||||
|
* @param {Cesium.DataSource|null|undefined} dataSource
|
||||||
|
* @returns {{ready:object[],pending:number,invariantFailed:boolean}}
|
||||||
|
*/
|
||||||
|
|
||||||
|
export function probeTranslucentMarkerBlend(dataSource) {
|
||||||
|
const cluster = dataSource?.clustering;
|
||||||
|
if (!cluster) return { ready: [], pending: 0, invariantFailed: true };
|
||||||
|
const ready = [];
|
||||||
|
let pending = 0;
|
||||||
|
let invariantFailed = false;
|
||||||
|
for (const { key, type } of MARKER_COLLECTION_EXPECTATIONS) {
|
||||||
|
if (!(key in cluster)) {
|
||||||
|
invariantFailed = true;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
const collection = cluster[key];
|
||||||
|
if (collection === undefined || collection === null) {
|
||||||
|
pending++;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if (!(collection instanceof type) || !('blendOption' in collection)) {
|
||||||
|
invariantFailed = true;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
ready.push(collection);
|
||||||
|
}
|
||||||
|
// Any failure discards every collected target: nothing is mutated at all.
|
||||||
|
if (invariantFailed) return { ready: [], pending: 0, invariantFailed: true };
|
||||||
|
return { ready, pending, invariantFailed: false };
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Commit a clean probe. Only ever called once every probe in the batch has
|
||||||
|
* passed, so this cannot land a partial application.
|
||||||
|
* @param {{ready:object[],pending:number}} probe
|
||||||
|
* @returns {{applied:number,pending:number,invariantFailed:boolean}}
|
||||||
|
*/
|
||||||
|
|
||||||
|
export function commitTranslucentMarkerBlend(probe) {
|
||||||
|
for (const collection of probe.ready) {
|
||||||
|
if (collection.blendOption !== Cesium.BlendOption.TRANSLUCENT) {
|
||||||
|
collection.blendOption = Cesium.BlendOption.TRANSLUCENT;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return {
|
||||||
|
applied: probe.ready.length,
|
||||||
|
pending: probe.pending,
|
||||||
|
invariantFailed: false,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Force one translucent draw pass for a data source's marker collections.
|
||||||
|
* The default `OPAQUE_AND_TRANSLUCENT` blend emits two draw commands per
|
||||||
|
* collection, and every cable marker is translucent (alpha < 1), so the
|
||||||
|
* opaque pass is pure overhead across 1,917 landing billboards + 2,629
|
||||||
|
* reference points. Cesium has no public accessor for the entity-backed
|
||||||
|
* collections, so this reaches through EntityCluster's private fields under
|
||||||
|
* a SHAPE INVARIANT the caller must honor loudly: the constructor
|
||||||
|
* pre-assigns `_billboardCollection`/`_pointCollection` (= undefined until a
|
||||||
|
* visualizer lazily creates them), so a missing PROPERTY means Cesium's
|
||||||
|
* shape changed — report `invariantFailed` and never touch anything —
|
||||||
|
* while a present-but-undefined value only means "not created yet"
|
||||||
|
* (`pending`). Wrong instance types also fail the invariant. The cables
|
||||||
|
* sources never enable clustering, so created collections persist.
|
||||||
|
* VALIDATE-ALL-THEN-MUTATE-ALL: every field/type check runs before the first
|
||||||
|
* assignment, so a failure anywhere leaves BOTH collections on Cesium's
|
||||||
|
* default blend — the fallback this helper promises.
|
||||||
|
* @param {Cesium.DataSource|null|undefined} dataSource
|
||||||
|
* @returns {{applied:number,pending:number,invariantFailed:boolean}}
|
||||||
|
*/
|
||||||
|
|
||||||
|
export function applyTranslucentMarkerBlend(dataSource) {
|
||||||
|
const probe = probeTranslucentMarkerBlend(dataSource);
|
||||||
|
if (probe.invariantFailed)
|
||||||
|
return { applied: 0, pending: 0, invariantFailed: true };
|
||||||
|
return commitTranslucentMarkerBlend(probe);
|
||||||
|
}
|
||||||
Reference in new issue
Block a user