mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
The Street Level view maths no longer reads Cesium. The camera's place comes from the camera port's pose; the visible box and the view focus cast the query port's screen rays and meet them with the ground, the WGS84 ellipsoid raised to the ground height, in geo; heights come from the query port; the horizon cull for the marker and the cones tests against an ellipsoid 1,000 m below WGS84 in geo and re-culls on the frame port's pre-render. Ground clicks, the screen-centre aim, the nearest-image point, photo framing, the coverage refresh and the ground re-measure read the same ports and convert positions with geo. geo's ellipsoid functions (toLonLatH, rayEllipsoid and those under them) and horizonFrom take an optional ellipsoid, made with ellipsoidOf or offsetEllipsoid; anything else, a map index included, means WGS84. Tests check them against Cesium on raised and lowered ellipsoids. view, index, cameraFraming, groundClick and selection leave the Cesium allow-list. The Street Level entries are Cesium-free callers of the unbound factories: given a viewer of a caller's own, with no renderer bound, the caller loads ./render/cesium/unbound first. GhostMaps, which uses the horizon cull and is still on the list, loads the camera factory itself. Differences the contract does not let us avoid: - The ground under the camera no longer reads whether the globe is shown (the globe port has no visibility getter). Where 3D tiles answer under the camera they decide, as they did under Google 3D; elsewhere the terrain answers, then the drawn surface below the camera. Over 3D tiles shown on a map with the globe (and under other primitives at the nadir) those now count as ground. - Without depth-texture support the query port answers no heights, the terrain included, so the ground then reads as the ellipsoid. - selection and groundClick still read the click dispatcher's own pick for now; they move to draw-set hits with the coverage lines.
141 lines
4.4 KiB
JavaScript
141 lines
4.4 KiB
JavaScript
import assert from 'node:assert/strict';
|
||
import test from 'node:test';
|
||
import * as Cesium from 'cesium';
|
||
import { createGroundClick, groundClickHeightOk } from './groundClick.js';
|
||
import * as scenePick from '../../data/scenePick.js';
|
||
import { bindFakeCesiumCamera } from '../../testSupport/fakeCameraPort.mjs';
|
||
import { streetPorts } from '../../testSupport/streetLevelFakes.mjs';
|
||
|
||
const GROUND = Cesium.Cartesian3.fromDegrees(-121.4944, 38.5816, 10);
|
||
const TILESET = { isCesium3DTileset: true };
|
||
|
||
/** A viewer double bound to the camera and query ports, as the app binds its renderer. */
|
||
const viewerWith = (viewer) =>
|
||
bindFakeCesiumCamera(viewer, streetPorts(viewer));
|
||
|
||
/**
|
||
* A layer state with providers `{id, on, groundClick, configured, available}`;
|
||
* `picked` is where the depth buffer lands, `ellipsoid` the fallback hit.
|
||
*/
|
||
function harness({
|
||
providers = [
|
||
{ id: 'mapillary', groundClick: false },
|
||
{ id: 'google', groundClick: true },
|
||
],
|
||
height = 400,
|
||
enabled = true,
|
||
picked = GROUND,
|
||
ellipsoid = undefined,
|
||
} = {}) {
|
||
const opened = [];
|
||
const state = {
|
||
enabled,
|
||
services: { scenePick },
|
||
providers: new Map(
|
||
providers.map(
|
||
({
|
||
id,
|
||
on = true,
|
||
groundClick,
|
||
configured = true,
|
||
available = true,
|
||
}) => [
|
||
id,
|
||
{ on, def: { id, groundClick }, status: { configured }, available },
|
||
],
|
||
),
|
||
),
|
||
viewer: viewerWith({
|
||
scene: { pickPositionSupported: true, pickPosition: () => picked },
|
||
camera: {
|
||
pickEllipsoid: () => ellipsoid,
|
||
positionCartographic: Cesium.Cartographic.fromDegrees(
|
||
-121.4944,
|
||
38.5816,
|
||
height,
|
||
),
|
||
},
|
||
}),
|
||
};
|
||
const openAtGround = createGroundClick({
|
||
state,
|
||
openNearest: (point, options) => {
|
||
opened.push({ point, options });
|
||
return Promise.resolve(true);
|
||
},
|
||
isAvailable: (entry) => entry.available,
|
||
});
|
||
return { opened, openAtGround };
|
||
}
|
||
|
||
const near = (point) =>
|
||
Math.abs(point.lon - -121.4944) < 1e-9 &&
|
||
Math.abs(point.lat - 38.5816) < 1e-9;
|
||
|
||
test('a click on the map opens the click-to-open providers there, without moving the camera', () => {
|
||
for (const picked of [undefined, { primitive: TILESET }, { content: {} }]) {
|
||
const { opened, openAtGround } = harness();
|
||
openAtGround({ x: 10, y: 20 }, picked);
|
||
assert.equal(opened.length, 1, JSON.stringify(picked));
|
||
assert.ok(near(opened[0].point));
|
||
assert.deepEqual(opened[0].options, {
|
||
providerIds: ['google'],
|
||
frame: false,
|
||
});
|
||
}
|
||
});
|
||
|
||
test('where the depth buffer names no place, the ellipsoid answers', () => {
|
||
const { opened, openAtGround } = harness({
|
||
picked: new Cesium.Cartesian3(500, 0, 0),
|
||
ellipsoid: GROUND,
|
||
});
|
||
openAtGround({ x: 1, y: 1 });
|
||
assert.ok(near(opened[0].point));
|
||
});
|
||
|
||
test('nothing opens over another layer’s object, the sky, from high up, off its map stack, or with the provider off', () => {
|
||
const cases = [
|
||
{ picked: { id: { id: 'flight:1' } }, label: 'an entity' },
|
||
{ picked: { id: 'cctv:7', primitive: TILESET }, label: 'an id on a tile' },
|
||
{ options: { picked: null, ellipsoid: undefined }, label: 'the sky' },
|
||
{ options: { height: 5000 }, label: 'high up' },
|
||
{
|
||
options: {
|
||
providers: [{ id: 'google', groundClick: true, available: false }],
|
||
},
|
||
label: 'not Google 3D',
|
||
},
|
||
{
|
||
options: { providers: [{ id: 'google', groundClick: true, on: false }] },
|
||
label: 'off',
|
||
},
|
||
{
|
||
options: {
|
||
providers: [{ id: 'google', groundClick: true, configured: false }],
|
||
},
|
||
label: 'no key',
|
||
},
|
||
{ options: { enabled: false }, label: 'layer off' },
|
||
];
|
||
for (const { picked, options = {}, label } of cases) {
|
||
const { opened, openAtGround } = harness(options);
|
||
assert.equal(openAtGround({ x: 1, y: 1 }, picked), false, label);
|
||
assert.equal(opened.length, 0, label);
|
||
}
|
||
});
|
||
|
||
test('street zoom is measured above the ground under the camera', () => {
|
||
const viewer = (height) =>
|
||
viewerWith({
|
||
camera: {
|
||
positionCartographic: Cesium.Cartographic.fromDegrees(0, 0, height),
|
||
},
|
||
scene: { globe: { getHeight: () => 1500 } },
|
||
});
|
||
// 1,500 m up a plateau, 2,000 m above it: still a street.
|
||
assert.equal(groundClickHeightOk(viewer(3500)), true);
|
||
assert.equal(groundClickHeightOk(viewer(5000)), false);
|
||
assert.equal(groundClickHeightOk(null), false);
|
||
});
|