forked from Blendman974/faceclaw
Add Glanceboard depth setting
This commit is contained in:
1 parent
71c1971992
commit
915f155819
29 files changed
+262
-50
No files matched your search
@@ -27,7 +27,7 @@ function fixture() {
|
||||
let now = 1000, nextTask = 0, screenOn = true, shellOptions;
|
||||
const tasks = new Map(), sent = [], previews = [], received = [], errors = [];
|
||||
const boardStats = { starts: 0, stops: 0, paints: 0 };
|
||||
const settings = { lock: true, enabled: true, tap: true, hold: true, tilt: true, duration: 3000 };
|
||||
const settings = { lock: true, enabled: true, tap: true, hold: true, tilt: true, duration: 3000, depth: 0 };
|
||||
const clock = { Date: class extends Date { static now() { return now; } },
|
||||
setTimeout: (fn, ms) => { tasks.set(++nextTask, { fn, at: now + ms }); return nextTask; },
|
||||
clearTimeout: id => tasks.delete(id), setInterval: () => ++nextTask, clearInterval() {} };
|
||||
@@ -63,6 +63,8 @@ function fixture() {
|
||||
async configureSurface(id, options) { this.compositor.configureSurface(id, options); }
|
||||
async removeSurface(id) { this.compositor.removeSurface(id); this.changed(); }
|
||||
async setSurfaceVisible(id, visible) { this.compositor.setSurfaceVisible(id, visible); this.changed(); }
|
||||
depths = [];
|
||||
async setSurfaceDepth(id, depth) { this.depths.push([id, depth]); this.compositor.setSurfaceDepth(id, depth); }
|
||||
async setUnderlayDim(below, factor) { this.compositor.setUnderlayDim(below, factor); this.changed(); }
|
||||
async setScreenBlanked(blanked) { this.compositor.setScreenBlanked(blanked); this.changed(); }
|
||||
async submitSurfaceFrame(id, pixels, rect, _fingerprint, _paintMs, _frameId, draws = null) { this.compositor.submitSurfaceFrame(id, pixels, rect, draws); this.changed(); }
|
||||
@@ -96,7 +98,7 @@ function fixture() {
|
||||
const provider = {
|
||||
isEnabled: () => settings.enabled, showOnTap: () => settings.tap,
|
||||
showOnLongPress: () => settings.hold, showOnHeadTilt: () => settings.tilt,
|
||||
tapTimeoutMs: () => settings.duration,
|
||||
tapTimeoutMs: () => settings.duration, depth: () => settings.depth,
|
||||
createBoard: () => ({ start: () => boardStats.starts++, stop: () => boardStats.stops++,
|
||||
paint: () => { boardStats.paints++; return new images.GrayImage(100, 80, 200); } }),
|
||||
};
|
||||
@@ -194,6 +196,16 @@ test('iOS sleep tap shows the shared board; repeated tap renews timeout and hide
|
||||
assert.equal(f.boardStats.starts, 1); assert.equal(f.boardStats.stops, 1);
|
||||
});
|
||||
|
||||
test('Glanceboard applies its depth setting to its surface only when it changes', async () => {
|
||||
const f = fixture(); await f.connect(); f.shell.sleep(); await f.render();
|
||||
f.settings.depth = 32; await f.hardware(0); assertBoard(f.sent.at(-1));
|
||||
await f.advance(3100); await f.render(); assert.equal(f.controller.glance.isVisible(), false);
|
||||
await f.hardware(0); assert.equal(f.controller.glance.isVisible(), true);
|
||||
await f.advance(3100); await f.render();
|
||||
f.settings.depth = 0; await f.hardware(0);
|
||||
assert.deepEqual(f.controller.display.depths, [['glance', 32], ['glance', 0]]);
|
||||
});
|
||||
|
||||
test('iOS holds and tap-then-holds last until release, including with phone backgrounded', async () => {
|
||||
const f = fixture(); await f.connect(); f.shell.sleep(); f.controller.pause();
|
||||
const previews = f.previews.length;
|
||||
|
||||
@@ -51,15 +51,43 @@ class DisplayListTest {
|
||||
val calls = listOf(DrawProtocol.call(DRAW_OP_DISPLAY_LIST,DrawProtocol.word(20)), DrawProtocol.image(10,3,1),
|
||||
DrawProtocol.call(DRAW_OP_TEXT,hex("0c00070003000f0141")), DrawProtocol.lut(8,4,128))
|
||||
resources[21]=DrawProtocol.displayList(calls)
|
||||
val screen=hex("123456789abcdef0123456789abcdef0"); val output=ByteArray(16)
|
||||
// Like the C harness, seed composition with the screen: this list has no screen copy.
|
||||
val screen=hex("123456789abcdef0123456789abcdef0"); val output=screen.copyOf()
|
||||
val renderer=DisplayListRenderer(resources)
|
||||
assertEquals(setOf(10,11,12,20,21),renderer.render(21,DisplayListRenderer.Target(screen,8,4),DisplayListRenderer.Target(output,8,4)))
|
||||
// Shared with the C sanitizer harness: signed clipping, resource target override, font and LUT.
|
||||
assertContentEquals(hex("71122334755061700112233445534477"),output)
|
||||
val first=output.copyOf(); renderer.render(21,DisplayListRenderer.Target(screen,8,4),DisplayListRenderer.Target(output,8,4))
|
||||
val first=output.copyOf(); screen.copyInto(output); renderer.render(21,DisplayListRenderer.Target(screen,8,4),DisplayListRenderer.Target(output,8,4))
|
||||
assertContentEquals(first,output)
|
||||
assertContentEquals(hex("123456789abcdef0123456789abcdef0"),screen)
|
||||
}
|
||||
@Test fun rootListsComposeTheScreenCopyAndClearBeforeDepthShifts() {
|
||||
val screen = ByteArray(640 * 480 / 2) { (0x12 + it * 0x22).toByte() }
|
||||
val sourceTarget = DisplayListRenderer.Target(screen, 640, 480)
|
||||
// Without a copy, a root presents only what it draws.
|
||||
val empty = mapOf(1 to DrawProtocol.displayList(emptyList()))
|
||||
val composition = ByteArray(screen.size) { 0x55 }
|
||||
DisplayListRenderer(empty).render(1, sourceTarget, DisplayListRenderer.Target(composition, 640, 480))
|
||||
assertTrue(composition.all { it == 0x55.toByte() })
|
||||
for (depth in listOf(-64, -17, 0, 1, 32)) for (right in listOf(false, true)) {
|
||||
val resources = mapOf(1 to DrawProtocol.displayList(DrawProtocol.screenCopy(640, 480, depth)))
|
||||
val output = ByteArray(screen.size) { -1 }
|
||||
val target = DisplayListRenderer.Target(output, 640, 480)
|
||||
DisplayListRenderer(resources, rightLens = right).render(1, sourceTarget, target)
|
||||
val shift = DrawProtocol.depthOffset(depth, right)
|
||||
for (y in listOf(0, 479)) for (x in 0 until 640) {
|
||||
val sx = x - shift
|
||||
assertEquals(if (sx in 0 until 640) sourceTarget.get(sx, y) else 0, target.get(x, y), "depth=$depth right=$right x=$x")
|
||||
}
|
||||
}
|
||||
// Clear fills the whole resource target, padding included, and ignores depth.
|
||||
val raw = DrawProtocol.rawImage(3, 2, hex("1234ab12"))
|
||||
DisplayListRenderer(mapOf(5 to raw)).execute(DrawProtocol.sequence(listOf(DrawProtocol.clear(7, target = 5))),
|
||||
DisplayListRenderer.Target(ByteArray(1), 1, 1))
|
||||
assertContentEquals(DrawProtocol.rawImage(3, 2, hex("77777777")), raw)
|
||||
val rejected = DrawProtocol.call(DRAW_OP_CLEAR, hex("10"))
|
||||
assertFails { DisplayListRenderer(emptyMap()).execute(DrawProtocol.sequence(listOf(rejected)), DisplayListRenderer.Target(ByteArray(1), 1, 1)) }
|
||||
}
|
||||
@Test fun graphValidationPrecedesMutationAndCopyPreservesOverlap() {
|
||||
val screen=hex("12345678"); val target=DisplayListRenderer.Target(screen,8,1)
|
||||
val copy=DrawProtocol.call(DRAW_OP_RECT_COPY,hex("feff000000000600010002000000"))
|
||||
@@ -80,7 +108,7 @@ class DisplayListTest {
|
||||
val screen = hex("012345601234560112345601234560122345601234560123345601234560123445601234560123455601234f60123456601234560123456001234560123456011234560123456012234560123456012334560123456012344560123456012345")
|
||||
val expected = listOf("01234560123456011aaaaaaaaaa56012aa45644444aa0123a4564444456a1234a564f44f564a2345a6444fff644a3456a4444456444a4560aa44456444aa56011aaaaaaaaaa56012234560123456012334560123456012344560123456012345", "012345601234560112aaaaaaaaaa60122aa56444445aa1233a5644444564a2344a644f44f644a3455a4444ff6444a4566a4444564444a5600aa44564444aa60112aaaaaaaaaa6012234560123456012334560123456012344560123456012345")
|
||||
for (right in listOf(false, true)) {
|
||||
val output = ByteArray(screen.size)
|
||||
val output = screen.copyOf() // the shared vector's list has no screen copy
|
||||
DisplayListRenderer(resources, rightLens = right).render(42, DisplayListRenderer.Target(screen,16,12), DisplayListRenderer.Target(output,16,12))
|
||||
assertContentEquals(hex(expected[if(right) 1 else 0]), output)
|
||||
}
|
||||
@@ -189,6 +217,36 @@ class DisplayListTest {
|
||||
assertTrue(reconnect.commands.any { it[0].toInt()==29 });glasses.apply(reconnect.commands)
|
||||
assertContentEquals(newer,glasses.screen)
|
||||
}
|
||||
@Test fun fullScreenSurfaceDepthShiftsThePresentedScreenPerLens() {
|
||||
val c = SurfaceCompositor()
|
||||
c.configureScreen(640, 480)
|
||||
c.configureSurface("app", 0, 0, 640, 480, 0, 0)
|
||||
c.configureSurface("glance", 0, 0, 640, 480, 900, 0)
|
||||
val board = ByteArray(640 * 480) { if (it % 640 in 100 until 110) 255.toByte() else 0 }
|
||||
c.submitSurface("glance", ArrayByteReader(board), 0, 0, 640, 480, "board")
|
||||
c.setSurfaceDepth("glance", 32)
|
||||
assertEquals(32, c.composite().shellScene.screenDepth)
|
||||
// Only the topmost visible surface counts, and only when it opaquely covers the screen.
|
||||
c.configureSurface("partial", 0, 0, 10, 10, 950, 0)
|
||||
assertEquals(0, c.composite().shellScene.screenDepth)
|
||||
c.setSurfaceVisible("partial", false)
|
||||
c.setSurfaceVisible("glance", false)
|
||||
assertEquals(0, c.composite().shellScene.screenDepth)
|
||||
c.setSurfaceVisible("glance", true)
|
||||
val composite = c.composite()
|
||||
val screen = BmpUtil.pack4bppFromGray8(composite.screenGray, 640, 480)
|
||||
for (right in listOf(false, true)) {
|
||||
val glasses = Glasses(right)
|
||||
glasses.composition.fill(-1) // stale pixels from an earlier frame
|
||||
glasses.apply(ScenePlanner(ResourceCacheState()).plan(screen, 640, 480, null, composite.shellScene, 1).commands)
|
||||
assertContentEquals(screen, glasses.screen)
|
||||
val output = DisplayListRenderer.Target(glasses.composition, 640, 480)
|
||||
val shift = if (right) -16 else 16
|
||||
assertEquals(15, output.get(100 + shift, 0)); assertEquals(0, output.get(99 + shift, 0))
|
||||
assertEquals(15, output.get(109 + shift, 479)); assertEquals(0, output.get(110 + shift, 479))
|
||||
assertEquals(0, output.get(if (right) 639 else 0, 240)) // cleared, not stale
|
||||
}
|
||||
}
|
||||
@Test fun noisyFramesRemainBoundedAndResourceBudgetIs192KiB() {
|
||||
val cache=ResourceCacheState();val planner=ScenePlanner(cache);val glasses=Glasses()
|
||||
val app=ByteArray(640*480/2){(it*37).toByte()}
|
||||
|
||||
@@ -74,7 +74,7 @@ class DrawExpressionTest {
|
||||
|
||||
@Test fun playerSchedulesOnlyUnfinishedFramesAndCancelsStaleCallbacks() {
|
||||
val call = DrawProtocol.roundedRect(DrawValue.Integer(0), DrawValue.animate(0, 4, 300), 2, 2, 0, 15)
|
||||
val renderer = DisplayListRenderer(mapOf(1 to DrawProtocol.displayList(listOf(call))))
|
||||
val renderer = DisplayListRenderer(mapOf(1 to DrawProtocol.displayList(DrawProtocol.screenCopy(4, 8) + call)))
|
||||
val screen = DisplayListRenderer.Target(ByteArray(16), 4, 8)
|
||||
val output = DisplayListRenderer.Target(ByteArray(16), 4, 8)
|
||||
var now = 1000L
|
||||
|
||||
@@ -5,7 +5,7 @@ import kotlin.test.*
|
||||
class DrawWireTest {
|
||||
private fun hex(value: String) = value.chunked(2).map { it.toInt(16).toByte() }.toByteArray()
|
||||
|
||||
@Test fun encodersUseRevision27CoordinatesAndPreserveOtherWireBytes() {
|
||||
@Test fun encodersUseRevision28CoordinatesAndPreserveOtherWireBytes() {
|
||||
// Literal vectors pin the firmware grammar independently of the reader.
|
||||
val calls = listOf(
|
||||
DrawProtocol.image(0x1234, -32768, 32767, 0x1f, target = 511, depth = -128) to
|
||||
@@ -20,12 +20,20 @@ class DrawWireTest {
|
||||
DrawProtocol.lut(640, 480, 256) to "0600000000008002e0010123456789abcdef",
|
||||
DrawProtocol.bbox(hex("ffffffffffffffff"), 4, 0, 0, 8, 2) to "010000000002010f10",
|
||||
DrawProtocol.bbox(hex("0f"), 1, 1, 0, 1, 1) to "01000101000000010001001f",
|
||||
DrawProtocol.clear(15, target = 511) to "0901ff010f",
|
||||
)
|
||||
for ((call, expected) in calls) assertContentEquals(hex(expected), call)
|
||||
assertContentEquals(hex("0100050007027fff01"), DrawProtocol.sequence(listOf(calls[4].first)))
|
||||
assertContentEquals(hex("1a0100050007027fff01"), DrawProtocol.message(listOf(calls[4].first)))
|
||||
assertContentEquals(hex("020100050007027fff01"), DrawProtocol.displayList(listOf(calls[4].first)))
|
||||
assertContentEquals(hex("1bffff"), DrawProtocol.root(DrawProtocol.SCREEN))
|
||||
val flat = DrawProtocol.screenCopy(640, 352)
|
||||
assertEquals(1, flat.size)
|
||||
assertContentEquals(hex("0200ffff000000008002600100000000"), flat[0])
|
||||
val shifted = DrawProtocol.screenCopy(640, 352, -32)
|
||||
assertEquals(2, shifted.size)
|
||||
assertContentEquals(hex("090000"), shifted[0])
|
||||
assertContentEquals(hex("0202e0ffff000000008002600100000000"), shifted[1])
|
||||
}
|
||||
|
||||
@Test fun optimizerFieldsAreReencodedAndOpaqueBytesArePreserved() {
|
||||
|
||||
Reference in new issue
Block a user