mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-21 18:52:18 +00:00
Never hide a mover behind the terrain it sits on
Cesium does not test points, billboards or labels against terrain depth; only the horizon, 3D tiles and models hide them. Navara compared every fragment of a marker's quad with the terrain, so markers on slopes or a little below the rendered terrain disappeared (the flood markers in the Nepal story). Navara now follows Cesium's rule for movers with the normal depth test, the contract describes it, and the contract suite checks it.
This commit is contained in:
1 parent
6c77b1ed41
commit
14b2adb7af
11 files changed
+655
-23
No files matched your search
@@ -4,6 +4,9 @@ import * as geo from '../../geo/index.js';
|
||||
import { assertGlobeEngine, engineCapabilities } from '../contract.js';
|
||||
import { cesiumFovy, orientationVectors } from '../cameraMath.js';
|
||||
import { createNavaraEngine } from './createNavaraEngine.js';
|
||||
import { createMoverRegistry } from '../movers.js';
|
||||
import { createMoverMesh } from './movers/moverMesh.js';
|
||||
import { createContractSuite } from '../testing/contractSuite.mjs';
|
||||
|
||||
const { cartesian2, cartesian3, math } = geo;
|
||||
|
||||
@@ -155,6 +158,41 @@ const setup = () => {
|
||||
return { view, engine };
|
||||
};
|
||||
|
||||
test('the contract suite mover checks pass on Navara without pixels', async (t) => {
|
||||
const view = fakeView();
|
||||
view.sampleTerrainHeight = () => 12;
|
||||
const registry = createMoverRegistry((options, store) => {
|
||||
const mover = createMoverMesh(options, store);
|
||||
return {
|
||||
ready: mover.ready,
|
||||
failed: mover.failed,
|
||||
commit: () => mover.commit(store.dirty()),
|
||||
destroy: () => mover.dispose(),
|
||||
};
|
||||
});
|
||||
const engine = createNavaraEngine(view, {
|
||||
...ports,
|
||||
hooks,
|
||||
movers: { movers: registry.movers, destroy: registry.destroyAll },
|
||||
});
|
||||
const checks = createContractSuite(engine, {
|
||||
waitFrames: async (count) => {
|
||||
for (let i = 0; i < count; i++) {
|
||||
view.emit('preUpdate', i);
|
||||
view.emit('preRender', i);
|
||||
view.emit('postRender', i);
|
||||
}
|
||||
},
|
||||
}).filter(({ name }) => name.startsWith('movers'));
|
||||
assert.equal(checks.length, 5);
|
||||
try {
|
||||
for (const { name, run } of checks) await t.test(name, run);
|
||||
} finally {
|
||||
engine.destroy();
|
||||
}
|
||||
assert.equal(registry.movers.list().length, 0);
|
||||
});
|
||||
|
||||
test('the engine has every contract capability and reports kind navara', () => {
|
||||
const { engine, view } = setup();
|
||||
assertGlobeEngine(engine);
|
||||
|
||||
@@ -0,0 +1,193 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
import { registerHooks } from 'node:module';
|
||||
import { PerspectiveCamera, ShaderLib } from 'three';
|
||||
import { cartesian3 } from '../../../geo/index.js';
|
||||
import { createMoverStore, normalizeMoverSetOptions } from '../../movers.js';
|
||||
import { createMoverMesh, patchMoverShader } from './moverMesh.js';
|
||||
|
||||
// Execute the scalar decisions from the material's actual shader patch.
|
||||
function decision(name) {
|
||||
const shader = patchMoverShader(
|
||||
{
|
||||
uniforms: {},
|
||||
vertexShader: ShaderLib.basic.vertexShader,
|
||||
fragmentShader: ShaderLib.basic.fragmentShader,
|
||||
},
|
||||
{},
|
||||
);
|
||||
const functions = ['packedDepthOccluded', name].map((key) => {
|
||||
const body = shader.fragmentShader.match(
|
||||
new RegExp(`bool ${key}\\([^}]+}`),
|
||||
);
|
||||
assert.ok(body, `${key} is in the compiled mover shader`);
|
||||
return body[0]
|
||||
.replace(`bool ${key}`, `function ${key}`)
|
||||
.replaceAll(/float (\w+)/g, '$1');
|
||||
});
|
||||
return new Function(`${functions.join('\n')}\nreturn ${name};`)();
|
||||
}
|
||||
|
||||
for (const [name, mine, scene, globe, hidden] of [
|
||||
['on terrain', 0.4, 0.4, 0.4, false],
|
||||
['below terrain', 0.7, 0.4, 0.4, false],
|
||||
['terrain copy rounding', 0.7, 0.4 - 6e-8, 0.4, false],
|
||||
['tile in front of terrain', 0.7, 0.3, 0.4, true],
|
||||
['tile with globe hidden', 0.7, 0.3, 1, true],
|
||||
['model in front of terrain', 0.7, 0.2, 0.4, true],
|
||||
['point in front of model', 0.1, 0.2, 0.4, false],
|
||||
['no surface', 0.7, 1, 1, false],
|
||||
]) {
|
||||
test(`mover depth: ${name}`, () => {
|
||||
assert.equal(decision('gevMoverSceneHidden')(mine, scene, globe), hidden);
|
||||
});
|
||||
}
|
||||
|
||||
for (const latitude of [0, 45, 90]) {
|
||||
test(`mover horizon at latitude ${latitude} ignores nearby underground points`, () => {
|
||||
const hidden = decision('gevMoverHorizonHidden');
|
||||
const eye = cartesian3.fromDegrees(0, latitude, 10000);
|
||||
const radii = [6378137, 6378137, 6356752.3142451793];
|
||||
const scaledEye = [eye.x, eye.y, eye.z].map((v, i) => v / radii[i]);
|
||||
const dot = (a, b) => a.reduce((sum, v, i) => sum + v * b[i], 0);
|
||||
const visible = (position) => {
|
||||
const ray = [
|
||||
position.x - eye.x,
|
||||
position.y - eye.y,
|
||||
position.z - eye.z,
|
||||
].map((v, i) => v / radii[i]);
|
||||
return !hidden(
|
||||
dot(scaledEye, scaledEye) - 1,
|
||||
-dot(ray, scaledEye),
|
||||
dot(ray, ray),
|
||||
);
|
||||
};
|
||||
assert.equal(visible(cartesian3.fromDegrees(0, latitude, 0)), true);
|
||||
assert.equal(visible(cartesian3.fromDegrees(0, latitude, -1000)), true);
|
||||
assert.equal(visible(cartesian3.fromDegrees(180, -latitude, 0)), false);
|
||||
});
|
||||
}
|
||||
|
||||
test('a high mover outside the Earth silhouette is not clipped by the limb plane', () => {
|
||||
assert.equal(decision('gevMoverHorizonHidden')(0.1, 0.2, 1), false);
|
||||
});
|
||||
|
||||
test('point and sprite shaders share terrain classification and camera-relative horizon inputs', () => {
|
||||
for (const kind of ['point', 'sprite']) {
|
||||
const options = normalizeMoverSetOptions({
|
||||
id: kind,
|
||||
kind,
|
||||
capacity: 1,
|
||||
depthTest: 'normal',
|
||||
point: { sizePx: 24 },
|
||||
sprite: { sizePx: 24, atlas: { canvas: {}, cells: { a: [0, 0, 1, 1] } } },
|
||||
});
|
||||
const mover = createMoverMesh(options, createMoverStore(options));
|
||||
try {
|
||||
mover.update({
|
||||
cameraPosition: { x: 6379137, y: 0, z: 0 },
|
||||
cameraHeight: 1000,
|
||||
fovDeg: 60,
|
||||
viewportHeightPx: 800,
|
||||
});
|
||||
assert.deepEqual(mover.uniforms.uGevScaledCamera?.value, [
|
||||
6379137 / 6378137,
|
||||
0,
|
||||
0,
|
||||
]);
|
||||
const shader = {
|
||||
uniforms: {},
|
||||
vertexShader: ShaderLib.basic.vertexShader,
|
||||
fragmentShader: ShaderLib.basic.fragmentShader,
|
||||
};
|
||||
mover.mesh.material.onBeforeCompile(shader);
|
||||
assert.match(shader.fragmentShader, /#define GEV_MOVER_DEPTH/);
|
||||
assert.match(shader.fragmentShader, /texelFetch\(tGevSceneDepth/);
|
||||
assert.match(shader.fragmentShader, /texelFetch\(tGevGlobeDepth/);
|
||||
assert.match(shader.vertexShader, /mvPosition.xyz \* mat3\(viewMatrix\)/);
|
||||
assert.equal(
|
||||
shader.uniforms.tGevGlobeDepth,
|
||||
mover.uniforms.tGevGlobeDepth,
|
||||
);
|
||||
} finally {
|
||||
mover.dispose();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('mover frames bind the current public globe-depth copy', async () => {
|
||||
// The SDK's descriptor bases are browser-only; the mover and frame callback
|
||||
// remain real, with the public depth/renderer methods supplied below.
|
||||
const stub = `data:text/javascript,${encodeURIComponent(`
|
||||
export class MeshDesc {}
|
||||
export class EffectDesc {}
|
||||
export class Pass {}
|
||||
export class PickableInstancedMeshWrapper {}
|
||||
export function createGltfLoader() { throw new Error('Unexpected model load'); }
|
||||
`)}`;
|
||||
const loader = registerHooks({
|
||||
resolve(specifier, context, next) {
|
||||
return specifier === '@navaramap/three'
|
||||
? { url: stub, shortCircuit: true }
|
||||
: next(specifier, context);
|
||||
},
|
||||
});
|
||||
let createNavaraMovers;
|
||||
try {
|
||||
({ createNavaraMovers } = await import('./index.js'));
|
||||
} finally {
|
||||
loader.deregister();
|
||||
}
|
||||
const camera = new PerspectiveCamera(60, 1.6, 1, 1e8);
|
||||
camera.position.set(6379137, 0, 0);
|
||||
let globeDepth = {};
|
||||
let mesh;
|
||||
let frame;
|
||||
const overlay = {
|
||||
uniforms: {
|
||||
tGevSceneDepth: { value: {} },
|
||||
uGevResolution: { value: [1280, 800] },
|
||||
},
|
||||
ctx: {
|
||||
getGlobeDepthTexture: () => globeDepth,
|
||||
getRenderer: () => ({
|
||||
domElement: { clientHeight: 800 },
|
||||
getPixelRatio: () => 1,
|
||||
}),
|
||||
},
|
||||
add(value, update) {
|
||||
mesh = value;
|
||||
frame = update;
|
||||
},
|
||||
remove() {},
|
||||
};
|
||||
const owner = createNavaraMovers(
|
||||
{
|
||||
camera: { raw: camera },
|
||||
registerMesh() {},
|
||||
forceUpdate() {},
|
||||
},
|
||||
{ overlay },
|
||||
);
|
||||
try {
|
||||
owner.movers.createSet({
|
||||
id: 'depth-copy',
|
||||
kind: 'point',
|
||||
capacity: 1,
|
||||
point: { sizePx: 24 },
|
||||
});
|
||||
const shader = {
|
||||
uniforms: {},
|
||||
vertexShader: ShaderLib.basic.vertexShader,
|
||||
fragmentShader: ShaderLib.basic.fragmentShader,
|
||||
};
|
||||
mesh.material.onBeforeCompile(shader);
|
||||
frame(1);
|
||||
assert.equal(shader.uniforms.tGevGlobeDepth?.value, globeDepth);
|
||||
globeDepth = {};
|
||||
frame(2);
|
||||
assert.equal(shader.uniforms.tGevGlobeDepth.value, globeDepth);
|
||||
} finally {
|
||||
owner.destroy();
|
||||
}
|
||||
});
|
||||
@@ -134,9 +134,11 @@ export function createNavaraMovers(view, { overlay, aces = false }) {
|
||||
targetOverlay.registerPickable(key, wrapper);
|
||||
pickIndex.add(options.id, wrapper, (index) => store.pickIds[index]);
|
||||
}
|
||||
targetOverlay.add(mover.mesh, (time) =>
|
||||
updateMover(readFrameCamera, targetOverlay.ctx, mover, time),
|
||||
);
|
||||
targetOverlay.add(mover.mesh, (time) => {
|
||||
mover.uniforms.tGevGlobeDepth.value =
|
||||
targetOverlay.ctx.getGlobeDepthTexture();
|
||||
updateMover(readFrameCamera, targetOverlay.ctx, mover, time);
|
||||
});
|
||||
return {
|
||||
ready: mover.ready,
|
||||
failed: mover.failed,
|
||||
|
||||
@@ -56,6 +56,7 @@ varying float vGevPixelDistance;
|
||||
varying float vGevTranslucency;
|
||||
varying float vGevSonarFactor;
|
||||
uniform vec2 uGevResolution;
|
||||
varying vec3 vGevScaledRay;
|
||||
${OVERLAY_DEPTH_VERTEX}
|
||||
${SONAR_VERTEX}
|
||||
`;
|
||||
@@ -106,6 +107,9 @@ vec2 gevTurned = vec2(
|
||||
vec4 mvPosition = mvCenter;
|
||||
mvPosition.xy += gevTurned * gevSizePx * uGevFootprint * max(-mvCenter.z, 0.0);
|
||||
gl_Position = projectionMatrix * mvPosition;
|
||||
// Rotate the camera-relative quad into Earth axes before scaling: adding
|
||||
// its Earth-sized origin in float32 would lose precision near the ground.
|
||||
vGevScaledRay = (mvPosition.xyz * mat3(viewMatrix)) / vec3(6378137.0, 6378137.0, 6356752.3142451793);
|
||||
// The Cyber sonar (sonar.js): by the anchor's place on screen, never the
|
||||
// corner's, so a contact is treated whole; the position stays as it is.
|
||||
vGevSonarFactor = gevSonarFactor(projectionMatrix * mvCenter, uGevResolution);
|
||||
@@ -191,7 +195,7 @@ export function patchMoverShader(
|
||||
let fragment = replace(
|
||||
shader.fragmentShader,
|
||||
'void main() {',
|
||||
`${point ? '#define GEV_POINT\n' : ''}${FRAGMENT_HEAD}\nvoid main() {`,
|
||||
`#define GEV_MOVER_DEPTH\n${point ? '#define GEV_POINT\n' : ''}${FRAGMENT_HEAD}\nvoid main() {`,
|
||||
);
|
||||
let colorFragment = fragmentColor(point);
|
||||
if (alwaysVisible)
|
||||
@@ -306,6 +310,9 @@ export function createMoverMesh(
|
||||
},
|
||||
// Shared by every overlay: the scene depth and the target's size.
|
||||
tGevSceneDepth: overlayUniforms.tGevSceneDepth,
|
||||
tGevGlobeDepth: { value: null },
|
||||
uGevScaledCamera: { value: [0, 0, 0] },
|
||||
uGevLimbSquared: { value: -1 },
|
||||
uGevResolution: overlayUniforms.uGevResolution,
|
||||
uGevDisplayBlend:
|
||||
overlayUniforms.uGevDisplayBlend ?? DETACHED_OVERLAY.uGevDisplayBlend,
|
||||
@@ -446,6 +453,15 @@ export function createMoverMesh(
|
||||
pixelRatio,
|
||||
};
|
||||
uniforms.uGevPixelRatio.value = pixelRatio;
|
||||
uniforms.uGevScaledCamera.value[0] = cameraPosition.x / 6378137;
|
||||
uniforms.uGevScaledCamera.value[1] = cameraPosition.y / 6378137;
|
||||
uniforms.uGevScaledCamera.value[2] =
|
||||
cameraPosition.z / 6356752.3142451793;
|
||||
// Subtract in double precision while the camera is near the surface.
|
||||
uniforms.uGevLimbSquared.value = uniforms.uGevScaledCamera.value.reduce(
|
||||
(sum, value) => sum + value * value,
|
||||
-1,
|
||||
);
|
||||
uniforms.uGevFootprint.value = footprintPerDepth(
|
||||
fovDeg,
|
||||
viewportHeightPx,
|
||||
|
||||
@@ -14,9 +14,29 @@ export const OVERLAY_DEPTH_MODES = Object.freeze({
|
||||
fail: 2,
|
||||
});
|
||||
|
||||
// Cesium clears terrain depth before primitives, retaining only the limb
|
||||
// plane. The ray-cone test limits that plane to the Earth's silhouette.
|
||||
const MOVER_DEPTH_GLSL = /* glsl */ `
|
||||
bool gevMoverHorizonHidden(float limbSquared, float towardCenter, float raySquared) {
|
||||
return limbSquared >= 0.0 && towardCenter > limbSquared &&
|
||||
towardCenter * towardCenter > limbSquared * raySquared;
|
||||
}
|
||||
bool gevMoverSceneHidden(float mine, float scene, float globe) {
|
||||
// Allow the same two depth-copy rounding steps as ground classification.
|
||||
return scene < globe - 2e-7 && packedDepthOccluded(mine, scene, 2e-6);
|
||||
}
|
||||
`;
|
||||
|
||||
/** Fragment declarations: uniforms, the varying and gevOverlayHidden(). */
|
||||
export const OVERLAY_DEPTH_FRAGMENT = /* glsl */ `
|
||||
${PACKED_DEPTH_GLSL}
|
||||
#ifdef GEV_MOVER_DEPTH
|
||||
${MOVER_DEPTH_GLSL}
|
||||
uniform sampler2D tGevGlobeDepth;
|
||||
uniform vec3 uGevScaledCamera;
|
||||
uniform float uGevLimbSquared;
|
||||
varying vec3 vGevScaledRay;
|
||||
#endif
|
||||
uniform sampler2D tGevSceneDepth;
|
||||
uniform vec2 uGevResolution;
|
||||
uniform float uGevDepthMode;
|
||||
@@ -30,7 +50,11 @@ bool gevOverlayHidden() {
|
||||
return false;
|
||||
// three's unpackRGBAToDepth (RGBADepthPacking).
|
||||
float scene = dot(
|
||||
#ifdef GEV_MOVER_DEPTH
|
||||
texelFetch(tGevSceneDepth, ivec2(gl_FragCoord.xy), 0),
|
||||
#else
|
||||
texture2D(tGevSceneDepth, gl_FragCoord.xy / uGevResolution),
|
||||
#endif
|
||||
vec4(255.0 / 256.0, 255.0 / 65536.0, 255.0 / 16777216.0, 1.0 / 16777216.0)
|
||||
);
|
||||
#ifdef USE_LOGARITHMIC_DEPTH_BUFFER
|
||||
@@ -39,6 +63,17 @@ bool gevOverlayHidden() {
|
||||
float mine = gl_FragCoord.z;
|
||||
#endif
|
||||
bool occluded = packedDepthOccluded(mine, scene, 2e-6);
|
||||
#ifdef GEV_MOVER_DEPTH
|
||||
float globe = dot(
|
||||
texelFetch(tGevGlobeDepth, ivec2(gl_FragCoord.xy), 0),
|
||||
vec4(255.0 / 256.0, 255.0 / 65536.0, 255.0 / 16777216.0, 1.0 / 16777216.0)
|
||||
);
|
||||
occluded = gevMoverHorizonHidden(
|
||||
uGevLimbSquared,
|
||||
-dot(vGevScaledRay, uGevScaledCamera),
|
||||
dot(vGevScaledRay, vGevScaledRay)
|
||||
) || gevMoverSceneHidden(mine, scene, globe);
|
||||
#endif
|
||||
return uGevDepthMode < 1.5 ? occluded : !occluded;
|
||||
}
|
||||
`;
|
||||
|
||||
Reference in new issue
Block a user