Files
faceclaw/tests/compass-texture-cache.test.cjs
T
James Babcock a02b849200 Borderless modes have different padding inside the builtin apps
Most of the builtin apps had some padding between the window edge and
their content, because they expect to be displayed with a line border on
their edge. We added a customization option to remove the border, so,
that padding is not always necessary. Make the layouts dynamically
adjust, to omit the padding when it isn't needed.
2026-11-11 15:19:29 -08:00

176 lines
7.8 KiB
JavaScript

const test = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs');
const path = require('node:path');
const vm = require('node:vm');
const ts = require('typescript');
const { bordered, unbordered } = require('./helpers/viewport.cjs');
function load(file, modules = {}, extra = '', globals = {}) {
const source = fs.readFileSync(path.join(__dirname, '..', file), 'utf8') + extra;
const context = { exports: {}, require: (name) => {
assert.ok(name in modules, `Unexpected dependency: ${name}`);
return modules[name];
}, ...globals };
vm.runInNewContext(ts.transpileModule(source, {
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
}).outputText, context, { filename: file });
return context.exports;
}
const textwrap = load('app/graphics/textwrap.ts');
const { BdfFont } = load('app/graphics/bdffont.ts', { '@nativescript/core': {} });
const graphics = require('../.test-build/app/graphics/image.js');
const { GrayImage } = graphics;
const font = (size) => BdfFont.parse(fs.readFileSync(
path.join(__dirname, `../app/fonts/terminus/ter-u${size}n.bdf`), 'utf8'));
const small = font(12);
const large = font(24);
let viewportWidth = 576;
const calibration = { isCompassCalibrated: () => true, normalizeHeading: (n) => ((n % 360) + 360) % 360 };
// The rose renderer's private helpers are re-exported for referenceFrame.
const rose = load('app/apps/compass/compass-rose.ts', {
'../../graphics/image': graphics,
'./calibration': calibration,
}, `
export { rotatingRoseBounds, drawPlaneGrid, drawDiscWall, drawTiltedRing, drawHeadingTick };
`);
const compass = load('app/apps/compass/compass-app.ts', {
'../../graphics/ui-fonts': { getDefaultSmallFont: () => small, getDefaultLargeFont: () => large },
'../../graphics/image': graphics,
'../../graphics/textwrap': textwrap,
'../../native/compass': {},
'../../ui/metrics': { lineStep: (font) => font.lineHeight + 2 },
'../../ui/shell/geometry': { screenCenterInViewportX: () => viewportWidth - 320 },
'../../ui/shell/in-process-window': {},
'../../ui/shell/shell': {},
'../../native/location-permissions': {},
'../../ui/dashboard-settings': { glassesHaveCompass: () => true },
'./calibration': calibration,
'./calibration-layer': {},
'./compass-rose': rose,
'./declination': {},
'./heading': { getNorthReference: () => 'magnetic', resolveHeading: (n) => ({ displayDegrees: n }) },
}, `
export { CompassLayer };
const rose_1 = require('./compass-rose');
export const rotatingRoseBounds = rose_1.rotatingRoseBounds;
export const createCompassBackground = rose_1.createCompassBackground;
export const drawCompassRose = rose_1.drawCompassRose;
export function referenceFrame(width, height, cx, cy, radius, clipY, heading) {
const image = new GrayImage(width, height, 0);
const fade = heading === null ? 0.45 : 1;
rose_1.drawPlaneGrid(image, cx, cy, radius, clipY);
rose_1.drawDiscWall(image, cx, cy, radius, fade);
rose_1.drawTiltedRing(image, cx, cy, radius, 105 * fade);
rose_1.drawCompassRose(image, cx, cy, radius, heading);
rose_1.drawHeadingTick(image, cx, cy, radius, 255 * fade);
return image;
}
`);
test('rotation bounds contain every painted point through a full turn', () => {
for (const radius of [24, 60, 98]) {
const cx = 120;
const cy = 70.25;
const bounds = compass.rotatingRoseBounds(cx, cy, radius);
assert.ok(bounds.width <= 255 && bounds.height <= 255, 'fits a cache image');
const image = new GrayImage(240, 160, 0);
// Accumulate the entire sweep, including fractional-degree orientations.
for (let heading = 0; heading < 360; heading += 0.5) {
compass.drawCompassRose(image, cx, cy, radius, heading);
}
let count = 0;
for (let y = 0; y < image.height; y++) {
for (let x = 0; x < image.width; x++) {
if (!image.getPixel(x, y)) continue;
count++;
assert.ok(x >= bounds.x && x < bounds.x + bounds.width
&& y >= bounds.y && y < bounds.y + bounds.height, `point outside bounds at ${x},${y}`);
}
}
assert.ok(count > 0);
}
});
test('cached background preserves the raster and tick layering at every heading', () => {
for (const [width, height, radius] of [[576, 260, 98], [640, 452, 98], [240, 160, 24]]) {
const cx = width / 2;
const cy = height - 65.25;
for (const heading of [null, ...Array.from({ length: 72 }, (_, i) => i * 5)]) {
const background = compass.createCompassBackground(width, height, cx, cy, radius, 30, heading === null ? 0.45 : 1);
const image = background.clone();
compass.drawCompassRose(image, cx, cy, radius, heading);
const expected = compass.referenceFrame(width, height, cx, cy, radius, 30, heading);
assert.deepEqual(image.withDrawsBaked().pixels, expected.pixels, `heading ${heading}, radius ${radius}`);
assert.equal(image.draws.length, 1);
const draw = image.draws[0];
assert.equal(draw.kind, 'image');
assert.equal(draw.source.hasDeferredDraws(), false);
const bounds = compass.rotatingRoseBounds(cx, cy, radius);
assert.deepEqual({ x: draw.x, y: draw.y, width: draw.source.width, height: draw.source.height }, { ...bounds });
// Every nonzero texture pixel must match the final composite, as the
// wire planner requires before it can replay a cached image.
for (let y = 0; y < draw.source.height; y++) {
for (let x = 0; x < draw.source.width; x++) {
const value = draw.source.getPixel(x, y);
if (value) assert.equal(value, expected.getPixel(draw.x + x, draw.y + y));
}
}
}
}
});
test('heading updates reuse the texture; brightness, layout and clipping changes rebuild it', () => {
const layer = new compass.CompassLayer(() => {});
layer.enabled = true;
let height = 260;
let viewport = bordered;
const ctx = { stack: { getBaseSize: () => viewport(viewportWidth, height) } };
const texture = () => layer.paint(ctx).draws.find((draw) => draw.kind === 'image').source;
const waiting = texture();
layer.rawHeading = 0;
const initial = texture();
assert.notEqual(initial, waiting);
const snapshot = initial.pixels.slice();
for (const heading of [1, 45, 180, 359.9, 0]) {
layer.rawHeading = heading;
assert.equal(texture(), initial);
}
assert.deepEqual(initial.pixels, snapshot, 'shared texture remains immutable');
height = 452;
const tall = texture();
assert.notEqual(tall, initial);
viewportWidth = 640;
const wide = texture();
assert.notEqual(wide, tall);
layer.firmwareStatus = 'Calibration status '.repeat(12);
const wrapped = texture();
assert.notEqual(wrapped, wide);
// Losing the borders moves the rose toward the edges, at the same size.
viewport = unbordered;
assert.notEqual(texture(), wrapped);
viewportWidth = 576;
});
test('the background registers once and uses a nine-byte image reference on later frames', () => {
const registered = [];
const atlas = load('app/native/texture-atlas.ts', { './java-direct-buffer': { copyToJavaByteBuffer: (bytes) => bytes } }, '', {
global: { isAndroid: true },
com: { faceclaw: { app: { AndroidByteReader: class { constructor(buffer) { this.buffer = buffer; } }, ImageAtlas: { ensure: (...args) => {
registered.push(args);
return 1;
} } } } },
});
const { prepareFrameDraws } = load('app/graphics/glyph-wire.ts', { '../native/texture-atlas': atlas, './presentation-wire': require('../.test-build/app/graphics/presentation-wire.js') });
const background = compass.createCompassBackground(576, 260, 256, 193.25, 98, 140, 1);
for (const heading of [0, 1, 2, 45, 90]) {
const image = background.clone();
compass.drawCompassRose(image, 256, 193.25, 98, heading);
const buffer = prepareFrameDraws(image.draws);
assert.equal(buffer.byteLength, 9);
assert.equal(new DataView(buffer).getUint8(0), 1);
}
assert.equal(registered.length, 1);
});