Release God's Eye View as open source

src/data/trackedCamera.test.mjs

@@ -0,0 +1,94 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import {
+  clampTrackedCameraPosition,
+  trackedDisplayPositionForCamera,
+  trackedModelScaleForPixelCap,
+} from './trackedCamera.js';
+
+test('tracked camera origin crossing returns to the prior side at the minimum range', () => {
+  const camera = {
+    position: new Cesium.Cartesian3(0, 500, -300),
+    direction: new Cesium.Cartesian3(0, -1, 0),
+  };
+  const previous = new Cesium.Cartesian3(0, -1000, 600);
+  assert.equal(clampTrackedCameraPosition(camera, previous, 150), true);
+  assert.ok(Cesium.Cartesian3.dot(camera.position, previous) > 0);
+  assert.ok(Math.abs(Cesium.Cartesian3.magnitude(camera.position) - 150) < 1e-9);
+});
+
+test('tracked camera clamps a too-close approach along the current sight line', () => {
+  const camera = {
+    position: new Cesium.Cartesian3(0, -80, 0),
+    direction: new Cesium.Cartesian3(0, 1, 0),
+  };
+  const previous = new Cesium.Cartesian3(0, -200, 0);
+  assert.equal(clampTrackedCameraPosition(camera, previous, 150), true);
+  assert.ok(Math.abs(camera.position.x) === 0);
+  assert.equal(camera.position.y, -150);
+  assert.ok(Math.abs(camera.position.z) === 0);
+});
+
+test('tracked camera leaves a safe approach unchanged', () => {
+  const camera = {
+    position: new Cesium.Cartesian3(0, -800, 500),
+    direction: Cesium.Cartesian3.normalize(
+      new Cesium.Cartesian3(0, 800, -500),
+      new Cesium.Cartesian3(),
+    ),
+  };
+  const previous = Cesium.Cartesian3.clone(camera.position);
+  const before = Cesium.Cartesian3.clone(camera.position);
+  assert.equal(clampTrackedCameraPosition(camera, previous, 150), false);
+  assert.deepEqual(camera.position, before);
+});
+
+test('tracked model keeps calibrated scale when it projects below the pixel cap', () => {
+  const scale = trackedModelScaleForPixelCap({
+    baseScale: 24,
+    nativeRadiusM: 1.43,
+    rangeM: 1000,
+    viewportHeightPx: 800,
+    fovyRad: Math.PI / 3,
+    maximumPixelSize: 104,
+  });
+  assert.equal(scale, 24);
+});
+
+test('tracked model shrinks smoothly when close enough to exceed the pixel cap', () => {
+  const scale = trackedModelScaleForPixelCap({
+    baseScale: 24,
+    nativeRadiusM: 1.43,
+    rangeM: 150,
+    viewportHeightPx: 800,
+    fovyRad: Math.PI / 3,
+    maximumPixelSize: 104,
+  });
+  const focalLengthPx = 800 / (2 * Math.tan(Math.PI / 6));
+  const projectedDiameterPx = (2 * 1.43 * scale * focalLengthPx) / 150;
+  assert.ok(scale < 24);
+  assert.ok(Math.abs(projectedDiameterPx - 104) < 1e-9);
+});
+
+test('tracked camera prefers the already-rendered display cache', () => {
+  let callbackReads = 0;
+  const cached = new Cesium.Cartesian3(1, 2, 3);
+  const entity = {
+    gevDisplayPosition: () => cached,
+    position: {
+      getValue: () => {
+        callbackReads += 1;
+        return new Cesium.Cartesian3(4, 5, 6);
+      },
+    },
+  };
+  const result = trackedDisplayPositionForCamera(
+    entity,
+    Cesium.JulianDate.now(),
+    new Cesium.Cartesian3(),
+  );
+  assert.deepEqual(result, cached);
+  assert.notEqual(result, cached);
+  assert.equal(callbackReads, 0);
+});