Keep shape radii, rim gradients, depth-fail looks, sweep cadence and step camera moves out of the renderer contract

Shapes take their radii in metres; the world annotation ring follows the
camera height itself (ringRadiusAt), resizing on preRender. The radial rim
preset and depthBias go: the launch pad zone draws a canvas image fill made
by the layer. Solid and dashed lines take one depthFail look (solid or
dash) in place of depthFailColor and depthFailDash. sonarCadenceHz goes from
the quality settings: nothing set it, and the sweep moves every 80 ms.

Camera move, look, rotateAround and zoom leave the camera port: the app's pans,
in-place turns, globe turns and zooms are setView views summed over the pose
(geo/eyeMoves), and the Cesium port places a view by direction and up
exactly rather than through heading, pitch and roll. The conformance driver
runs those script steps through setView; the lookAt script turns in place
where it turned about the frame-local axis, and its reference is recorded
again.
This commit is contained in:
Sameh Khamis committed 2026-11-10 04:08:41 -08:00
1 parent 7a376ebefc
commit c8346c9fda
44 files changed
+810 -799

No files matched your search

+5 -2
View File
@@ -217,8 +217,11 @@ export function initDrawTool({
length: 16,
},
// Dashed behind the surface too, as the band in front of it is.
depthFailColor: withAlpha(cssColor(PREVIEW.primary), 0.35),
depthFailDash: { length: 16 },
depthFail: {
kind: 'dash',
color: withAlpha(cssColor(PREVIEW.primary), 0.35),
length: 16,
},
},
]);
};
+3 -4
View File
@@ -503,11 +503,10 @@ test('the rubber band follows the pointer, closes an area and takes the chosen c
'the band takes the colour',
);
assert.deepEqual(
band().depthFailColor,
[139 / 255, 233 / 255, 1, 0.35],
'behind the surface it stays the primary colour, as before',
band().depthFail,
{ kind: 'dash', color: [139 / 255, 233 / 255, 1, 0.35], length: 16 },
'behind the surface it stays the primary colour, dashed, as before',
);
assert.deepEqual(band().depthFailDash, { length: 16 }, 'and dashed there');
assert.equal(band().style.kind, 'dash');
assert.equal(band().style.length, 16);
assert.equal(band().widthPx, 3);
+109 -16
View File
@@ -2,7 +2,12 @@ import { recordWorkSlice } from '../sources/phaseTiming.js';
import { ringCentroid } from '../sources/featureGeometry.js';
import { showOsmCredit, hideOsmCredit } from '../data/dataCredits.js';
import { fromDegrees } from '../geo/ellipsoid.js';
import { drawOf, frameOf } from '../render/rendererOf.js';
import {
drawOf,
findCamera,
findFrame,
frameOf,
} from '../render/rendererOf.js';
import { heightsOf } from '../queries/heights.js';
/**
@@ -22,7 +27,8 @@ import { heightsOf } from '../queries/heights.js';
* Fades follow the mark's alpha: the engine calls `sync` as it changes, and
* each mark's items take their new colours where they are. Pulsing fills
* are a declarative pulse the renderer runs; target rings follow the
* camera's height, which the renderer reads each frame.
* camera's height, read before each frame, and are sent again at the radius
* it gives when that changes.
*
* Each mark draws into sets of its own, so adding or removing one leaves
* the others' geometry alone.
@@ -57,9 +63,23 @@ const PULSE_MS = (2 * Math.PI) / 0.005;
const PULSE_LOW = 0.6;
/** Target rings: 3% of the camera's height, between 14 m and 170 m. */
const RING_RADIUS = Object.freeze({
byCameraHeight: Object.freeze({ factor: 0.03, min: 14, max: 170 }),
});
const RING_RADIUS = Object.freeze({ factor: 0.03, min: 14, max: 170 });
/** Relative change of the ring radius under which rings are not redrawn. */
const RING_RESIZE = 1e-3;
/**
* A target ring's radius, metres, for a camera `height` metres above the
* ellipsoid; 1000 m stands in for a height the camera cannot give.
* @param {number} height
*/
export function ringRadiusAt(height) {
const h = Number.isFinite(height) ? height : 1000;
return Math.max(
RING_RADIUS.min,
Math.min(RING_RADIUS.max, h * RING_RADIUS.factor),
);
}
/**
* Each renderer's sets have ids of their own, unique across copies of this
@@ -79,6 +99,56 @@ export function createWorldAnnotationRenderer(viewer) {
const groundQueue = [];
let offGroundFrame = null;
let destroyed = false;
// Marks with a target ring, and the radius they are drawn at.
const ringed = new Set();
let offRingFrame = null;
let ringRadius = ringRadiusAt(cameraHeight());
/** The camera's height above the ellipsoid, or NaN when it has none. */
function cameraHeight() {
try {
return findCamera(viewer)?.pose().height ?? Number.NaN;
} catch {
return Number.NaN;
}
}
/** The current ring radius, for the items that draw rings. */
const ringRadiusNow = () => ringRadius;
/**
* Before each frame: when the camera's height gives the rings another
* radius, every shown mark's ring is sent again at it. A hidden mark's
* ring catches up when it shows (`sync`).
*/
function followRings() {
const radius = ringRadiusAt(cameraHeight());
if (Math.abs(radius - ringRadius) <= RING_RESIZE * ringRadius) return;
ringRadius = radius;
for (const anno of ringed) if (!anno.hidden) resizeRing(anno);
}
/** Send a mark's ring again at the current radius, when it differs. */
function resizeRing(anno) {
const was = anno._drawn;
const set = anno._draw?.shapes;
if (!was?.ring || !set || was.ringRadius === ringRadius) return;
was.ringRadius = ringRadius;
set.upsert([was.ring(was.alpha)]);
}
/**
* Keep the ring frame listener while any mark has a ring. A host with no
* frame port draws its rings at the radius they were added with.
*/
function watchRings() {
if (ringed.size && !offRingFrame)
offRingFrame = findFrame(viewer)?.on('preRender', followRings) ?? null;
else if (!ringed.size && offRingFrame) {
offRingFrame();
offRingFrame = null;
}
}
const requestRender = () => frameOf(viewer).requestRender('annotations');
@@ -338,8 +408,18 @@ export function createWorldAnnotationRenderer(viewer) {
return sampleBuilding(anno, options);
}
const items = itemsOf(anno, options);
anno._drawn = { alpha: alphaOf(anno), items };
// Rings not yet followed take the camera's height now.
if (!offRingFrame) ringRadius = ringRadiusAt(cameraHeight());
const items = itemsOf(anno, options, ringRadiusNow);
anno._drawn = {
alpha: alphaOf(anno),
items,
ring: items.ring,
ringRadius,
};
if (items.ring) ringed.add(anno);
else ringed.delete(anno);
watchRings();
const current = () => options.isCurrent?.() ?? true;
const building = anno.footprintKind === 'building';
for (const kind of ['shapes', 'lines', 'points']) {
@@ -394,6 +474,8 @@ export function createWorldAnnotationRenderer(viewer) {
hideOsmCredit(viewer, anno);
osmAnnotations.delete(anno);
drawn.delete(anno);
ringed.delete(anno);
watchRings();
clearSets(anno);
if (anno) {
anno._draw = null;
@@ -415,8 +497,13 @@ export function createWorldAnnotationRenderer(viewer) {
if (sets[kind] && sets[kind].show !== show) sets[kind].show = show;
const was = anno._drawn;
const alpha = alphaOf(anno);
if (!was || was.alpha === alpha) continue;
if (!was || was.alpha === alpha) {
// Shown again: its ring catches up with the camera.
if (show) resizeRing(anno);
continue;
}
was.alpha = alpha;
was.ringRadius = ringRadius;
for (const kind of ['shapes', 'lines', 'points'])
if (sets[kind] && was.items[kind].length)
sets[kind].upsert(was.items[kind].map((item) => item(alpha)));
@@ -428,6 +515,8 @@ export function createWorldAnnotationRenderer(viewer) {
for (const task of [...pendingGround.values()]) task.finish('cancelled');
for (const anno of osmAnnotations) hideOsmCredit(viewer, anno);
osmAnnotations.clear();
ringed.clear();
watchRings();
for (const anno of drawn) {
clearSets(anno);
anno._draw = null;
@@ -455,14 +544,16 @@ const pulse = (alpha) => ({
/**
* What a mark draws, as item makers by kind, each taking the mark's alpha:
* built once per add, called again on each fade step.
* built once per add, called again on each fade step. `ring` is the target
* ring's maker among the shapes, drawn at `ringRadiusNow()`.
*/
function itemsOf(anno, options) {
function itemsOf(anno, options, ringRadiusNow) {
const base = PALETTE[anno.color] || PALETTE.primary;
const shapes = [];
const lines = [];
const points = [];
const meta = { annotation: anno.id };
let ring = null;
const draped = (id, positions, widthPx, style) => (alpha) => ({
id,
positions,
@@ -612,21 +703,23 @@ function itemsOf(anno, options) {
} else {
// pin / highlight / label — a camera-proportional target ring + a marker.
const pos = { lon: anno.anchor.lon, lat: anno.anchor.lat };
if (anno.type !== 'label')
shapes.push((alpha) => ({
if (anno.type !== 'label') {
ring = (alpha) => ({
id: 'ring',
geometry: {
kind: 'ellipse',
center: pos,
semiMajor: RING_RADIUS,
semiMinor: RING_RADIUS,
semiMajor: ringRadiusNow(),
semiMinor: ringRadiusNow(),
},
fill: colour(base, 0.38 * alpha),
animate: pulse(0.38 * alpha),
height: 'clampGround',
clampTo: CLAMP_TO,
meta,
}));
});
shapes.push(ring);
}
// Captions belong to the hybrid renderer's screen-space callouts.
points.push((alpha) => ({
id: 'marker',
@@ -640,7 +733,7 @@ function itemsOf(anno, options) {
meta,
}));
}
return { shapes, lines, points };
return { shapes, lines, points, ring };
}
/** `[lon, lat]` pairs as ECEF positions on the ellipsoid. */
@@ -8,29 +8,40 @@ import { bindRenderer } from '../render/rendererOf.js';
import { fakeDrawPort } from '../testSupport/fakeDrawPort.mjs';
import { createWorldAnnotationRenderer } from './worldAnnotationRenderer.js';
/** A viewer with a fake draw port, frame and query bound. */
/**
* A viewer with a fake draw port, frame, camera and query bound. The camera
* stands at `camera.height`; `preRender()` runs the frame's preRender
* listeners, `emit()` its postRender ones.
*/
function viewer(t, { heights = () => null } = {}) {
const draw = fakeDrawPort();
const frames = new Set();
const before = new Set();
const v = { requests: 0 };
const frame = {
on(phase, cb) {
if (phase !== 'postRender') return () => {};
frames.add(cb);
return () => frames.delete(cb);
const listeners =
phase === 'postRender' ? frames : phase === 'preRender' ? before : null;
if (!listeners) return () => {};
listeners.add(cb);
return () => listeners.delete(cb);
},
requestRender() {
v.requests += 1;
},
};
const camera = { height: 2000, pose: () => ({ height: camera.height }) };
const query = { sampleHeightNow: (point) => heights(point) };
const unbind = bindRenderer(v, { draw, frame, query });
const unbind = bindRenderer(v, { draw, frame, query, camera });
t.after(unbind);
return {
v,
draw,
frames,
before,
camera,
emit: () => [...frames].forEach((cb) => cb()),
preRender: () => [...before].forEach((cb) => cb()),
};
}
@@ -213,9 +224,7 @@ test('every kind draws as it did: draped on terrain and tiles alike, rings by ca
);
const [ring] = items(pin, 'shapes');
assert.deepEqual(ring.geometry.semiMajor, {
byCameraHeight: { factor: 0.03, min: 14, max: 170 },
});
assert.equal(ring.geometry.semiMajor, 60, '3% of the camera height');
assert.equal(ring.geometry.semiMinor, ring.geometry.semiMajor);
const [marker] = items(pin, 'points');
assert.deepEqual(
@@ -232,6 +241,67 @@ test('every kind draws as it did: draped on terrain and tiles alike, rings by ca
renderer.destroy();
});
test('target rings follow the camera height, sent again only when the radius changes, and catch up once shown', (t) => {
const { v, draw, camera, preRender, before } = viewer(t);
const renderer = createWorldAnnotationRenderer(v);
const [, , pin] = marks();
const other = { ...pin, id: 'pin2', anchor: { lat: 0.03, lon: 0.03 } };
renderer.add(pin);
renderer.add(other);
const ringOf = (anno) =>
setsOf(draw, anno)
.find((r) => r.kind === 'shapes')
.items.get('ring');
// Writes to the rings' sets since they were drawn.
const shapeSets = [pin, other].map((anno) =>
setsOf(draw, anno).find((r) => r.kind === 'shapes'),
);
const upserts = {
get length() {
return shapeSets.reduce((n, record) => n + record.writes - 1, 0);
},
};
assert.equal(ringOf(pin).geometry.semiMajor, 60);
assert.equal(before.size, 1, 'one listener for every ring');
// The camera has not moved: nothing is sent.
preRender();
assert.equal(upserts.length, 0);
// It climbs: both rings are sent at the new radius, once.
camera.height = 4000;
preRender();
preRender();
assert.equal(upserts.length, 2);
assert.equal(ringOf(pin).geometry.semiMajor, 120);
assert.equal(ringOf(pin).geometry.semiMinor, 120);
assert.equal(ringOf(other).geometry.semiMajor, 120);
// A change under 0.1% sends nothing.
camera.height = 4002;
preRender();
assert.equal(upserts.length, 2);
// Held within 14 m and 170 m.
camera.height = 1e6;
preRender();
assert.equal(ringOf(pin).geometry.semiMajor, 170);
camera.height = 10;
preRender();
assert.equal(ringOf(pin).geometry.semiMajor, 14);
// A hidden mark waits, and catches up when shown.
other.hidden = true;
renderer.sync();
camera.height = 3000;
preRender();
assert.equal(ringOf(pin).geometry.semiMajor, 90);
assert.equal(ringOf(other).geometry.semiMajor, 14, 'hidden: not sent');
other.hidden = false;
renderer.sync();
assert.equal(ringOf(other).geometry.semiMajor, 90, 'shown: caught up');
// The last ring gone, the listener goes with it.
renderer.remove(pin);
renderer.remove(other);
assert.equal(before.size, 0);
renderer.destroy();
});
test('a building waits for its ground probes, then draws a pulsing column, a cage and a draped base', async (t) => {
const { v, draw, emit, frames } = viewer(t, { heights: () => 150 });
const renderer = createWorldAnnotationRenderer(v);
+6 -3
View File
@@ -67,6 +67,7 @@ import {
toRadians,
vec,
} from './geo/index.js';
import { eyeMoved, eyeRotatedAbout, eyeTurned } from './geo/eyeMoves.js';
import { heightsOf } from './queries/heights.js';
import {
cameraOf,
@@ -1083,7 +1084,7 @@ function lookWithinFrame(camera, m, look, angle) {
if (allowed < owed) allowed = owed;
m.turnedRad += allowed;
}
if (allowed > 0) camera.look(look, allowed);
if (allowed > 0) camera.setView(eyeTurned(camera.pose(), look, allowed));
// The pose this turn leaves, for a turn that continues from it.
if (_lookBaseline) _lookBaseline.direction = camera.pose().direction;
if (allowed < angle) interruptCameraMotion('globe-out-of-frame');
@@ -1343,7 +1344,9 @@ function onTick() {
? heightM * ONCE.panViewFraction * (scale - (m.lastScale || 0))
: heightM * PAN_VIEW_FRACTION_S[m.speed] * dt;
m.lastScale = scale;
camera.move(PAN_MOVES[m.direction] ?? 'down', step);
camera.setView(
eyeMoved(camera.pose(), PAN_MOVES[m.direction] ?? 'down', step),
);
} else if (m.kind === 'tilt') {
tickTilt(camera, m, scale, dt);
} else if (m.kind === 'rotate' || m.kind === 'rotate_globe') {
@@ -1377,7 +1380,7 @@ function onTick() {
interruptCameraMotion('globe-surface-limit');
return;
}
camera.rotateAround(m.rotationAxis, angle);
camera.setView(eyeRotatedAbout(pose, m.rotationAxis, angle));
} else {
lookWithinFrame(
camera,
+7 -19
View File
@@ -6,8 +6,8 @@
* Each tick, before the renderer decides whether to draw: a change of the
* theme, the sweep, its settings or the map's size sets the sector at once;
* while sweeping, the sector moves to the current angle on every tick that
* draws anyway, and at least at the renderer's `sonarCadenceHz` (which then
* asks for a frame). Out of the theme the sector is cleared.
* draws anyway, and at least every `CYBER_SONAR_RENDER_INTERVAL_MS` (which
* then asks for a frame). Out of the theme the sector is cleared.
*
* A renderer without the capability, or one that does not list the pass
* once a sector is set, leaves markers as they are: the document's
@@ -25,16 +25,8 @@ import {
readCyberSonarSettings,
syncCyberSonarAnimation,
} from './cyberSonar.js';
import {
canvasOf,
findEffects,
findFrame,
rendererOf,
} from './render/rendererOf.js';
import { canvasOf, findEffects, findFrame } from './render/rendererOf.js';
/** Sweep updates per second when the renderer's quality has no setting. */
export const CYBER_SONAR_DEFAULT_CADENCE_HZ =
1000 / CYBER_SONAR_RENDER_INTERVAL_MS;
const UNSUPPORTED_MESSAGE =
'Contact GPU unavailable. Native contacts remain visible.';
@@ -54,14 +46,8 @@ export function createCyberSonarScene(viewer, manager) {
let current = null;
let key = null;
let lastSetAt = Number.NEGATIVE_INFINITY;
let interval = CYBER_SONAR_RENDER_INTERVAL_MS;
let disposed = false;
const readCadence = () => {
const hz = Number(rendererOf(viewer)?.quality?.get?.()?.sonarCadenceHz);
interval = 1000 / (hz > 0 ? hz : CYBER_SONAR_DEFAULT_CADENCE_HZ);
};
const publish = () => {
const support = failed ? 'unsupported' : 'supported';
if (root?.dataset && root.dataset.cyberSonarGpu !== support)
@@ -120,11 +106,13 @@ export function createCyberSonarScene(viewer, manager) {
const now = performance.now();
if (
next === key &&
!(sweeping && (now - lastSetAt >= interval || t.rendering))
!(
sweeping &&
(now - lastSetAt >= CYBER_SONAR_RENDER_INTERVAL_MS || t.rendering)
)
)
return;
key = next;
readCadence();
set(cyberSonarSector(width, height, now, { sweeping, root }), now);
});
+1 -23
View File
@@ -92,7 +92,7 @@ test('the sector is the sweep the HUD shows, in CSS pixels and radians', () => {
* viewer: its frame's preUpdate is ticked by hand and its effects record
* each sector.
*/
function fixture({ modulation = true, lists = true, cadenceHz } = {}) {
function fixture({ modulation = true, lists = true } = {}) {
const previous = {
document: globalThis.document,
matchMedia: globalThis.matchMedia,
@@ -137,7 +137,6 @@ function fixture({ modulation = true, lists = true, cadenceHz } = {}) {
const unbind = bindRenderer(viewer, {
canvas,
effects,
quality: { get: () => (cadenceHz ? { sonarCadenceHz: cadenceHz } : {}) },
frame: {
on(phase, cb) {
assert.equal(phase, 'preUpdate');
@@ -277,27 +276,6 @@ test('the sweep sets its sector on drawing ticks and at the cadence, and changes
}
});
test('the renderer cadence paces the idle sweep', () => {
const f = fixture({ cadenceHz: 4 });
const now = performance.now;
let clock = 0;
performance.now = () => clock;
try {
const dispose = createCyberSonarScene(f.viewer);
f.tick();
clock += CYBER_SONAR_RENDER_INTERVAL_MS;
f.tick();
assert.equal(f.sets.length, 1, '4 Hz waits 250 ms');
clock += 250 - CYBER_SONAR_RENDER_INTERVAL_MS;
f.tick();
assert.equal(f.sets.length, 2);
dispose();
} finally {
performance.now = now;
f.restore();
}
});
test('a sector the renderer does not list is unsupported: cleared, and the sweep stops', () => {
const f = fixture({ lists: false });
try {
+1 -1
View File
@@ -294,7 +294,7 @@ export function createCalibrationGizmo({
// Standard gizmo convention: parts behind geometry stay clearly
// visible, just dimmed (a street-level mount buries half the heading
// ring in sloped photogrammetry tiles — smoke-tested 2026-07-05).
depthFailColor: rgba(color, 0.45),
depthFail: { kind: 'solid', color: rgba(color, 0.45) },
show: shown,
});
}
+1 -1
View File
@@ -211,7 +211,7 @@ test('the gizmo draws its parts through the draw port, shown in ADJUST mode only
assert.equal(ring.widthPx, 3);
assert.equal(ring.positions.length, 97, 'a closed 96-segment ring');
assert.ok(Math.abs(ring.style.color[3] - 0.9) < 1e-12);
assert.ok(Math.abs(ring.depthFailColor[3] - 0.45) < 1e-12);
assert.ok(Math.abs(ring.depthFail.color[3] - 0.45) < 1e-12);
const arrow = lines.items.get(`${GIZMO_ID_PREFIX}move-up`);
assert.equal(arrow.style.kind, 'arrow');
assert.equal(arrow.widthPx, 12);
+1 -1
View File
@@ -126,7 +126,7 @@ export function createTrail(viewer, { color, width = 2.5 }) {
style: { kind: 'solid', color: colorAt(color, alpha) },
// The owner-locked rule (round 6): a segment below the photoreal
// mesh renders dimmed — it must never disappear into the ground.
depthFailColor: colorAt(color, occludedAlpha),
depthFail: { kind: 'solid', color: colorAt(color, occludedAlpha) },
};
drawn.set(id, { key, item });
lines.upsert([item]);
+5 -2
View File
@@ -34,7 +34,10 @@ test('a trail draws its history as one dimmed-when-hidden geodesic line', (t) =>
assert.equal(line.mode, 'geodesic');
assert.equal(line.style.kind, 'solid');
assert.deepEqual(line.style.color, [0, 212 / 255, 1, 0.85]);
assert.deepEqual(line.depthFailColor, [0, 212 / 255, 1, 0.4]);
assert.deepEqual(line.depthFail, {
kind: 'solid',
color: [0, 212 / 255, 1, 0.4],
});
// The same positions again change nothing; fewer than two distinct hide it.
const writes = set.writes;
@@ -65,7 +68,7 @@ test('a trail head is a line of its own beside the history, at the head alphas',
);
assert.equal(findPickOwner(head.id), 'trails');
assert.equal(head.style.color[3], 0.9);
assert.equal(head.depthFailColor[3], 0.45);
assert.equal(head.depthFail.color[3], 0.45);
assert.equal(head.mode, '3d', 'short: straight, two positions a frame');
// No head: hidden once, then nothing more to write.
trail.setHead(null);
+104
View File
@@ -0,0 +1,104 @@
/**
* @module geo/eyeMoves
* @description Moving and turning the eye from its pose, as `setView` takes
* the result: the app's step-by-step camera motions (pans, in-place turns, the
* globe turned under the eye, zooms) are these sums over the camera port's
* pose, so the renderer moves this way without a verb of its own.
* Each keeps the eye's world pose otherwise; a renderer keeps a `lookAt`
* frame across `setView`.
*/
import { add, cross, negate, normalize, scale } from './vector.js';
import { rotate } from './frames.js';
/**
* A `setView` view: the eye at `position`, looking along `direction` with
* `up` up.
* @typedef {{destination: {x: number, y: number, z: number},
* orientation: {direction: {x: number, y: number, z: number},
* up: {x: number, y: number, z: number}}}} EyeView
*/
const view = (position, direction, up) => ({
destination: position,
orientation: { direction, up },
});
/**
* The eye moved `metres` along one of its own axes.
* @param {{position: object, direction: object, up: object, right: object}} pose
* @param {'forward'|'back'|'left'|'right'|'up'|'down'} direction
* @param {number} metres
* @returns {EyeView}
*/
export function eyeMoved(pose, direction, metres) {
const axes = {
forward: pose.direction,
back: negate(pose.direction),
right: pose.right,
left: negate(pose.right),
up: pose.up,
down: negate(pose.up),
};
if (!Object.hasOwn(axes, direction))
throw new RangeError(`no move direction '${direction}'`);
return view(
add(pose.position, scale(axes[direction], metres)),
pose.direction,
pose.up,
);
}
/**
* The eye turned in place by `radians`: left and right about its own up,
* up and down about its own right.
* @param {{position: object, direction: object, up: object, right: object}} pose
* @param {'left'|'right'|'up'|'down'} direction
* @param {number} radians
* @returns {EyeView}
*/
export function eyeTurned(pose, direction, radians) {
const turns = {
left: [pose.up, radians],
right: [pose.up, -radians],
up: [pose.right, radians],
down: [pose.right, -radians],
};
if (!Object.hasOwn(turns, direction))
throw new RangeError(`no look direction '${direction}'`);
const [axis, angle] = turns[direction];
const a = normalize(axis);
return view(
pose.position,
rotate(pose.direction, a, angle),
rotate(pose.up, a, angle),
);
}
/**
* The eye carried about `axis` through the Earth's centre by `radians`,
* position and view together: a positive angle turns it clockwise seen
* from the axis's tip (the globe seems to turn the other way).
* @param {{position: object, direction: object, up: object}} pose
* @param {{x: number, y: number, z: number}} axis
* @param {number} radians
* @returns {EyeView}
*/
export function eyeRotatedAbout(pose, axis, radians) {
const a = normalize(axis);
const direction = rotate(pose.direction, a, -radians);
const turnedUp = rotate(pose.up, a, -radians);
const right = cross(direction, turnedUp);
return view(
rotate(pose.position, a, -radians),
normalize(direction),
normalize(cross(right, direction)),
);
}
/**
* The eye moved `metres` along its view direction; negative backs away.
* @param {{position: object, direction: object, up: object, right: object}} pose
* @param {number} metres
* @returns {EyeView}
*/
export const eyeZoomed = (pose, metres) => eyeMoved(pose, 'forward', metres);
+4 -2
View File
@@ -32,7 +32,9 @@ function lineItemOf(handle) {
style: handle.dashed
? { kind: 'dash', color, length: 16, pattern16: 255 }
: { kind: 'solid', color },
depthFailColor: handle.depthFailColor ?? null,
depthFail: handle.depthFailColor
? { kind: 'solid', color: handle.depthFailColor }
: null,
meta: { cameraId: handle.cameraId },
show: handle.show !== false,
};
@@ -45,7 +47,7 @@ const lineKey = (item) =>
item.widthPx,
item.style.kind,
item.style.color.join(','),
item.depthFailColor ? item.depthFailColor.join(',') : '',
item.depthFail ? item.depthFail.color.join(',') : '',
item.show,
].join('|');
+2 -2
View File
@@ -39,7 +39,7 @@ test('lines are written as they change, and drawn as their handles say', () => {
widthPx: 1.2,
mode: 'geodesic',
style: { kind: 'solid', color: a.color },
depthFailColor: null,
depthFail: null,
meta: { cameraId: 'cam' },
show: true,
});
@@ -58,7 +58,7 @@ test('lines are written as they change, and drawn as their handles say', () => {
length: 16,
pattern16: 255,
});
assert.deepEqual(cap.depthFailColor, [1, 1, 1, 0.2]);
assert.deepEqual(cap.depthFail, { kind: 'solid', color: [1, 1, 1, 0.2] });
assert.equal(drawSets.roleOfSet(coverage.spec.id), 'coverage');
assert.equal(drawSets.roleOfSet('other:1:lines'), null);
+67 -11
View File
@@ -10,11 +10,69 @@ const ZONE_FILL_ALPHA = 0.105;
const ZONE_RIM_ALPHA = 0.72;
/** The rim's width, a fraction of the zone's radius. */
const ZONE_RIM_WIDTH = 0.033;
/** Where the zone's soft edge starts, a fraction of its radius. */
const ZONE_EDGE = 0.985;
/** How much brighter the rim glows than its colour. */
const ZONE_RIM_GLOW = 0.35;
/** The zone image's side, pixels. */
const ZONE_IMAGE_PX = 512;
const smoothstep = (edge0, edge1, x) => {
const t = Math.min(1, Math.max(0, (x - edge0) / (edge1 - edge0)));
return t * t * (3 - 2 * t);
};
/**
* Pulled toward the eye, metres, so the zone is not buried by the pad's
* mesh at oblique angles, without a height that would float it.
* The zone's colour and alpha at `r`, a fraction of its radius from its
* centre: the fill's colour, easing into the rim's (which glows a little)
* over `ZONE_RIM_WIDTH` just inside a soft edge, nothing past it.
* @param {number} r
* @returns {[number, number, number, number]} `r, g, b, a`, 0..1.
*/
const ZONE_DEPTH_BIAS_M = 1;
export function launchPadZoneColour(r) {
const [red, green, blue] = hexColor(ZONE_COLOR, 1);
const inside = 1 - smoothstep(ZONE_EDGE, 1, r);
const rim = smoothstep(ZONE_EDGE - ZONE_RIM_WIDTH, ZONE_EDGE, r) * inside;
const glow = 1 + ZONE_RIM_GLOW * rim;
return [
Math.min(1, red * glow),
Math.min(1, green * glow),
Math.min(1, blue * glow),
inside * (ZONE_FILL_ALPHA + (ZONE_RIM_ALPHA - ZONE_FILL_ALPHA) * rim),
];
}
/** The zone's image, made on first use; null where there is no 2D canvas. */
let zoneImage;
/**
* The zone as an image fill: `launchPadZoneColour` across a square canvas,
* its centre at the middle and its edge at the sides.
* @param {() => HTMLCanvasElement} [createCanvas]
* @returns {?{canvas: HTMLCanvasElement, key: string}}
*/
export function launchPadZoneImage(
createCanvas = () => globalThis.document?.createElement('canvas'),
) {
if (zoneImage !== undefined) return zoneImage;
const canvas = createCanvas();
const context = canvas?.getContext?.('2d');
if (!context) return (zoneImage = null);
canvas.width = ZONE_IMAGE_PX;
canvas.height = ZONE_IMAGE_PX;
const image = context.createImageData(ZONE_IMAGE_PX, ZONE_IMAGE_PX);
const half = ZONE_IMAGE_PX / 2;
for (let y = 0; y < ZONE_IMAGE_PX; y++)
for (let x = 0; x < ZONE_IMAGE_PX; x++) {
const r = Math.hypot(x + 0.5 - half, y + 0.5 - half) / half;
const colour = launchPadZoneColour(r);
const at = (y * ZONE_IMAGE_PX + x) * 4;
for (let k = 0; k < 4; k++)
image.data[at + k] = Math.round(colour[k] * 255);
}
context.putImageData(image, 0, 0);
return (zoneImage = { canvas, key: 'launch-pad-zone' });
}
export function createLaunchPad({
state: layerState,
@@ -39,9 +97,13 @@ export function createLaunchPad({
layerState._launchPadZoneLaunchId = null;
}
/** The zone drawn around a launch's pad, draped on the ground. */
/**
* The zone drawn around a launch's pad, draped on the ground (and on the
* pad's mesh); a plain fill where there is no canvas to draw it with.
*/
function createLaunchPadZonePrimitive(launch) {
removeLaunchPadZonePrimitive();
const image = launchPadZoneImage();
const item = {
id: `rocket-pad-zone:${launch.id}`,
geometry: {
@@ -50,15 +112,9 @@ export function createLaunchPad({
semiMajor: LAUNCH_PAD_ZONE_RADIUS_M,
semiMinor: LAUNCH_PAD_ZONE_RADIUS_M,
},
fill: {
preset: 'radialRim',
color: hexColor(ZONE_COLOR, ZONE_FILL_ALPHA),
rimColor: hexColor(ZONE_COLOR, ZONE_RIM_ALPHA),
rimWidth: ZONE_RIM_WIDTH,
},
fill: image ? { image } : hexColor(ZONE_COLOR, ZONE_FILL_ALPHA),
height: 'clampGround',
clampTo: 'both',
depthBias: ZONE_DEPTH_BIAS_M,
show: true,
};
layerState._launchPadZoneItem = item;
+2 -2
View File
@@ -477,8 +477,8 @@ test('the trail head runs from the last fix to the marker every frame, dimmed be
color: hexColor('#ff4fd8', 0.9),
});
assert.deepEqual(
head.depthFailColor,
hexColor('#ff4fd8', 0.45),
head.depthFail,
{ kind: 'solid', color: hexColor('#ff4fd8', 0.45) },
'dimmed, not hidden, behind the surface',
);
assert.equal(head.positions.length, 2);
@@ -481,7 +481,10 @@ test('tracking without a Cockpit subject keeps its marks', async (t) => {
/** A ring's drawn colour and behind-the-globe colour. */
function ringColors(f, id) {
const item = f.ring(id);
return { color: [...item.style.color], depthFail: [...item.depthFailColor] };
return {
color: [...item.style.color],
depthFail: [...item.depthFail.color],
};
}
test('a Cockpit subject dims every other orbit ring and restores it exactly', async (t) => {
@@ -506,7 +509,11 @@ test('a Cockpit subject dims every other orbit ring and restores it exactly', as
);
assert.equal(f.ring(ISS_NORAD).show, true, 'other rings stay visible');
assert.equal(f.ring(GPS).show, false, 'the ridden ring stays hidden');
assert.deepEqual(ringColors(f, GPS), gpsBuilt, 'the ridden ring is not dimmed');
assert.deepEqual(
ringColors(f, GPS),
gpsBuilt,
'the ridden ring is not dimmed',
);
// Other satellites' points stay as they are.
assert.equal(f.state._points.get(COMPANION).show, true);
+1 -1
View File
@@ -251,7 +251,7 @@ test('the rendering part draws the dots, the tracked dot and the rings through t
assert.equal(rings.spec.pickable, false, 'ring clicks fall through');
const ring = rings.items.get('25544');
assert.deepEqual(ring.style, { kind: 'solid', color: [1, 1, 0, 0.6] });
assert.deepEqual(ring.depthFailColor, [1, 1, 0, 0.35]);
assert.deepEqual(ring.depthFail, { kind: 'solid', color: [1, 1, 0, 0.35] });
assert.equal(ring.widthPx, 2.5, 'the ISS ring is wider');
assert.equal(ring.mode, 'geodesic');
assert.deepEqual([...ring.positions.slice(0, 3)], [7e6, 0, 0]);
+10 -7
View File
@@ -229,10 +229,10 @@ export function createRendering({
kind: 'solid',
color: withAlpha(path.color, RING_ALPHA * factor),
};
path.item.depthFailColor = withAlpha(
path.color,
RING_BEHIND_ALPHA * factor,
);
path.item.depthFail = {
kind: 'solid',
color: withAlpha(path.color, RING_BEHIND_ALPHA * factor),
};
sets?.rings.upsert([path.item]);
return true;
}
@@ -460,7 +460,7 @@ export function createRendering({
/**
* Show orbital path for a satellite: the ring over one orbit, baked once
* in ECEF at the current GMST, bright in front of the globe and dimmed
* behind it (`depthFailColor`), and turned with the Earth each
* behind it (`depthFail`), and turned with the Earth each
* `RING_ROTATION_MS` (`_updateOrbitPathRotations`).
*/
@@ -494,7 +494,10 @@ export function createRendering({
// Along the ellipsoid between samples, as the ring always ran.
mode: 'geodesic',
style: { kind: 'solid', color: withAlpha(pathColor, RING_ALPHA) },
depthFailColor: withAlpha(pathColor, RING_BEHIND_ALPHA),
depthFail: {
kind: 'solid',
color: withAlpha(pathColor, RING_BEHIND_ALPHA),
},
show: true,
};
layerState._orbitPaths.set(noradId, path);
@@ -521,7 +524,7 @@ export function createRendering({
*
* No SGP4 here: WGS84 is rotationally symmetric about Z, so rotating the
* baked curve rigidly equals rebaking from rotated points. A ring with a
* `depthFailColor` is built at once where it now runs, so it never blinks.
* `depthFail` style is built at once where it now runs, so it never blinks.
* @param {Date} nowDate Epoch used for current GMST.
*/
+48 -41
View File
@@ -38,25 +38,6 @@ export const EASINGS = Object.freeze({
sineInOut: Cesium.EasingFunction.SINUSOIDAL_IN_OUT,
});
/**
* The contract's moves and looks as Cesium camera method names, called by
* name: a caller's camera may come from another copy of Cesium.
*/
const MOVES = Object.freeze({
forward: 'moveForward',
back: 'moveBackward',
left: 'moveLeft',
right: 'moveRight',
up: 'moveUp',
down: 'moveDown',
});
const LOOKS = Object.freeze({
left: 'lookLeft',
right: 'lookRight',
up: 'lookUp',
down: 'lookDown',
});
/** A contract destination as Cesium's: a Cartesian3, or a Rectangle. */
export function toDestination(d) {
if ('rect' in d) {
@@ -219,16 +200,60 @@ export function createCesiumCamera({
if (frustum.fov !== fov) frustum.fov = fov;
}
/**
* Put the eye at world point `destination` looking along `direction` with
* `up` up (made square to it), in the camera's frame: a `lookAt` frame
* stays, as Cesium's setView keeps it.
*/
function placeEye(destination, { direction, up }) {
const at = toCartesian(destination);
const dir = Cesium.Cartesian3.normalize(
toCartesian(direction),
new Cesium.Cartesian3(),
);
const right = Cesium.Cartesian3.normalize(
Cesium.Cartesian3.cross(dir, toCartesian(up), new Cesium.Cartesian3()),
new Cesium.Cartesian3(),
);
const square = Cesium.Cartesian3.cross(right, dir, new Cesium.Cartesian3());
const transform = camera.transform;
if (
transform &&
!Cesium.Matrix4.equals(transform, Cesium.Matrix4.IDENTITY)
) {
const inverse = Cesium.Matrix4.inverseTransformation(
transform,
new Cesium.Matrix4(),
);
Cesium.Matrix4.multiplyByPoint(inverse, at, camera.position);
Cesium.Matrix4.multiplyByPointAsVector(inverse, dir, camera.direction);
Cesium.Matrix4.multiplyByPointAsVector(inverse, square, camera.up);
Cesium.Matrix4.multiplyByPointAsVector(inverse, right, camera.right);
return;
}
Cesium.Cartesian3.clone(at, camera.position);
Cesium.Cartesian3.clone(dir, camera.direction);
Cesium.Cartesian3.clone(square, camera.up);
Cesium.Cartesian3.clone(right, camera.right);
}
const cameraPort = {
on: (event, cb, options) => cameraEvents.on(event, cb, options),
onCommand: (cb) => commandHooks.on(cb),
setView(spec) {
command('setView');
const d = spec.destination;
camera.setView({
...(d ? { destination: toDestination(d) } : {}),
orientation: toOrientation(spec.orientation),
});
const o = spec.orientation;
// A view by direction and up at a point is placed as given: Cesium's
// own setView would round it through heading, pitch and roll, which
// drifts looking straight down, where steps add up (the app's pans,
// turns and globe turns are setViews).
if (d && !('rect' in d) && o && 'direction' in o) placeEye(d, o);
else
camera.setView({
...(d ? { destination: toDestination(d) } : {}),
orientation: toOrientation(o),
});
scene.requestRender();
},
flyTo(destination, options = {}) {
@@ -314,24 +339,6 @@ export function createCesiumCamera({
camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
scene.requestRender();
},
move(direction, metres) {
camera[MOVES[direction]](metres);
scene.requestRender();
},
look(direction, radians) {
camera[LOOKS[direction]](radians);
scene.requestRender();
},
rotateAround(axis, radians) {
camera.rotate(toCartesian(axis), radians);
scene.requestRender();
},
zoom(metres) {
// Cesium's zoom, not a move: outside 3D it changes the view's width.
if (metres < 0) camera.zoomOut(-metres);
else camera.zoomIn(metres);
scene.requestRender();
},
setFov({ vertical }) {
// Cesium would take a bad angle and draw a garbage projection.
if (!(vertical > 0 && vertical < Math.PI))
+50 -227
View File
@@ -189,40 +189,11 @@ czm_material czm_getMaterial(czm_materialInput materialInput) {
return m;
}`;
/** The `radialRim` fill's material type. */
const RADIAL_RIM_MATERIAL = 'DrawRadialRimFill';
/**
* Across the ellipse (`st` from its centre, 1 at its edge) the fill's
* colour, easing into the rim's over `rimWidth` (a fraction of the
* radius) just inside a soft edge; the rim glows a little.
* How finely a clamped ellipse with an image fill is cut, radians, so an
* image's round edge (a zone's rim) runs round.
*/
const RADIAL_RIM_SOURCE = `
czm_material czm_getMaterial(czm_materialInput materialInput) {
czm_material material = czm_getDefaultMaterial(materialInput);
vec2 centered = (materialInput.st - vec2(0.5)) * 2.0;
float radius = length(centered);
float inside = 1.0 - smoothstep(0.985, 1.0, radius);
float rim = smoothstep(0.985 - rimWidth, 0.985, radius) * inside;
material.diffuse = mix(color.rgb, rimColor.rgb, rim);
material.emission = rimColor.rgb * rim * 0.35;
material.alpha = inside * mix(color.a, rimColor.a, rim);
return material;
}`;
/** How finely a rim-filled ellipse is cut, radians. */
const RIM_GRANULARITY = Cesium.Math.toRadians(0.08);
/**
* A ground fill pulled toward the eye (`depthBias`): depth-tested, not
* writing depth, offset toward the camera, alpha blended.
*/
const DEPTH_BIASED_STATE = Object.freeze({
depthTest: { enabled: true },
depthMask: false,
polygonOffset: { enabled: true, factor: -1, units: -4 },
blending: Cesium.BlendingState.ALPHA_BLEND,
});
const IMAGE_ELLIPSE_GRANULARITY = Cesium.Math.toRadians(0.08);
/**
* An image fill's material. The image carries its own alpha, so it draws in
@@ -241,33 +212,6 @@ function imageMaterial(image, repeat = [1, 1]) {
return material;
}
/** A `radialRim` fill's material. */
function radialRimMaterial(fill) {
const uniforms = {
color: toColor(fill.color),
rimColor: toColor(fill.rimColor),
rimWidth: fill.rimWidth,
};
// Built from its type, then given its values, as the line materials are.
const material = new Cesium.Material({
fabric: { type: RADIAL_RIM_MATERIAL, uniforms, source: RADIAL_RIM_SOURCE },
});
Object.assign(material.uniforms, uniforms);
return material;
}
/**
* An ellipse radius at a camera `height`: a fixed one as it is, one by
* camera height scaled by its factor and held within its bounds.
* @param {number|{byCameraHeight: {factor: number, min: number, max: number}}} radius
* @param {number} height
*/
export function radiusAt(radius, height) {
if (typeof radius === 'number') return radius;
const { factor, min, max } = radius.byCameraHeight;
return Math.max(min, Math.min(max, height * factor));
}
/**
* A shape's `animate`, checked: the Cesium renderer pulses alpha, forever.
* Null for a shape that does not pulse.
@@ -305,12 +249,6 @@ export function pulseAlpha(pulse, now) {
return pulse.from + (pulse.to - pulse.from) * (0.5 + 0.5 * Math.sin(turn));
}
/** Whether a shape is an ellipse with a radius by camera height. */
const byCameraHeight = (item) =>
item.geometry?.kind === 'ellipse' &&
(typeof item.geometry.semiMajor !== 'number' ||
typeof item.geometry.semiMinor !== 'number');
/** The line styles the port drapes. */
const DRAPED_STYLES = new Set(['solid', 'glow', 'dash', 'flow', 'arrow']);
@@ -1932,8 +1870,8 @@ export function createCesiumDraw({
positions.some((p) => !Cesium.Cartesian3.equals(p, positions[0]));
/**
* A line not draped that has a `depthFailColor`: a primitive of its own,
* drawn in that colour where the surface hides it. Built at once, so one
* A line not draped that has a `depthFail` style: a primitive of its own,
* drawn in that style where the surface hides it. Built at once, so one
* built anew where it moves draws in the frame it replaces the old one.
* Null when its positions make no line.
*/
@@ -1961,18 +1899,7 @@ export function createCesiumDraw({
}),
appearance: new Cesium.PolylineMaterialAppearance({ material }),
depthFailAppearance: new Cesium.PolylineMaterialAppearance({
material: lineMaterial(
record,
item.depthFailDash
? {
kind: 'dash',
color: item.depthFailColor,
length: item.depthFailDash.length,
pattern16: item.depthFailDash.pattern16,
}
: { kind: 'solid', color: item.depthFailColor },
reveal,
),
material: lineMaterial(record, item.depthFail, reveal),
}),
show: item.show !== false,
asynchronous: false,
@@ -2080,7 +2007,7 @@ export function createCesiumDraw({
const line = {
...rest,
mode: '3d',
depthFailColor: item.style.color,
depthFail: { kind: 'solid', color: item.style.color },
overlaid: true,
};
if (segmentShow?.length) {
@@ -2113,10 +2040,9 @@ export function createCesiumDraw({
return true;
}
/** An overlay line's look but its colours (its depth-fail colour is its
/** An overlay line's look but its colours (its depth-fail style is its
* colour too). */
const overlayShape = (item) =>
lineLook({ ...item, depthFailColor: null }, true);
const overlayShape = (item) => lineLook({ ...item, depthFail: null }, true);
/** Stop tracking a line no longer drawn over the surface for a draped
* one. */
@@ -2191,11 +2117,20 @@ export function createCesiumDraw({
);
else if (
item.frame === 'inertial' &&
(item.mode === 'draped' || item.depthFailColor)
(item.mode === 'draped' || item.depthFail)
)
throw new Error(
'the Cesium renderer draws inertial lines undraped, without depth-fail colours',
);
else if (
item.mode !== 'draped' &&
item.depthFail &&
item.depthFail.kind !== 'solid' &&
item.depthFail.kind !== 'dash'
)
throw new Error(
'the Cesium renderer draws solid and dashed lines behind the surface only',
);
else if (
segmented(item) &&
(item.mode !== 'draped' ||
@@ -2274,7 +2209,7 @@ export function createCesiumDraw({
draped.get(clampTo).push(drapedInstance(item, part, true));
continue;
}
if (item.depthFailColor) {
if (item.depthFail) {
deep ??= new Cesium.PrimitiveCollection();
const id = pickId(record, item);
const primitive = depthFailLine(record, item, id);
@@ -2418,10 +2353,14 @@ export function createCesiumDraw({
item.widthPx,
item.clampTo,
colourless ? { ...item.style, color: undefined } : item.style,
item.depthFailColor,
// A dash is drawn only with a depth-fail colour, the same in any key order.
item.depthFailColor && item.depthFailDash
? [item.depthFailDash.length, item.depthFailDash.pattern16]
// The same depth-fail style in any key order.
item.depthFail
? [
item.depthFail.kind,
item.depthFail.color,
item.depthFail.length,
item.depthFail.pattern16,
]
: null,
// Segment colours and shows change in place.
item.segmentColors != null,
@@ -2439,7 +2378,7 @@ export function createCesiumDraw({
Object.is(a.widthPx, b.widthPx) &&
a.clampTo === b.clampTo &&
a.style === b.style &&
a.depthFailColor === b.depthFailColor &&
a.depthFail === b.depthFail &&
(a.segmentColors != null) === (b.segmentColors != null) &&
(a.segmentShow != null) === (b.segmentShow != null) &&
revealed(a) === revealed(b) &&
@@ -2756,7 +2695,7 @@ export function createCesiumDraw({
const settles = (item) =>
item.mode !== 'draped' &&
item.frame !== 'inertial' &&
!item.depthFailColor &&
!item.depthFail &&
item.style.kind === 'solid' &&
!revealed(item) &&
// The collection draws no line under half a pixel wide; a batch
@@ -3219,10 +3158,6 @@ export function createCesiumDraw({
};
}
case 'ellipse': {
if (byCameraHeight(item))
throw new Error(
'the Cesium renderer takes radii by camera height on clamped ellipses only',
);
const ellipse = {
center: toCartesian(g.center),
semiMajorAxis: g.semiMajor,
@@ -3276,91 +3211,12 @@ export function createCesiumDraw({
}
}
/**
* The camera's height for radii by camera height: above the ellipsoid,
* as Cesium places it (1000 m while it has none).
*/
const cameraHeight = () => {
const height = scene.camera?.positionCartographic?.height;
return Number.isFinite(height) ? height : 1000;
};
/** A clamped ellipse's radii by camera height at this frame's height, or null. */
function radiiOf(item) {
if (!byCameraHeight(item)) return null;
const height = cameraHeight();
return [
radiusAt(item.geometry.semiMajor, height),
radiusAt(item.geometry.semiMinor, height),
];
}
/**
* Before a frame draws: clamped ellipses with radii by camera height
* whose radii have changed with the camera are drawn at the new ones. A
* colour fill is drawn alone where it is, built in this frame
* (`moveShape`), as Cesium's entities rebuild a ground ellipse whose
* radius follows a callback, while no more than `MOVING_SHAPES` of the
* set would be drawn alone; past that, and for any other fill once its
* radii have changed by more than `REBUILD_RADII`, its set rebuilds (one
* rebuild at a time). Hidden ones wait until they show.
*/
function followCameraHeight() {
for (const record of sets.values()) {
const parts = record.shapeParts;
if (record.kind !== 'shapes' || !parts || record.spec.show === false)
continue;
try {
followIn(record, parts);
} catch (error) {
// The set draws as it did; the next frame tries again.
report(error);
}
}
}
/** Relative change of radii past which a fill drawn in a batch rebuilds. */
const REBUILD_RADII = 0.02;
function followIn(record, parts) {
const changed = (radii, part, by) =>
Math.abs(radii[0] - part.radii[0]) > by * part.radii[0] ||
Math.abs(radii[1] - part.radii[1]) > by * part.radii[1];
let alone = 0;
for (const part of parts.values()) if (part.solo) alone += 1;
// Those the host still retiring draws alone count too, until it goes.
if (record.retiring)
for (const part of record.retiringShapeParts?.values() ?? [])
if (part.solo && part.ground && !part.ground.isDestroyed()) alone += 1;
let rebuild = false;
for (const [id, part] of parts) {
if (!part.radii || !part.ground) continue;
const item = record.items.get(id);
if (!item || item.show === false || !byCameraHeight(item)) continue;
const radii = radiiOf(item);
if (!changed(radii, part, 1e-3)) continue;
if (part.ground.isDestroyed() || part.batch?.isDestroyed()) continue;
const movable =
colourFill(item) &&
groundSyncs() &&
typeof record.host?.add === 'function' &&
(part.solo || alone < MOVING_SHAPES);
if (movable) {
if (!part.solo) alone += 1;
moveShape(record, part, item);
} else if (changed(radii, part, REBUILD_RADII)) rebuild = true;
}
if (rebuild && !record.pending) {
record.rebuild();
requestRender();
}
}
/**
* A clamped shape's fill geometry, on the ellipsoid for draping; an
* ellipse with a rim fill is cut finely, so its rim runs round.
* ellipse with an image fill is cut finely, so a round image's edge runs
* round.
*/
function groundGeometry(item, rimFill = null) {
function groundGeometry(item, imageFill = false) {
const g = item.geometry;
switch (g.kind) {
case 'polygon': {
@@ -3373,21 +3229,19 @@ export function createCesiumDraw({
});
}
case 'ellipse': {
// Radii by camera height are the ones it has at this frame's height.
const height = cameraHeight();
const major = radiusAt(g.semiMajor, height);
const minor = radiusAt(g.semiMinor, height);
// Radii that follow the camera apart may cross: the longer is then
// drawn as Cesium's semi-major axis, a quarter turn on.
const major = g.semiMajor;
const minor = g.semiMinor;
// A semi-minor axis longer than the semi-major one is drawn as
// Cesium's semi-major axis, a quarter turn on.
const crossed = minor > major;
return new Cesium.EllipseGeometry({
center: toCartesian(g.center),
semiMajorAxis: crossed ? minor : major,
semiMinorAxis: crossed ? major : minor,
rotation: (g.rotation ?? 0) + (crossed ? Math.PI / 2 : 0),
...(rimFill
...(imageFill
? {
granularity: RIM_GRANULARITY,
granularity: IMAGE_ELLIPSE_GRANULARITY,
vertexFormat:
Cesium.MaterialAppearance.MaterialSupport.TEXTURED
.vertexFormat,
@@ -3436,11 +3290,7 @@ export function createCesiumDraw({
typeof item.fill === 'object' && !Array.isArray(item.fill)
? item.fill
: null;
const rimFill =
objectFill?.preset === 'radialRim' && item.geometry.kind === 'ellipse'
? objectFill
: null;
const imageFill = rimFill ? null : objectFill;
const imageFill = objectFill;
if (imageFill && !imageFill.image)
throw new Error('the Cesium renderer fills shapes with colours only');
if (item.extrudeHeight !== undefined)
@@ -3457,7 +3307,7 @@ export function createCesiumDraw({
// load when they show.
let geometry;
try {
geometry = groundGeometry(item, rimFill);
geometry = groundGeometry(item, Boolean(imageFill));
} catch (error) {
if (item.show === false) continue;
throw error;
@@ -3466,8 +3316,6 @@ export function createCesiumDraw({
look: lookOf(item),
id: pickId(record, item),
ground: null,
// Radii by camera height as drawn (`followCameraHeight`).
radii: radiiOf(item),
pulse: pulseOf(item),
show: item.show !== false,
};
@@ -3477,29 +3325,17 @@ export function createCesiumDraw({
);
const instance = new Cesium.GeometryInstance({
geometry,
attributes:
imageFill || rimFill
? { show }
: {
color: Cesium.ColorGeometryInstanceAttribute.fromColor(
toColor(item.fill),
),
show,
},
attributes: imageFill
? { show }
: {
color: Cesium.ColorGeometryInstanceAttribute.fromColor(
toColor(item.fill),
),
show,
},
id: part.id,
});
const clampTo = item.clampTo ?? record.spec.clampTo ?? 'both';
if (rimFill) {
// A rim fill is a ground primitive of its own, with its material.
batches.push({
clampTo,
instances: [instance],
parts: [part],
rimFill,
depthBias: item.depthBias,
});
continue;
}
if (imageFill) {
// An image fill is a ground primitive of its own, with its material.
// (Cesium turns its texture wrongly across the antimeridian: its
@@ -3540,9 +3376,7 @@ export function createCesiumDraw({
const grounds = batches.map((batch) => {
const material = batch.imageFill
? imageMaterial(batch.image, batch.imageFill.repeat)
: batch.rimFill
? radialRimMaterial(batch.rimFill)
: null;
: null;
const ground = new Ground({
geometryInstances: batch.instances,
classificationType: classificationOf(batch.clampTo),
@@ -3555,15 +3389,6 @@ export function createCesiumDraw({
Cesium.MaterialAppearance.MaterialSupport.TEXTURED,
translucent: true,
flat: true,
...(batch.rimFill
? {
closed: false,
faceForward: true,
...(batch.depthBias
? { renderState: DEPTH_BIASED_STATE }
: {}),
}
: {}),
}),
}
: {}),
@@ -3943,7 +3768,6 @@ export function createCesiumDraw({
part.solo = true;
part.pendingShow = undefined;
part.look = lookOf(item);
part.radii = radiiOf(item);
part.pulse = pulseOf(item);
part.show = item.show !== false;
part.pendingColour = undefined;
@@ -4344,7 +4168,6 @@ export function createCesiumDraw({
building: () => [...sets.values()].some((record) => record.pending),
/** Each frame, before it draws: the horizon cull. */
beforeRender() {
followCameraHeight();
pulsing = runPulses();
cullHorizon();
runFlows();
+73 -168
View File
@@ -508,7 +508,7 @@ test('hidden clamped fills wait for nothing, and the hidden ones it cannot build
set.set([
fill('a', 0, false, { outline: '#000' }),
fill('b', 1, false, { extrudeHeight: 10 }),
fill('c', 2, false, { fill: { preset: 'radialRim' } }),
fill('c', 2, false, { fill: { gradient: 'radial' } }),
]),
);
assert.equal(groundsIn(scene.added.at(-1)).length, 0);
@@ -596,57 +596,22 @@ test('clamped shapes refuse what they cannot draw', () => {
fill: '#fff',
height: 'clampGround',
};
// A rim fill is drawn on ellipses alone.
// A fill that is neither a colour nor an image.
assert.throws(
() =>
set.set([
{
...disc,
geometry: {
kind: 'rectangle',
rect: { west: 0, south: 0, east: 1, north: 1 },
},
fill: {
preset: 'radialRim',
color: '#fff',
rimColor: '#fff',
rimWidth: 0.1,
},
},
]),
() => set.set([{ ...disc, fill: { gradient: 'radial' } }]),
/colours only/,
);
set.dispose();
// Radii by camera height are for clamped ellipses alone.
const unclamped = draw.shapes({ id: 'refuse-unclamped' });
assert.throws(
() =>
unclamped.set([
{
...disc,
height: 'absolute',
geometry: {
...disc.geometry,
semiMajor: { byCameraHeight: { factor: 1, min: 1, max: 2 } },
},
},
]),
/radii by camera height on clamped ellipses only/,
);
unclamped.dispose();
});
test('a clamped ellipse with radii by camera height draws at the camera height and follows it', () =>
test('a clamped colour ring whose radius alone changes is drawn alone where it now is', () =>
withTerrainHeights(() => {
const scene = fakeScene();
let height = 2000;
Object.defineProperty(scene.camera, 'positionCartographic', {
get: () => ({ height }),
});
const { draw, frame } = drawOver(scene);
const set = draw.shapes({ id: 'rings' });
const radius = { byCameraHeight: { factor: 0.03, min: 14, max: 170 } };
const ring = (show = true) => ({
// The app follows the camera's height and sends the radius it wants, as
// annotation target rings do.
const ring = (radius, show = true) => ({
id: 'ring',
geometry: {
kind: 'ellipse',
@@ -658,115 +623,65 @@ test('a clamped ellipse with radii by camera height draws at the camera height a
height: 'clampGround',
show,
});
set.set([ring()]);
set.set([ring(60)]);
const host = scene.added[0];
const radiusIn = (ground) =>
ground.geometryInstances[0].geometry._semiMajorAxis;
const last = () => host.get(host.length - 1);
assert.equal(radiusIn(last()), 60, '3% of 2000 m');
// The camera has not moved: nothing is built.
assert.equal(radiusIn(last()), 60);
const built = last();
frame();
assert.equal(last(), built);
// It climbs: the ring is drawn wider in the frame that draws it, alone.
height = 4000;
frame();
assert.equal(last(), built, 'nothing built while nothing changes');
// Wider: drawn alone, built in this frame, under its own pick id.
set.upsert([ring(120)]);
const wider = last();
assert.notEqual(wider, built);
assert.equal(wider.asynchronous, false);
assert.equal(radiusIn(wider), 120);
assert.equal(wider.geometryInstances[0].id.id, 'ring', 'its own pick id');
// Held within its bounds.
height = 1e6;
frame();
assert.equal(radiusIn(last()), 170);
height = 10;
frame();
set.upsert([ring(14)]);
assert.equal(radiusIn(last()), 14);
// Hidden, it waits; shown, it catches up.
set.upsert([ring(false)]);
const lastShown = last();
height = 3000;
frame();
assert.equal(last(), lastShown, 'hidden: not rebuilt');
set.upsert([ring(true)]);
frame();
assert.equal(radiusIn(last()), 90);
assert.equal(scene.added[0], host, 'never a rebuild of the set');
set.dispose();
assert.equal(scene.added.length, 0);
}));
test('radii by camera height that cross draw the longer as the major axis; past the cap of shapes drawn alone, the set rebuilds', () =>
test('a semi-minor axis longer than the semi-major is drawn as the major axis, a quarter turn on', () =>
withTerrainHeights(() => {
const scene = fakeScene();
let height = 1000;
Object.defineProperty(scene.camera, 'positionCartographic', {
get: () => ({ height }),
});
const { draw, frame } = drawOver(scene);
const { draw } = drawOver(scene);
const set = draw.shapes({ id: 'crossing' });
const ring = (id, lon) => ({
id,
geometry: {
kind: 'ellipse',
center: { lon, lat: 0 },
semiMajor: { byCameraHeight: { factor: 0.03, min: 14, max: 170 } },
semiMinor: { byCameraHeight: { factor: 0.05, min: 20, max: 100 } },
rotation: 0.25,
set.set([
{
id: 'r',
geometry: {
kind: 'ellipse',
center: { lon: 0, lat: 0 },
semiMajor: 30,
semiMinor: 50,
rotation: 0.25,
},
fill: [0.5, 0.9, 1, 0.38],
height: 'clampGround',
},
fill: [0.5, 0.9, 1, 0.38],
height: 'clampGround',
});
const rings = Array.from({ length: MOVING_SHAPES + 4 }, (_, i) =>
ring(`r${i}`, i * 0.1),
);
assert.doesNotThrow(() => set.set(rings));
const first = scene.added[0];
const ground = (host) => {
for (let i = 0; i < host.length; i++)
if (host.get(i) instanceof Cesium.GroundPrimitive) return host.get(i);
return null;
};
const geometry = ground(first).geometryInstances[0].geometry;
assert.equal(geometry._semiMajorAxis, 50, 'the longer, 5% of 1000 m');
]);
const host = scene.added[0];
let ground = null;
for (let i = 0; i < host.length; i++)
if (host.get(i) instanceof Cesium.GroundPrimitive) ground = host.get(i);
const geometry = ground.geometryInstances[0].geometry;
assert.equal(geometry._semiMajorAxis, 50);
assert.equal(geometry._semiMinorAxis, 30);
assert.ok(Math.abs(geometry._rotation - (0.25 + Math.PI / 2)) < 1e-12);
// Its batches built.
for (let i = 0; i < first.length; i++)
if (first.get(i) instanceof Cesium.GroundPrimitive) {
Object.defineProperty(first.get(i), 'ready', { value: true });
first.get(i).getGeometryInstanceAttributes = () => ({
show: new Uint8Array([1]),
});
}
frame();
// The camera climbs: no more than the cap are drawn alone; the set
// rebuilds for the rest, and nothing throws in the frame.
height = 1500;
assert.doesNotThrow(() => frame());
let solo = 0;
for (let i = 0; i < first.length; i++) {
const p = first.get(i);
if (p instanceof Cesium.GroundPrimitive && p.asynchronous === false)
solo += 1;
}
assert.equal(solo, MOVING_SHAPES);
assert.notEqual(scene.added.at(-1), first, 'rebuilt for the rest');
set.dispose();
}));
test('rings drawn alone by a host still retiring count toward the cap when the camera moves again', () =>
test('rings that would be drawn alone past the cap rebuild their set, counting those a retiring host draws alone', () =>
withTerrainHeights(() => {
const scene = fakeScene();
let height = 1000;
Object.defineProperty(scene.camera, 'positionCartographic', {
get: () => ({ height }),
});
const { draw, frame } = drawOver(scene);
const set = draw.shapes({ id: 'climbing' });
const radius = { byCameraHeight: { factor: 0.03, min: 14, max: 170 } };
const rings = Array.from({ length: MOVING_SHAPES + 4 }, (_, i) => ({
const ring = (i, radius) => ({
id: `r${i}`,
geometry: {
kind: 'ellipse',
@@ -776,7 +691,9 @@ test('rings drawn alone by a host still retiring count toward the cap when the c
},
fill: [0.5, 0.9, 1, 0.38],
height: 'clampGround',
}));
});
const all = (radius, from = 0, to = MOVING_SHAPES + 4) =>
Array.from({ length: to - from }, (_, k) => ring(from + k, radius));
const ready = (host) => {
for (let i = 0; i < host.length; i++)
if (host.get(i) instanceof Cesium.GroundPrimitive) {
@@ -795,21 +712,22 @@ test('rings drawn alone by a host still retiring count toward the cap when the c
}
return n;
};
set.set(rings);
set.set(all(30));
const first = scene.added[0];
ready(first);
frame();
// A climb: the cap drawn alone, and a rebuild for the rest.
height = 1500;
frame();
// The cap moves alone.
set.upsert(all(45, 0, MOVING_SHAPES));
assert.equal(solo(first), MOVING_SHAPES);
assert.equal(scene.added.at(-1), first);
// One more would pass it: the set rebuilds, the old host retiring.
set.upsert(all(45, MOVING_SHAPES));
const second = scene.added.at(-1);
assert.notEqual(second, first, 'rebuilding, the old host retiring');
ready(second);
// Climbing on while the old host retires: its rings drawn alone still
// count, so none more are drawn alone.
height = 2500;
frame();
// While the old host retires, its rings drawn alone still count, so
// none more are drawn alone.
set.upsert([ring(0, 75)]);
assert.equal(solo(second), 0, 'nothing more drawn alone');
set.dispose();
}));
@@ -4224,12 +4142,7 @@ test('an unclamped shape filled with an image draws a textured primitive and fre
kind: 'rectangle',
rect: { west: 0, south: 0, east: 1, north: 1 },
},
fill: {
preset: 'radialRim',
color: '#fff',
rimColor: '#000',
rimWidth: 1,
},
fill: { gradient: 'radial' },
},
]),
/colours only/,
@@ -4564,7 +4477,7 @@ test('a line with a depth-fail colour draws it behind the surface, and moves in
widthPx: 2.5,
mode: 'geodesic',
style: { kind: 'solid', color: [1, 0, 1, 0.9] },
depthFailColor: [1, 0, 1, 0.45],
depthFail: { kind: 'solid', color: [1, 0, 1, 0.45] },
meta: height,
...extra,
});
@@ -4579,7 +4492,7 @@ test('a line with a depth-fail colour draws it behind the surface, and moves in
widthPx: 1,
mode: '3d',
style: { kind: 'solid', color: '#fff' },
depthFailColor: null,
depthFail: null,
},
]);
const host = scene.added[0];
@@ -4629,13 +4542,15 @@ test('a line with a depth-fail colour draws it behind the surface, and moves in
assert.equal(deep.length, 1);
assert.equal(deep.get(0).show, false, 'hidden as asked');
// A new colour is a new look: rebuilt.
set.upsert([head(400, { depthFailColor: [1, 1, 1, 1] })]);
set.upsert([
head(400, { depthFail: { kind: 'solid', color: [1, 1, 1, 1] } }),
]);
assert.notEqual(scene.added[0], host);
set.dispose();
assert.equal(scene.added.length, 0);
}));
test('a depth-fail dash dashes the parts behind the surface, in the depth-fail colour', () =>
test('a dashed depth-fail style dashes the parts behind the surface, in its colour', () =>
withImageClasses(() => {
const { scene, draw } = drawOver();
const set = draw.lines({ id: 'band' });
@@ -4648,8 +4563,7 @@ test('a depth-fail dash dashes the parts behind the surface, in the depth-fail c
widthPx: 3,
mode: 'geodesic',
style: { kind: 'dash', color: [1, 1, 0, 0.9], length: 16 },
depthFailColor: [0, 1, 1, 0.35],
depthFailDash: { length: 16 },
depthFail: { kind: 'dash', color: [0, 1, 1, 0.35], length: 16 },
...extra,
});
set.set([band()]);
@@ -4666,21 +4580,27 @@ test('a depth-fail dash dashes the parts behind the surface, in the depth-fail c
assert.equal(hidden.uniforms.dashLength, 16);
assert.equal(hidden.uniforms.dashPattern, 255, 'the default pattern');
// A move keeps the dash; its fields in another order are the same look.
set.upsert([band({ depthFailDash: { length: 16 } })]);
set.upsert([
band({ depthFail: { length: 16, color: [0, 1, 1, 0.35], kind: 'dash' } }),
]);
assert.equal(scene.added[0], host, 'not rebuilt');
assert.equal(
host.get(1).get(0).depthFailAppearance.material.type,
'PolylineDash',
);
set.upsert([band({ depthFailDash: { pattern16: 0xf0f0, length: 8 } })]);
const patternedBand = (fields) =>
band({ depthFail: { kind: 'dash', color: [0, 1, 1, 0.35], ...fields } });
set.upsert([patternedBand({ pattern16: 0xf0f0, length: 8 })]);
const patterned = scene.added[0].get(1).get(0).depthFailAppearance.material;
assert.equal(patterned.uniforms.dashPattern, 0xf0f0);
assert.equal(patterned.uniforms.dashLength, 8);
const again = scene.added[0];
set.upsert([band({ depthFailDash: { length: 8, pattern16: 0xf0f0 } })]);
set.upsert([patternedBand({ length: 8, pattern16: 0xf0f0 })]);
assert.equal(scene.added[0], again, 'the same dash in another order');
// Without it the hidden parts are solid; the change is a new look.
set.upsert([band({ depthFailDash: undefined })]);
// Solid behind the surface: a new look.
set.upsert([
band({ depthFail: { kind: 'solid', color: [0, 1, 1, 0.35] } }),
]);
assert.notEqual(scene.added[0], host, 'rebuilt');
const solid = scene.added[0].get(1).get(0).depthFailAppearance.material;
assert.equal(solid.type, 'Color');
@@ -5456,7 +5376,7 @@ test('where the scene cannot drape, an overlay line is culled by its whole arc,
],
widthPx: 2,
mode: '3d',
depthFailColor: [1, 0, 0, 1],
depthFail: { kind: 'solid', color: [1, 0, 0, 1] },
style: { kind: 'solid', color: [1, 0, 0, 1] },
},
]);
@@ -5615,7 +5535,7 @@ test('revealFraction reveals flow and depth-fail lines too, their clocks still r
widthPx: 2,
mode: '3d',
style: { kind: 'solid', color: '#f0f' },
depthFailColor: [1, 0, 1, 0.45],
depthFail: { kind: 'solid', color: [1, 0, 1, 0.45] },
revealFraction: 0.5,
},
]);
@@ -6889,7 +6809,7 @@ test('a pattern line draws its image along it, repeated, and an inertial line tu
assert.equal(scene.added.length, 0);
}));
test('a clamped ellipse filled with a radial rim drapes its material, finely cut, pulled toward the eye', () =>
test('a clamped ellipse with an image fill drapes its material, finely cut so a round image runs round', () =>
withImageClasses(() => {
const { scene, draw } = drawOver();
const set = draw.shapes({ id: 'pad-zone' });
@@ -6901,14 +6821,8 @@ test('a clamped ellipse filled with a radial rim drapes its material, finely cut
semiMajor: 500,
semiMinor: 500,
},
fill: {
preset: 'radialRim',
color: [0.13, 0.9, 0.9, 0.105],
rimColor: [0.13, 0.9, 0.9, 0.72],
rimWidth: 0.033,
},
fill: { image: 'zone.png' },
height: 'clampGround',
depthBias: 1,
};
set.set([zone]);
const host = scene.added[0];
@@ -6918,17 +6832,8 @@ test('a clamped ellipse filled with a radial rim drapes its material, finely cut
assert.ok(ground);
const { appearance } = ground;
assert.ok(appearance instanceof Cesium.MaterialAppearance);
assert.equal(appearance.material.type, 'DrawRadialRimFill');
const { color, rimColor, rimWidth } = appearance.material.uniforms;
assert.ok(
color.equalsEpsilon(new Cesium.Color(0.13, 0.9, 0.9, 0.105), 1e-9),
);
assert.ok(
rimColor.equalsEpsilon(new Cesium.Color(0.13, 0.9, 0.9, 0.72), 1e-9),
);
assert.equal(rimWidth, 0.033);
assert.equal(appearance.renderState.polygonOffset.enabled, true);
assert.equal(appearance.renderState.depthMask, false);
assert.equal(appearance.material.type, 'Image');
assert.equal(appearance.material.uniforms.image, 'zone.png');
assert.equal(ground.classificationType, Cesium.ClassificationType.BOTH);
const [instance] = ground.geometryInstances;
assert.ok(instance.geometry instanceof Cesium.EllipseGeometry);
+2 -2
View File
@@ -44,7 +44,7 @@ export const CESIUM_CHECKS = new Set([
'draw.field.windStreamlines',
'draw.icons.distance',
'draw.icons.update',
'draw.lines.depthFailDash',
'draw.lines.depthFail',
'draw.lines.settled',
'draw.lines.styles',
'draw.lines.drape',
@@ -65,7 +65,7 @@ export const CESIUM_CHECKS = new Set([
'draw.displayRange',
'draw.sets',
'draw.shapes.drapedRotation',
'draw.shapes.radiusByCameraHeight',
'draw.shapes.resize',
'effects.crossfade',
'effects.defineStyle',
'effects.screenModulation',
+20
View File
@@ -6,6 +6,12 @@
* reference recorder's own.
*/
import { wheelLines } from '../input/wheel.js';
import {
eyeMoved,
eyeRotatedAbout,
eyeTurned,
eyeZoomed,
} from '../../geo/eyeMoves.js';
const NO_MODIFIERS = Object.freeze({
shift: false,
@@ -187,6 +193,18 @@ function resolveArgs(driver, name, args) {
return args;
}
/**
* Script steps that are the app's own sums over the pose, not port verbs: the
* contract driver turns them into `setView`, where the reference recorder
* runs Cesium's matching camera functions.
*/
const EYE_STEPS = {
move: eyeMoved,
look: eyeTurned,
rotateAround: eyeRotatedAbout,
zoom: eyeZoomed,
};
/**
* A driver over a renderer, through the contract only.
* @param {import('../contract/renderer').Renderer} renderer
@@ -200,6 +218,8 @@ export function contractDriver(renderer, hooks) {
const camera = renderer.camera;
return {
command(name, args) {
if (Object.hasOwn(EYE_STEPS, name))
return camera.setView(EYE_STEPS[name](camera.pose(), ...args));
return camera[name](...args);
},
frame: hooks.frame,
+1 -1
View File
@@ -253,7 +253,7 @@ export const CAMERA_SCRIPTS = Object.freeze([
},
{ do: 'move', args: ['forward', 500] },
{ record: 'pose' },
{ do: 'rotateAround', args: [{ x: 0, y: 0, z: 1 }, 0.4] },
{ do: 'look', args: ['left', 0.4] },
{ record: 'pose' },
{ do: 'zoom', args: [-1000] },
{ record: 'pose' },
+2 -1
View File
@@ -10,6 +10,7 @@ import {
} from '../cameraScripts.js';
import { contractDriver, runCameraScript } from '../cameraRunner.js';
import { deepEqual, equal, near, nearAngle, nearVec, ok } from '../expect.js';
import { eyeMoved } from '../../../geo/eyeMoves.js';
const lonLatToEcef = (h) => h.toEcef;
@@ -389,7 +390,7 @@ export function cameraChecks() {
r.camera.on('moveEnd', () => events.push(['end', h.now(r)]));
await h.frame(r);
const movingAt = h.now(r);
r.camera.move('forward', 1000);
r.camera.setView(eyeMoved(r.camera.pose(), 'forward', 1000));
await h.frame(r);
equal(events[0]?.[0], 'start', 'moveStart after the move');
const movedAt = h.now(r);
+27 -32
View File
@@ -1714,7 +1714,7 @@ export function portChecks() {
},
),
check(
'draw.lines.depthFailDash',
'draw.lines.depthFail',
'a line dashed behind the surface draws, moves in place and changes back to solid',
async (h, r) => {
await overAustin(h, r);
@@ -1727,8 +1727,7 @@ export function portChecks() {
widthPx: 3,
mode: 'geodesic',
style: { kind: 'dash', color: [1, 1, 0, 0.9], length: 16 },
depthFailColor: [0, 1, 1, 0.35],
depthFailDash: { length: 16 },
depthFail: { kind: 'dash', color: [0, 1, 1, 0.35], length: 16 },
...extra,
});
lines.set([band(-200)]);
@@ -1737,7 +1736,9 @@ export function portChecks() {
lines.upsert([band(-100)]);
await drawn(h, r);
equal(lines.size(), 1, 'moved in place, not added');
lines.upsert([band(-100, { depthFailDash: undefined })]);
lines.upsert([
band(-100, { depthFail: { kind: 'solid', color: [0, 1, 1, 0.35] } }),
]);
await drawn(h, r);
equal(lines.size(), 1, 'solid behind the surface again');
lines.dispose();
@@ -1877,24 +1878,21 @@ export function portChecks() {
},
),
check(
'draw.shapes.radiusByCameraHeight',
'a clamped ellipse with radii by camera height draws at the radius the camera height gives, held within its bounds, and follows the camera',
'draw.shapes.resize',
'a clamped ellipse whose radius alone is upserted draws at the new radius, growing and shrinking',
async (h, r) => {
const shapes = r.draw.shapes({ id: 'conf:rings' });
const radius = { byCameraHeight: { factor: 0.1, min: 50, max: 600 } };
shapes.set([
{
id: 'ring',
geometry: {
kind: 'ellipse',
center: { lon: AUSTIN.lon, lat: AUSTIN.lat },
semiMajor: radius,
semiMinor: radius,
},
fill: [0.5, 0.9, 1, 0.6],
height: 'clampGround',
const ring = (radius) => ({
id: 'ring',
geometry: {
kind: 'ellipse',
center: { lon: AUSTIN.lon, lat: AUSTIN.lat },
semiMajor: radius,
semiMinor: radius,
},
]);
fill: [0.5, 0.9, 1, 0.6],
height: 'clampGround',
});
// Metres east of the centre, at its latitude.
const east = (m) =>
h.toEcef({
@@ -1919,22 +1917,19 @@ export function portChecks() {
}
return false;
};
// 2000 m up: 200 m across its centre.
await overAustin(h, r, 2000);
ok(await until(() => covers(150)), 'at 2000 m it reaches 150 m');
ok(!covers(260), 'and not 260 m');
// 4000 m up: 400 m.
await overAustin(h, r, 4000);
shapes.set([ring(200)]);
ok(
await until(() => covers(150) && !covers(260)),
'at 200 m it reaches 150 m, not 260 m',
);
shapes.upsert([ring(400)]);
ok(
await until(() => covers(300) && !covers(460)),
'at 4000 m it reaches 300 m, not 460 m',
);
// 20 km up: held at 600 m.
await overAustin(h, r, 20000);
ok(
await until(() => covers(550) && !covers(700)),
'held at its largest',
'at 400 m it reaches 300 m, not 460 m',
);
shapes.upsert([ring(200)]);
ok(await until(() => covers(150) && !covers(260)), 'back at 200 m');
shapes.dispose();
await drawn(h, r);
ok(!covers(0), 'gone with its set');
@@ -1961,7 +1956,7 @@ export function portChecks() {
widthPx: 3,
mode: '3d',
style: { kind: 'solid', color: '#ff00ff' },
depthFailColor: [1, 0, 1, 0.45],
depthFail: { kind: 'solid', color: [1, 0, 1, 0.45] },
});
lines.set([
{
+48 -48
View File
@@ -1117,29 +1117,29 @@
"kind": "pose",
"value": {
"position": {
"x": -744971.9139187913,
"y": -5464375.678277303,
"z": 3195735.7092693974
"x": -744481.3426810508,
"y": -5464789.733339174,
"z": 3195145.9335938734
},
"direction": {
"x": 0.8577979868850266,
"y": 0.50373228948861,
"z": 0.10215867179324013
"x": 0.3312543721140628,
"y": 0.7819390858650948,
"z": 0.5280547385941896
},
"up": {
"x": 0.33601932677210566,
"y": -0.6999992672201266,
"z": 0.6301523926217426
"x": 0.22881921132251012,
"y": -0.6095195427272047,
"z": 0.7590307606173572
},
"right": {
"x": 0.38893910285752537,
"y": -0.5062161657018166,
"z": -0.7697217470297525
"x": 0.915375501903488,
"y": -0.13060318920332545,
"z": -0.38082869834724636
},
"heading": 1.099821436536688,
"pitch": -0.5003437292588502,
"roll": 6.283185070682873,
"height": 1198.9411841126202,
"heading": 0.25083973344668564,
"pitch": -0.45766939657173955,
"roll": 0.20978125179289364,
"height": 1198.941902759726,
"frameIsIdentity": false
}
},
@@ -1148,29 +1148,29 @@
"kind": "pose",
"value": {
"position": {
"x": -745829.7119056764,
"y": -5464879.410566793,
"z": 3195633.5505976044
"x": -744812.5970531654,
"y": -5465571.672425042,
"z": 3194617.878855279
},
"direction": {
"x": 0.8577979868850265,
"y": 0.5037322894886102,
"z": 0.10215867179324012
"x": 0.33125437211406306,
"y": 0.7819390858650948,
"z": 0.5280547385941895
},
"up": {
"x": 0.33601932677210533,
"y": -0.6999992672201268,
"z": 0.6301523926217425
"x": 0.22881921132251018,
"y": -0.6095195427272047,
"z": 0.7590307606173573
},
"right": {
"x": 0.3889391028575255,
"y": -0.5062161657018166,
"z": -0.7697217470297526
"x": 0.9153755019034878,
"y": -0.1306031892033257,
"z": -0.38082869834724653
},
"heading": 1.0997500524431754,
"pitch": -0.5004811848386681,
"roll": 6.283184976084162,
"height": 1678.7289113419563,
"heading": 0.2508194571959139,
"pitch": -0.45781035725623687,
"roll": 0.20978111856887782,
"height": 1640.8642564622487,
"frameIsIdentity": false
}
},
@@ -1179,29 +1179,29 @@
"kind": "pose",
"value": {
"position": {
"x": -745829.7119056764,
"y": -5464879.410566793,
"z": 3195633.5505976044
"x": -744812.5970531654,
"y": -5465571.672425042,
"z": 3194617.878855279
},
"direction": {
"x": 0.8577979868850266,
"y": 0.5037322894886103,
"z": 0.1021586717932402
"x": 0.3312543721140633,
"y": 0.7819390858650948,
"z": 0.5280547385941896
},
"up": {
"x": 0.33601932677210533,
"y": -0.6999992672201268,
"z": 0.6301523926217425
"x": 0.22881921132251018,
"y": -0.6095195427272047,
"z": 0.7590307606173573
},
"right": {
"x": 0.3889391028575255,
"y": -0.5062161657018165,
"z": -0.7697217470297525
"x": 0.9153755019034878,
"y": -0.13060318920332578,
"z": -0.3808286983472466
},
"heading": 1.0997500524431754,
"pitch": -0.5004811848386681,
"roll": 6.283184976084162,
"height": 1678.7289113419563,
"heading": 0.2508194571959148,
"pitch": -0.4578103572562373,
"roll": 0.20978111856887693,
"height": 1640.8642564622487,
"frameIsIdentity": true
}
}
+7 -7
View File
@@ -208,6 +208,13 @@ export type CameraEvent =
export interface CameraPort {
pose(): CameraPose;
/**
* Place the eye. A position with a `{direction, up}` orientation is placed
* exactly as given (`up` made square to `direction`), never rounded
* through heading, pitch and roll: the application's step moves (pans, turns, the
* globe turned under the eye, zooms; `geo/eyeMoves`) are such views,
* sent many times over.
*/
setView(view: ViewSpec): void;
setFov(fov: { vertical: number }): void;
/**
@@ -236,13 +243,6 @@ export interface CameraPort {
lookAt(target: Ecef, offset: HeadingPitchRange): void;
/** Leave `lookAt` for the world frame. */
release(): void;
move(
direction: 'forward' | 'back' | 'left' | 'right' | 'up' | 'down',
metres: number,
): void;
look(direction: 'left' | 'right' | 'up' | 'down', radians: number): void;
rotateAround(axis: Vec3, radians: number): void;
zoom(metres: number): void;
/**
* Follow `target`, or stop following with null; `followChanged` fires
* whenever `followed` changes, and only then.
+1 -1
View File
@@ -183,7 +183,7 @@ test('members added to version 0 later are optional, each behind its capability'
Object.fromEntries(
members(checker.getTypeAtLocation(declared(shape).name)),
)[field];
assert.equal(optional('LineItem', 'depthFailDash'), true);
assert.equal(optional('LineItem', 'depthFail'), true);
// And on one kind of a union: the rectangle's rotation.
const rectangle = checker
.getTypeAtLocation(declared('ShapeGeometry').name)
+18 -27
View File
@@ -212,15 +212,11 @@ export interface LineItem {
mode: '3d' | 'geodesic' | 'draped';
clampTo?: ClampTarget;
style: LineStyle;
/** Colour where the line is behind the surface; `null` hides those parts. */
depthFailColor?: Color | null;
/**
* Dash the parts behind the surface, in `depthFailColor`, as a `dash`
* style's `length` and `pattern16` dash a line. Omitted, they are solid; a
* renderer that predates it draws them solid too. Ignored without a
* `depthFailColor`, and on draped lines, which are never behind it.
* How the parts behind the surface draw, solid or dashed; omitted or
* `null` hides them. Ignored on draped lines, which are never behind it.
*/
depthFailDash?: { length: number; pattern16?: number };
depthFail?: Extract<LineStyle, { kind: 'solid' | 'dash' }> | null;
/** Per-segment colours; changing them does not rebuild the line. */
segmentColors?: Color[];
segmentShow?: boolean[];
@@ -233,25 +229,23 @@ export interface LineItem {
pickable?: boolean;
}
/** A shape's fill. */
export type Fill =
| Color
| { image: ImageRef; repeat?: [number, number] }
| { preset: 'radialRim'; color: Color; rimColor: Color; rimWidth: number };
/**
* A shape's fill: a colour, or an image stretched over the shape's extent
* (`repeat` times across and up). A canvas image sent again with a new
* `key` is new content.
*/
export type Fill = Color | { image: ImageRef; repeat?: [number, number] };
/** Declarative animation the renderer runs (no per-frame callbacks). */
/**
* Declarative animation the renderer runs (no per-frame callbacks): the
* fill's and outline's alpha swings between `from` and `to` and back every
* `periodMs`, forever.
*/
export interface Pulse {
property: 'radius' | 'alpha';
property: 'alpha';
from: number;
to: number;
periodMs: number;
/** Repeat count; omitted repeats forever. */
repeat?: number;
}
/** A radius that follows the camera's height above the ground. */
export interface RadiusByCameraHeight {
byCameraHeight: { factor: number; min: number; max: number };
}
export type ShapeGeometry =
@@ -259,12 +253,11 @@ export type ShapeGeometry =
| {
kind: 'ellipse';
center: Position;
semiMajor: number | RadiusByCameraHeight;
semiMinor: number | RadiusByCameraHeight;
/** Metres. */
semiMajor: number;
semiMinor: number;
/** Radians counter-clockwise from north to the semi-major axis. */
rotation?: number;
/** Only part of the ellipse, radians from north. */
arc?: { start: number; end: number };
}
/**
* `height`: metres above the ellipsoid, for a rectangle not clamped.
@@ -292,8 +285,6 @@ export interface ShapeItem {
extrudeHeight?: number;
height?: 'absolute' | 'clampGround';
clampTo?: ClampTarget;
/** Pull toward the eye, metres, to win depth against coplanar surfaces. */
depthBias?: number;
/**
* Shaded by the renderer's fixed light (true) or flat colour (false).
* Omitted: lit for extruded shapes, flat otherwise. A renderer
+2 -2
View File
@@ -46,8 +46,8 @@ export interface StyleDefinition extends StyleDescriptor {
* full inside the band, each by where its anchor is on screen; the map,
* lines and shapes draw as they are, and picks are unchanged. A radius of 0
* dims every marker to `floor` (the theme on, the sweep off). Setting a
* sector, or clearing it, asks for one frame; the app sets it again at
* `sonarCadenceHz`.
* sector, or clearing it, asks for one frame; the application moves it about every
* 80 ms while it sweeps.
* `diagnostics().passes` lists `'screenModulation'` while it draws, so a
* sector set but not listed is unsupported.
*/
-5
View File
@@ -74,7 +74,6 @@ export const QUALITY_KEYS = Object.freeze([
'particles',
'models',
'postFx',
'sonarCadenceHz',
'targetFps',
]);
@@ -174,10 +173,6 @@ export const PORTS = deepFreeze({
'flying',
'lookAt',
'release',
'move',
'look',
'rotateAround',
'zoom',
'follow',
'followed',
'followFramed',
-2
View File
@@ -26,8 +26,6 @@ export interface QualitySettings {
models: { maxInstances: number; maxDistance: number };
/** Detail of the post-processing passes; bloom and sharpen are switched in `effects`. */
postFx: 'low' | 'high';
/** Updates per second of a screen modulation sweep. */
sonarCadenceHz: number;
targetFps: number;
}
-46
View File
@@ -607,48 +607,6 @@ export function createStubCamera({
finishFlight('cancelled');
}
function move(dir, metres) {
const axis = {
forward: direction,
back: negate(direction),
right,
left: negate(right),
up,
down: negate(up),
}[dir];
position = add(position, scale(axis, metres));
requestRender('camera');
}
function look(dir, radians) {
const [axis, sign] = {
left: [up, -1],
right: [up, 1],
up: [right, -1],
down: [right, 1],
}[dir];
const a = clone(axis);
const angle = -(sign * radians);
direction = rotate(direction, a, angle);
up = rotate(up, a, angle);
right = rotate(right, a, angle);
requestRender('camera');
}
function rotateAround(axis, radians) {
const a = normalize(axis);
position = rotate(position, a, -radians);
direction = rotate(direction, a, -radians);
up = rotate(up, a, -radians);
right = cross(direction, up);
up = cross(right, direction);
requestRender('camera');
}
function zoom(metres) {
move('forward', metres);
}
// --- Follow ----------------------------------------------------------------
/** Where the target is drawn, for a drawn item; otherwise its own answer. */
@@ -797,10 +755,6 @@ export function createStubCamera({
},
lookAt,
release,
move,
look,
rotateAround,
zoom,
follow,
get followed() {
return followed;
+3 -19
View File
@@ -707,23 +707,11 @@ export function createStubRenderer(options = {}) {
);
}
/** The eye's height above the ellipsoid, for radii by camera height. */
const eyeHeight = () => toCartographicRadians(eye().position)?.height ?? 0;
/**
* Whether `lon`, `lat` (degrees) is in an ellipse geometry, its radii by
* camera height at the eye's height, measured in the plane tangent at its
* centre.
* Whether `lon`, `lat` (degrees) is in an ellipse geometry, measured in
* the plane tangent at its centre.
*/
function inEllipse(g, lon, lat) {
const height = eyeHeight();
const radius = (r) =>
typeof r === 'number'
? r
: Math.max(
r.byCameraHeight.min,
Math.min(r.byCameraHeight.max, height * r.byCameraHeight.factor),
);
const centre = toCartographicRadians(toEcef(g.center));
const metresPerRadian = 6378137;
const east =
@@ -735,11 +723,7 @@ export function createStubRenderer(options = {}) {
const turn = g.rotation ?? 0;
const along = north * Math.cos(turn) - east * Math.sin(turn);
const across = north * Math.sin(turn) + east * Math.cos(turn);
return (
(along / radius(g.semiMajor)) ** 2 +
(across / radius(g.semiMinor)) ** 2 <=
1
);
return (along / g.semiMajor) ** 2 + (across / g.semiMinor) ** 2 <= 1;
}
/**
+22
View File
@@ -107,8 +107,16 @@ export function bindFakeCesiumCamera(viewer, ports = {}) {
return fly.apply(this, args);
};
const keepsFlight = '_currentFlight' in fake;
// The port places a view by direction and up on the camera's own vectors;
// a fake without them gets scratch ones, and the view is handed to its
// `setView` as Cesium's setView would have had it.
const placesOnSetView = !('position' in fake) && Boolean(fake.setView);
const placed = placesOnSetView
? { position: {}, direction: {}, up: {}, right: {} }
: null;
const camera = new Proxy(fake, {
get(target, key, receiver) {
if (placed && Object.hasOwn(placed, key)) return placed[key];
if ((key === 'moveStart' || key === 'moveEnd') && !target[key])
return noEvent;
if (!keepsFlight) {
@@ -175,6 +183,20 @@ export function bindFakeCesiumCamera(viewer, ports = {}) {
};
},
},
setView: {
value(spec) {
real.setView(spec);
const o = spec?.orientation;
if (placed && spec?.destination && o && 'direction' in o)
fake.setView({
destination: { ...placed.position },
orientation: {
direction: { ...placed.direction },
up: { ...placed.up },
},
});
},
},
// A fake that computes a view rectangle answers with it, as the
// renderer does; one that does not has none.
viewRectangle: {
+12 -9
View File
@@ -76,17 +76,20 @@ export function nativeIntegrationFixture(t) {
positionCartographic: { height: state.height },
moveEnd: { addEventListener() {} },
cancelFlight() {},
zoomIn(metres) {
position.x -= metres;
// Looking straight down at the surface along -x.
directionWC: { x: -1, y: 0, z: 0 },
upWC: { x: 0, y: 0, z: 1 },
rightWC: { x: 0, y: 1, z: 0 },
setView({ destination }) {
const metres = position.x - destination.x;
position.x = destination.x;
state.height -= metres;
this.positionCartographic.height = state.height;
state.zooms.push({ direction: 'in', metres });
},
zoomOut(metres) {
position.x += metres;
state.height += metres;
this.positionCartographic.height = state.height;
state.zooms.push({ direction: 'out', metres });
state.zooms.push(
metres < 0
? { direction: 'out', metres: -metres }
: { direction: 'in', metres },
);
},
},
scene: {
+7 -8
View File
@@ -55,14 +55,13 @@ function fixture({ holdFirst = false } = {}) {
positionCartographic: { height: 1000 },
moveEnd: { addEventListener() {} },
cancelFlight() {},
zoomIn(n) {
position.x -= n;
state.height -= n;
this.positionCartographic.height = state.height;
},
zoomOut(n) {
position.x += n;
state.height += n;
// Looking straight down at the surface along -x.
directionWC: { x: -1, y: 0, z: 0 },
upWC: { x: 0, y: 0, z: 1 },
rightWC: { x: 0, y: 1, z: 0 },
setView({ destination }) {
state.height -= position.x - destination.x;
position.x = destination.x;
this.positionCartographic.height = state.height;
},
},
+3 -2
View File
@@ -21,6 +21,7 @@ import {
toRadians,
} from '../geo/index.js';
import { sphereFromPoints } from '../geo/sphere.js';
import { eyeZoomed } from '../geo/eyeMoves.js';
import {
cameraOf,
findCamera,
@@ -3429,7 +3430,7 @@ function adjustCameraZoom(viewer, args) {
camera.cancelFlight();
if (direction === 'out') {
camera.zoom(-movementM);
camera.setView(eyeZoomed(before, -movementM));
} else {
const safeMovementM = Math.min(
movementM,
@@ -3444,7 +3445,7 @@ function adjustCameraZoom(viewer, args) {
error: 'Camera is already at the minimum target distance',
};
}
camera.zoom(safeMovementM);
camera.setView(eyeZoomed(before, safeMovementM));
}
const after = camera.pose();
+7 -9
View File
@@ -184,15 +184,13 @@ function compositionFixture(
positionCartographic: { height: state.height },
moveEnd: { addEventListener() {} },
cancelFlight() {},
zoomIn(metres) {
position.x -= metres;
state.height -= metres;
this.positionCartographic.height = state.height;
state.zooms++;
},
zoomOut(metres) {
position.x += metres;
state.height += metres;
// Looking straight down at the surface along -x.
directionWC: { x: -1, y: 0, z: 0 },
upWC: { x: 0, y: 0, z: 1 },
rightWC: { x: 0, y: 1, z: 0 },
setView({ destination }) {
state.height -= position.x - destination.x;
position.x = destination.x;
this.positionCartographic.height = state.height;
state.zooms++;
},