mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-18 01:02:23 +00:00
Geo import asks the frame port for renders, the camera port for moveEnd and the globe port's progress for the terrain queue running dry; its data sources are added, removed and shown by the listed geoImportPins module. Voice capture waits on the frame port's postRender. Visual settings toggle the infrared fog through the globe sky port, and the anime style dims the Milky Way through a sky getter it is given. The scope mask reads the camera height and listens on the frame and camera ports. Recent imagery picks the view centre, reads the view rectangle and the field of view through the query and camera ports. Installations claim camera sensitivity from their rendering module. The application shell loads the unbound globe factory.
360 lines
9.4 KiB
JavaScript
360 lines
9.4 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import { bindRenderer } from '../render/rendererOf.js';
|
|
import { fakeSceneFrame } from '../testSupport/fakeCesiumScene.mjs';
|
|
import test from 'node:test';
|
|
import {
|
|
RealtimeViewport,
|
|
pointerCropRect,
|
|
renderFreshPointerFrame,
|
|
} from './realtimeViewport.js';
|
|
|
|
|
|
/** A viewer over `scene` whose renderer's frame port is the scene's own loop. */
|
|
function framed(scene) {
|
|
const viewer = { scene };
|
|
bindRenderer(viewer, { frame: fakeSceneFrame(viewer) });
|
|
return viewer;
|
|
}
|
|
|
|
test('crop: a square around the pointer, clamped inside the canvas, in buffer pixels', () => {
|
|
assert.deepEqual(
|
|
pointerCropRect({
|
|
x: 750,
|
|
y: 475,
|
|
cssWidth: 1500,
|
|
cssHeight: 950,
|
|
pixelWidth: 3000,
|
|
pixelHeight: 1900,
|
|
}),
|
|
{
|
|
sx: 988,
|
|
sy: 438,
|
|
sw: 1024,
|
|
sh: 1024,
|
|
output: 512,
|
|
pointX: 256,
|
|
pointY: 256,
|
|
},
|
|
);
|
|
const corner = pointerCropRect({
|
|
x: 20,
|
|
y: 20,
|
|
cssWidth: 1500,
|
|
cssHeight: 950,
|
|
pixelWidth: 1500,
|
|
pixelHeight: 950,
|
|
});
|
|
assert.equal(corner.sx, 0);
|
|
assert.equal(corner.sy, 0);
|
|
assert.equal(
|
|
corner.pointX,
|
|
20,
|
|
'the ring still marks the real spot near an edge',
|
|
);
|
|
assert.equal(
|
|
pointerCropRect({
|
|
x: 1,
|
|
y: 1,
|
|
cssWidth: 0,
|
|
cssHeight: 0,
|
|
pixelWidth: 0,
|
|
pixelHeight: 0,
|
|
}),
|
|
null,
|
|
);
|
|
assert.equal(
|
|
pointerCropRect({
|
|
x: Number.NaN,
|
|
y: 1,
|
|
cssWidth: 100,
|
|
cssHeight: 100,
|
|
pixelWidth: 100,
|
|
pixelHeight: 100,
|
|
}),
|
|
null,
|
|
'non-finite pointer geometry fails closed',
|
|
);
|
|
assert.equal(
|
|
pointerCropRect({
|
|
x: 101,
|
|
y: 1,
|
|
cssWidth: 100,
|
|
cssHeight: 100,
|
|
pixelWidth: 100,
|
|
pixelHeight: 100,
|
|
}),
|
|
null,
|
|
'out-of-canvas pointer geometry fails closed',
|
|
);
|
|
assert.equal(
|
|
pointerCropRect({
|
|
x: 120,
|
|
y: 100,
|
|
cssWidth: 320,
|
|
cssHeight: 240,
|
|
pixelWidth: 320,
|
|
pixelHeight: 240,
|
|
}).output,
|
|
512,
|
|
'the provider image stays 512 px even when the source crop is smaller',
|
|
);
|
|
});
|
|
|
|
test('crop: a slow render gets one bounded fresh-frame recovery request', async () => {
|
|
const originalDocument = globalThis.document;
|
|
let requests = 0;
|
|
let listener = null;
|
|
try {
|
|
globalThis.document = { hidden: false };
|
|
const scene = {
|
|
postRender: {
|
|
addEventListener(next) {
|
|
listener = next;
|
|
return () => {
|
|
if (listener === next) listener = null;
|
|
};
|
|
},
|
|
},
|
|
requestRender() {
|
|
requests += 1;
|
|
if (requests === 2) queueMicrotask(() => listener?.());
|
|
},
|
|
};
|
|
assert.equal(await renderFreshPointerFrame(framed(scene)), true);
|
|
assert.equal(requests, 2, 'only the pointer path retries once');
|
|
assert.equal(listener, null, 'the successful listener is removed');
|
|
} finally {
|
|
globalThis.document = originalDocument;
|
|
}
|
|
});
|
|
|
|
test('crop: a hidden document never starts the recovery request', async () => {
|
|
const originalDocument = globalThis.document;
|
|
let requests = 0;
|
|
try {
|
|
globalThis.document = { hidden: true };
|
|
const scene = {
|
|
postRender: { addEventListener: () => () => {} },
|
|
requestRender() {
|
|
requests += 1;
|
|
},
|
|
};
|
|
assert.equal(await renderFreshPointerFrame(framed(scene)), false);
|
|
assert.equal(requests, 0);
|
|
} finally {
|
|
globalThis.document = originalDocument;
|
|
}
|
|
});
|
|
|
|
function viewportFixture({ capturePointer, capture } = {}) {
|
|
const sent = [];
|
|
const captures = [];
|
|
const state = { clock: 10_000, pointer: null, camera: 'pose-A' };
|
|
const channel = { readyState: 'open' };
|
|
const viewport = new RealtimeViewport({
|
|
readChannel: () => channel,
|
|
readPointer: () => state.pointer,
|
|
readCameraKey: () => state.camera,
|
|
capture: capture || (async () => 'data:image/jpeg;base64,FULL'),
|
|
capturePointer:
|
|
capturePointer ||
|
|
(async (px) => {
|
|
captures.push(px);
|
|
return {
|
|
dataUrl: 'data:image/jpeg;base64,CROP',
|
|
rect: { x: 0.25, y: 0.2, w: 0.3, h: 0.5 },
|
|
};
|
|
}),
|
|
now: () => state.clock,
|
|
operations: {
|
|
sendRealtimeEvent: (event, label) => {
|
|
sent.push({ event, label });
|
|
return true;
|
|
},
|
|
},
|
|
});
|
|
return { viewport, sent, captures, state };
|
|
}
|
|
|
|
const ground = {
|
|
fresh: true,
|
|
target: 'ground',
|
|
at: 'keydown',
|
|
screenPx: { x: 400, y: 300 },
|
|
capturedAt: 9_000,
|
|
cameraKey: 'pose-A',
|
|
};
|
|
|
|
test('crop: sent once per snapshot, only at local/city scale, into the one retained slot', async () => {
|
|
const { viewport, sent, captures, state } = viewportFixture();
|
|
assert.equal(
|
|
await viewport.sendPointerCrop(ground, { viewScale: 'regional' }),
|
|
false,
|
|
'the scale guard lives in the shared send path',
|
|
);
|
|
assert.equal(
|
|
await viewport.sendPointerCrop(ground),
|
|
false,
|
|
'no scale, no crop',
|
|
);
|
|
assert.equal(
|
|
await viewport.sendPointerCrop(ground, { viewScale: 'city' }),
|
|
true,
|
|
);
|
|
assert.equal(
|
|
await viewport.sendPointerCrop(ground, { viewScale: 'city' }),
|
|
false,
|
|
'once per snapshot',
|
|
);
|
|
assert.deepEqual(captures, [{ x: 400, y: 300 }]);
|
|
assert.equal(sent[0].label, 'client.pointer_crop');
|
|
assert.match(sent[0].event.item.content[0].text, /ring marks the exact spot/);
|
|
assert.equal(
|
|
sent[0].event.item.content[1].image_url,
|
|
'data:image/jpeg;base64,CROP',
|
|
);
|
|
assert.deepEqual(viewport.retainedFrame, {
|
|
kind: 'crop',
|
|
rect: { x: 0.25, y: 0.2, w: 0.3, h: 0.5 },
|
|
cameraKey: 'pose-A',
|
|
});
|
|
assert.equal(
|
|
await viewport.sendPointerCrop(
|
|
{ ...ground, target: 'entity' },
|
|
{ viewScale: 'city' },
|
|
),
|
|
false,
|
|
'entities are named, not cropped',
|
|
);
|
|
state.clock = 60_000;
|
|
assert.equal(
|
|
await viewport.sendPointerCrop({ ...ground }, { viewScale: 'city' }),
|
|
false,
|
|
'too old',
|
|
);
|
|
|
|
// Pull: a ground pointer lookup sends the crop, deleting the old image.
|
|
state.clock = 10_000;
|
|
state.pointer = { ...ground, at: 'speech_start' };
|
|
const lookup = {
|
|
action: 'get_entity_context',
|
|
scope: 'pointer',
|
|
selected: null,
|
|
pointer: { latitude: 1, longitude: 2 },
|
|
scene: { basemap: { viewScale: 'city' } },
|
|
};
|
|
assert.equal(await viewport.sendVisualContextIfUseful(lookup), true);
|
|
assert.equal(
|
|
sent.at(-2).event.type,
|
|
'conversation.item.delete',
|
|
'one retained image at most',
|
|
);
|
|
assert.equal(sent.at(-1).label, 'client.pointer_crop');
|
|
assert.equal(
|
|
await viewport.sendVisualContextIfUseful({
|
|
...lookup,
|
|
selected: { id: 'x' },
|
|
}),
|
|
false,
|
|
);
|
|
assert.equal(
|
|
await viewport.sendVisualContextIfUseful({
|
|
...lookup,
|
|
scene: { basemap: { viewScale: 'regional' } },
|
|
}),
|
|
false,
|
|
);
|
|
viewport.reset();
|
|
assert.equal(viewport.lastPointerCrop, null);
|
|
assert.equal(viewport.retainedFrame, null);
|
|
});
|
|
|
|
test('crop: a camera move before or during capture drops it; pixels only name their own pose', async () => {
|
|
let release;
|
|
const { viewport, sent, state } = viewportFixture({
|
|
capturePointer: () =>
|
|
new Promise((resolve) => {
|
|
release = () =>
|
|
resolve({
|
|
dataUrl: 'data:image/jpeg;base64,CROP',
|
|
rect: { x: 0, y: 0, w: 1, h: 1 },
|
|
});
|
|
}),
|
|
});
|
|
state.camera = 'pose-B';
|
|
assert.equal(
|
|
await viewport.sendPointerCrop(ground, { viewScale: 'local' }),
|
|
false,
|
|
'moved before capture',
|
|
);
|
|
state.camera = null;
|
|
assert.equal(
|
|
await viewport.sendPointerCrop(
|
|
{ ...ground, cameraKey: null },
|
|
{ viewScale: 'local' },
|
|
),
|
|
false,
|
|
'a missing pose identity fails closed',
|
|
);
|
|
state.camera = 'pose-A';
|
|
const pending = viewport.sendPointerCrop(
|
|
{ ...ground },
|
|
{ viewScale: 'local' },
|
|
);
|
|
state.camera = 'pose-B';
|
|
release();
|
|
assert.equal(await pending, false, 'moved while capturing');
|
|
assert.equal(sent.length, 0);
|
|
});
|
|
|
|
test('crop: a snapshot that expires during capture is not published', async () => {
|
|
let release;
|
|
const { viewport, sent, state } = viewportFixture({
|
|
capturePointer: () =>
|
|
new Promise((resolve) => {
|
|
release = () =>
|
|
resolve({
|
|
dataUrl: 'data:image/jpeg;base64,CROP',
|
|
rect: { x: 0, y: 0, w: 1, h: 1 },
|
|
});
|
|
}),
|
|
});
|
|
const pending = viewport.sendPointerCrop(
|
|
{ ...ground },
|
|
{ viewScale: 'local' },
|
|
);
|
|
state.clock = 40_000;
|
|
release();
|
|
assert.equal(await pending, false);
|
|
assert.equal(sent.length, 0);
|
|
});
|
|
|
|
test('crop: an older capture that finishes last never replaces the newer image', async () => {
|
|
const releases = [];
|
|
const { viewport, sent } = viewportFixture({
|
|
capturePointer: () =>
|
|
new Promise((resolve) =>
|
|
releases.push((url) => resolve({ dataUrl: url, rect: null })),
|
|
),
|
|
});
|
|
const first = viewport.sendPointerCrop({ ...ground }, { viewScale: 'local' });
|
|
const second = viewport.sendPointerCrop(
|
|
{ ...ground },
|
|
{ viewScale: 'local' },
|
|
);
|
|
releases[1]('data:image/jpeg;base64,NEW');
|
|
assert.equal(await second, true);
|
|
releases[0]('data:image/jpeg;base64,OLD');
|
|
assert.equal(await first, false, 'superseded request');
|
|
assert.deepEqual(
|
|
sent.map((s) => s.event.item?.content?.[1]?.image_url).filter(Boolean),
|
|
['data:image/jpeg;base64,NEW'],
|
|
);
|
|
|
|
// A new user turn drops a capture still in flight from the previous one.
|
|
const third = viewport.sendPointerCrop({ ...ground }, { viewScale: 'local' });
|
|
viewport.beginTurn();
|
|
releases[2]('data:image/jpeg;base64,LATE');
|
|
assert.equal(await third, false);
|
|
});
|