mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
Animations are mainly on the typescript side, not kotlin
This commit is contained in:
1 parent
063d8a0b03
commit
440674b261
26 files changed
+783
-128
No files matched your search
@@ -0,0 +1,84 @@
|
||||
# TypeScript display lists
|
||||
|
||||
`GrayImage.drawDisplayList(list, x, y, width, height, depth)` retains a list alongside
|
||||
the image's ordinary pixels. Existing frame submission (`prepareFrameDraws`) and
|
||||
shell scene submission carry it to Kotlin. Bounds describe its footprint for plane
|
||||
occlusion; draw coordinates are relative to its placement. Keep the list, its image
|
||||
resources, and their pixel buffers immutable after submission.
|
||||
|
||||
```ts
|
||||
import { DrawExpression as E } from './draw-expression';
|
||||
import { DrawOp, type DisplayList } from './display-list';
|
||||
|
||||
const list: DisplayList = {
|
||||
resources: [],
|
||||
timeline: { token: animationId, startedAt: Date.now() },
|
||||
calls: [{
|
||||
op: DrawOp.ROUNDED_RECT,
|
||||
x: E.progress(300).ease().lerp(E.f32(0), E.f32(100)).toInt(),
|
||||
y: 0,
|
||||
width: 40, height: 20, radius: 6,
|
||||
background: 4, border: 15,
|
||||
}],
|
||||
};
|
||||
frame.drawDisplayList(list, 20, 30, 140, 20, 0);
|
||||
```
|
||||
|
||||
Supported calls in this first pass:
|
||||
|
||||
- `ROUNDED_RECT`: literal or expression `x`/`y`, literal dimensions/radius, and
|
||||
4-bit colors (0–15). Border 16 means no border. Fill takes the maximum of the
|
||||
background color and existing pixels.
|
||||
- `IMAGE`: a local resource index, integer `x`/`y`, and `transparent`. Transparent
|
||||
images skip pixels quantized to zero. Resources have `width`, `height`, and
|
||||
gray8 `pixels`; a baked `GrayImage` can be used directly.
|
||||
- `RECT_COPY`: a local resource index, integer source rectangle and destination
|
||||
`dx`/`dy`. `SCREEN` reads the uncomposed frame; its source coordinates are also
|
||||
relative to this list's placement. Each call may add its own `depth` to the
|
||||
list's depth. A screen restore normally uses the negative of the list depth.
|
||||
|
||||
Kotlin allocates/cache-pins all image resources, resolves the local indices, applies
|
||||
surface placement, and includes the calls in the root firmware display list. The
|
||||
phone's existing display-list renderer consumes the same compiled calls. This uses
|
||||
the current firmware protocol; no firmware update is needed for this bridge change.
|
||||
|
||||
## Expressions and time
|
||||
|
||||
`E.i32` and `E.f32` construct typed constants. Builders support arithmetic, min/max,
|
||||
integer remainder, negation, explicit conversions, lerp, and the easing functions
|
||||
in `ExprOp`. `ease()` defaults to smoothstep. Integers wrap at 32 bits; float
|
||||
operations round to f32. The firmware's existing stack/error semantics apply.
|
||||
Only rounded-rectangle x/y accept expressions in this first pass.
|
||||
|
||||
`maximum.time()` returns `min(milliseconds since PRESENT, maximum)`. The existing
|
||||
45 ms repaint timer remains active while this is below maximum. `E.elapsed()` is
|
||||
a bridge binding: Kotlin replaces it with the timeline's elapsed milliseconds when
|
||||
building a new root list. It is a constant within that PRESENT, not a second clock.
|
||||
`E.progress(durationMs)` combines the two and clamps to 0..1 so intervening frames
|
||||
and PRESENTs continue an animation instead of restarting it.
|
||||
|
||||
Keep `timeline.token` and `timeline.startedAt` stable for an animation; use a new
|
||||
token when restarting it. JS sends an elapsed duration, so JS and native clocks
|
||||
need not share an epoch. Fingerprints include the token and expression code but
|
||||
exclude the changing elapsed duration. Without a timeline, raw `time()` expressions
|
||||
start at each PRESENT. Native compilation strips the bridge-only elapsed opcode.
|
||||
|
||||
`menu-selection-list.ts` authors both the rounded highlight and the transparent row
|
||||
image using this API. Navigation eligibility, duration, and easing remain in
|
||||
TypeScript. There is no animated-menu tag or menu animation policy in Kotlin.
|
||||
|
||||
## Bridge framing
|
||||
|
||||
Tag 7 is followed by a little-endian u32 byte length and a bounded body:
|
||||
placement (i16 x/y, u16 width/height, i8 depth), timeline (u32 token/elapsed),
|
||||
u16 resource count, gray8 images (u16 width/height followed by pixels), u16 call
|
||||
count, then calls. Calls start with the firmware opcode and an i16 relative depth;
|
||||
operands otherwise use their fixed-width fields, except rounded x/y which use
|
||||
extended varints. Expressions use the firmware bytecode plus bridge-only
|
||||
`ELAPSED = 128`. Resource indices are local to this record, never firmware IDs.
|
||||
Rect-copy source x/y are signed here to permit relative SCREEN coordinates.
|
||||
|
||||
Limits: 256 images per record, 64 KiB per packed image, 4 MiB per bridge record,
|
||||
4096 calls, and 900 input bytes per expression. Native validates the bound program
|
||||
against the firmware's 1024-byte limit. The combined scene must also fit the
|
||||
existing resource cache, root-list size, and VM stack limits.
|
||||
@@ -0,0 +1,133 @@
|
||||
import { DrawBytes, encodeValue, evaluate, integer, readValue, type DrawValue } from './draw-expression';
|
||||
|
||||
/** Local resources are assigned firmware cache IDs by Kotlin. SCREEN reads the uncomposed frame. */
|
||||
export const SCREEN = 65535;
|
||||
export const DrawOp = { RECT_COPY: 2, IMAGE: 4, ROUNDED_RECT: 8 } as const;
|
||||
export const DISPLAY_LIST_RECORD = 7;
|
||||
export type ListImage = { readonly width: number; readonly height: number; readonly pixels: Uint8Array };
|
||||
export type ListCall = (
|
||||
| { op: typeof DrawOp.ROUNDED_RECT; x: DrawValue; y: DrawValue; width: number; height: number; radius: number; background: number; border: number }
|
||||
| { op: typeof DrawOp.IMAGE; resource: number; x: number; y: number; transparent: boolean }
|
||||
| { op: typeof DrawOp.RECT_COPY; resource: number; x: number; y: number; width: number; height: number; dx: number; dy: number }
|
||||
) & { depth?: number };
|
||||
export type DisplayList = {
|
||||
readonly resources: readonly ListImage[];
|
||||
readonly calls: readonly ListCall[];
|
||||
/** Stable identity plus JS clock origin. Native binds ELAPSED again for each PRESENT. */
|
||||
/** Set by the decoder: the local PRESENT origin for software replay. */
|
||||
readonly presentedAt?: number;
|
||||
readonly timeline?: { readonly token: number; readonly startedAt: number };
|
||||
};
|
||||
export type PlacedDisplayList = { displayList: DisplayList; x: number; y: number; width: number; height: number; depth: number };
|
||||
|
||||
class Writer {
|
||||
bytes: number[] = [];
|
||||
u8(n: number): void { this.bytes.push(integer(n, 0, 255)); }
|
||||
i8(n: number): void { this.u8(integer(n, -128, 127) & 255); }
|
||||
u16(n: number): void { integer(n, 0, 65535); this.bytes.push(n & 255, n >>> 8); }
|
||||
i16(n: number): void { this.u16(integer(n, -32768, 32767) & 65535); }
|
||||
u32(n: number): void { integer(n, 0, 4294967295); this.u16(n & 65535); this.u16(n >>> 16); }
|
||||
raw(bytes: ArrayLike<number>): void { for (let i = 0; i < bytes.length; i++) this.bytes.push(bytes[i]); }
|
||||
}
|
||||
|
||||
/** Length-delimited bridge envelope; call operands use fixed widths except extended x/y. */
|
||||
export function encodeDisplayList(placed: PlacedDisplayList, now = Date.now()): Uint8Array {
|
||||
const { displayList: list } = placed, out = new Writer();
|
||||
integer(placed.width, 1, 640); integer(placed.height, 1, 480);
|
||||
out.i16(placed.x); out.i16(placed.y); out.u16(placed.width); out.u16(placed.height); out.i8(placed.depth);
|
||||
out.u32(list.timeline?.token ?? 0);
|
||||
out.u32(list.timeline ? Math.min(2147483647, Math.max(0, Math.trunc(now - list.timeline.startedAt))) : 0);
|
||||
integer(list.resources.length, 0, 256); out.u16(list.resources.length);
|
||||
for (const image of list.resources) {
|
||||
integer(image.width, 1, 640); integer(image.height, 1, 480);
|
||||
if (image.pixels.length !== image.width * image.height || 5 + Math.ceil(image.width / 2) * image.height > 65536) throw new Error('Invalid display-list image');
|
||||
out.u16(image.width); out.u16(image.height); out.raw(image.pixels);
|
||||
}
|
||||
integer(list.calls.length, 0, 4096); out.u16(list.calls.length);
|
||||
for (const call of list.calls) {
|
||||
out.u8(call.op); out.i16(call.depth ?? 0);
|
||||
integer(placed.depth + (call.depth ?? 0), -128, 127);
|
||||
if (call.op === DrawOp.ROUNDED_RECT) {
|
||||
out.raw(encodeValue(call.x)); out.raw(encodeValue(call.y));
|
||||
out.u16(integer(call.width, 1, 640)); out.u16(integer(call.height, 1, 480)); out.u16(call.radius);
|
||||
out.u8(integer(call.background, 0, 15)); out.u8(integer(call.border, 0, 16));
|
||||
} else {
|
||||
if (call.resource !== SCREEN) integer(call.resource, 0, list.resources.length - 1);
|
||||
if (call.op === DrawOp.RECT_COPY && call.resource !== SCREEN && (call.x < 0 || call.y < 0)) throw new Error('Negative image source coordinate');
|
||||
if (call.op === DrawOp.IMAGE && call.resource === SCREEN) throw new Error('Use rectCopy to read SCREEN');
|
||||
out.u16(call.resource);
|
||||
if (call.op === DrawOp.IMAGE) { out.i16(call.x); out.i16(call.y); out.u8(call.transparent ? 31 : 15); }
|
||||
else {
|
||||
out.i16(call.x); out.i16(call.y); out.u16(integer(call.width, 1, 640)); out.u16(integer(call.height, 1, 480)); out.i16(call.dx); out.i16(call.dy);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (out.bytes.length > 4 * 1024 * 1024) throw new Error('Display list exceeds bridge limit');
|
||||
const header = new Writer(); header.u8(DISPLAY_LIST_RECORD); header.u32(out.bytes.length); header.raw(out.bytes);
|
||||
return Uint8Array.from(header.bytes);
|
||||
}
|
||||
|
||||
export function readDisplayList(bytes: Uint8Array, offset: number, now = Date.now()): { placed: PlacedDisplayList; end: number } {
|
||||
const envelope = new DrawBytes(bytes.subarray(offset));
|
||||
if (envelope.u8() !== DISPLAY_LIST_RECORD) throw new Error('Invalid display-list record');
|
||||
const length = envelope.u32(); integer(length, 0, 4 * 1024 * 1024);
|
||||
const r = new DrawBytes(envelope.take(length));
|
||||
const x = r.i16(), y = r.i16(), width = r.u16(), height = r.u16(), depth = r.u8() << 24 >> 24;
|
||||
const token = r.u32(), elapsed = r.u32(), count = r.u16(); integer(count, 0, 256);
|
||||
const resources: ListImage[] = [];
|
||||
for (let i = 0; i < count; i++) { const width = r.u16(), height = r.u16(); resources.push({ width, height, pixels: r.take(width * height) }); }
|
||||
const calls: ListCall[] = [], callCount = r.u16(); integer(callCount, 0, 4096);
|
||||
for (let i = 0; i < callCount; i++) {
|
||||
const op = r.u8(), depth = r.i16();
|
||||
if (op === DrawOp.ROUNDED_RECT) calls.push({ op, depth, x: readValue(r), y: readValue(r), width: r.u16(), height: r.u16(), radius: r.u16(), background: r.u8(), border: r.u8() });
|
||||
else if (op === DrawOp.IMAGE) calls.push({ op, depth, resource: r.u16(), x: r.i16(), y: r.i16(), transparent: (r.u8() & 16) !== 0 });
|
||||
else if (op === DrawOp.RECT_COPY) calls.push({ op, depth, resource: r.u16(), x: r.i16(), y: r.i16(), width: r.u16(), height: r.u16(), dx: r.i16(), dy: r.i16() });
|
||||
else throw new Error('Unsupported display-list call');
|
||||
}
|
||||
if (r.offset !== length) throw new Error('Trailing display-list bytes');
|
||||
const placed = { x, y, width, height, depth, displayList: { resources, calls, presentedAt: now, timeline: { token, startedAt: now - elapsed } } };
|
||||
// The writer is also the shared structural validator for software preview records.
|
||||
encodeDisplayList(placed, now);
|
||||
return { placed, end: offset + envelope.offset };
|
||||
}
|
||||
|
||||
export function dimDisplayList(list: DisplayList, factor: number): DisplayList {
|
||||
const dim = (v: number) => v === 0 ? 0 : Math.max(1, Math.round(v * factor));
|
||||
return { ...list, resources: list.resources.map(r => ({ ...r, pixels: r.pixels.map(dim) })),
|
||||
calls: list.calls.map(c => c.op === DrawOp.ROUNDED_RECT ? { ...c, background: Math.min(15, Math.round(c.background * factor)), border: c.border === 16 ? 16 : Math.min(15, Math.round(c.border * factor)) } : c) };
|
||||
}
|
||||
|
||||
/** Fallback compositor; native preview and glasses replay the compiled list with their existing timers. */
|
||||
export function paintDisplayList(output: Uint8Array, screen: Uint8Array, width: number, height: number, placed: PlacedDisplayList, right = false, now = Date.now()): void {
|
||||
const q = (n: number) => Math.min(15, (n + 8) >> 4) * 16;
|
||||
const list = placed.displayList;
|
||||
const elapsed = list.timeline ? Math.max(0, (list.presentedAt ?? now) - list.timeline.startedAt) : 0;
|
||||
const presentTime = list.presentedAt === undefined ? 0 : Math.max(0, now - list.presentedAt);
|
||||
const inside = (x: number, y: number, w: number, h: number, radius: number) => {
|
||||
if (x < 0 || y < 0 || x >= w || y >= h) return false;
|
||||
const r = Math.min(radius, Math.floor(w / 2), Math.floor(h / 2));
|
||||
const dx = Math.max(0, 2 * r - (2 * Math.min(x, w - 1 - x) + 1)), dy = Math.max(0, 2 * r - (2 * Math.min(y, h - 1 - y) + 1));
|
||||
return dx * dx + dy * dy <= 4 * r * r;
|
||||
};
|
||||
for (const c of placed.displayList.calls) {
|
||||
const depth = placed.depth + (c.depth ?? 0), shift = right ? -Math.floor((depth + 1) / 2) : Math.floor(depth / 2);
|
||||
if (c.op === DrawOp.ROUNDED_RECT) {
|
||||
const x = placed.x + evaluate(c.x, elapsed, presentTime).value + shift, y = placed.y + evaluate(c.y, elapsed, presentTime).value;
|
||||
for (let yy = 0; yy < c.height; yy++) for (let xx = 0; xx < c.width; xx++) {
|
||||
if (x + xx < 0 || y + yy < 0 || x + xx >= width || y + yy >= height || !inside(xx, yy, c.width, c.height, c.radius)) continue;
|
||||
const p = (y + yy) * width + x + xx;
|
||||
output[p] = c.border !== 16 && !inside(xx - 1, yy - 1, c.width - 2, c.height - 2, Math.max(0, c.radius - 1)) ? c.border * 16 : Math.max(output[p], c.background * 16);
|
||||
}
|
||||
} else {
|
||||
const source = c.resource === SCREEN ? { width, height, pixels: screen } : placed.displayList.resources[c.resource];
|
||||
const w = c.op === DrawOp.IMAGE ? source.width : c.width, h = c.op === DrawOp.IMAGE ? source.height : c.height;
|
||||
const sx = c.op === DrawOp.IMAGE ? 0 : c.x + (c.resource === SCREEN ? placed.x : 0), sy = c.op === DrawOp.IMAGE ? 0 : c.y + (c.resource === SCREEN ? placed.y : 0);
|
||||
const x = placed.x + (c.op === DrawOp.IMAGE ? c.x : c.dx) + shift, y = placed.y + (c.op === DrawOp.IMAGE ? c.y : c.dy);
|
||||
for (let yy = 0; yy < h; yy++) for (let xx = 0; xx < w; xx++) {
|
||||
if (x + xx < 0 || y + yy < 0 || x + xx >= width || y + yy >= height || sx + xx < 0 || sy + yy < 0 || sx + xx >= source.width || sy + yy >= source.height) continue;
|
||||
const v = q(source.pixels[(sy + yy) * source.width + sx + xx]);
|
||||
if (c.op !== DrawOp.IMAGE || !c.transparent || v !== 0) output[(y + yy) * width + x + xx] = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
/** Revision 27 expression bytecode. ELAPSED is a bridge binding, never sent to firmware. */
|
||||
export const ExprOp = {
|
||||
I32: 1, F32: 2, DUP: 3, DROP: 4, SWAP: 5,
|
||||
IADD: 16, ISUB: 17, IMUL: 18, IDIV: 19, IMOD: 20, INEG: 21, IMIN: 22, IMAX: 23,
|
||||
FADD: 32, FSUB: 33, FMUL: 34, FDIV: 35, FNEG: 36, FMIN: 37, FMAX: 38,
|
||||
I2F: 48, F2I: 49, TIME: 50, LERP: 64, SMOOTHSTEP: 65,
|
||||
EASE_IN_QUAD: 66, EASE_OUT_QUAD: 67, EASE_IN_OUT_QUAD: 68,
|
||||
EASE_IN_CUBIC: 69, EASE_OUT_CUBIC: 70, EASE_IN_OUT_CUBIC: 71,
|
||||
ELAPSED: 128,
|
||||
} as const;
|
||||
|
||||
export function integer(value: number, min: number, max: number): number {
|
||||
if (!Number.isInteger(value) || value < min || value > max) throw new Error('Draw integer out of range');
|
||||
return value;
|
||||
}
|
||||
export function varint(value: number, signed = true): number[] {
|
||||
integer(value, signed ? -2147483648 : 0, signed ? 2147483647 : 4294967295);
|
||||
const widths = [7, 14, 21, 28, 32], prefixes = [0, 128, 192, 224, 240];
|
||||
const size = widths.findIndex(bits => bits === 32 || (signed
|
||||
? value >= -(2 ** (bits - 1)) && value < 2 ** (bits - 1) : value < 2 ** bits)) + 1;
|
||||
const bytes = [size === 5 ? 240 : prefixes[size - 1] | ((value >>> (8 * (size - 1))) & ((1 << (8 - size)) - 1))];
|
||||
for (let i = 1; i < size; i++) bytes.push((value >>> (8 * (size - 1 - i))) & 255);
|
||||
return bytes;
|
||||
}
|
||||
|
||||
export class DrawBytes {
|
||||
offset = 0;
|
||||
constructor(readonly bytes: Uint8Array) {}
|
||||
take(size: number): Uint8Array {
|
||||
integer(size, 0, this.bytes.length - this.offset);
|
||||
const result = this.bytes.slice(this.offset, this.offset + size); this.offset += size; return result;
|
||||
}
|
||||
u8(): number { return this.take(1)[0]; }
|
||||
u16(): number { return this.u8() | this.u8() << 8; }
|
||||
i16(): number { return this.u16() << 16 >> 16; }
|
||||
u32(): number { return (this.u16() | this.u16() << 16) >>> 0; }
|
||||
variable(signed = true): number {
|
||||
const first = this.u8();
|
||||
const size = first < 128 ? 1 : first < 192 ? 2 : first < 224 ? 3 : first < 240 ? 4 : first === 240 ? 5 : 0;
|
||||
if (!size) throw new Error('Reserved extended-varint prefix');
|
||||
let value = size === 5 ? 0 : first & ((1 << (8 - size)) - 1);
|
||||
for (let i = 1; i < size; i++) value = (value << 8) | this.u8();
|
||||
const bits = [7, 14, 21, 28, 32][size - 1];
|
||||
return signed ? bits < 32 ? value << (32 - bits) >> (32 - bits) : value : value >>> 0;
|
||||
}
|
||||
}
|
||||
|
||||
/** Immutable, typed expression builder; operations use firmware i32/f32 semantics. */
|
||||
export class DrawExpression<T extends 'i32' | 'f32'> {
|
||||
private constructor(readonly type: T, readonly code: readonly number[]) {
|
||||
// Leave room for native elapsed bindings and surface translation.
|
||||
if (code.length > 900) throw new Error('Draw expression too large');
|
||||
}
|
||||
static i32(value: number): DrawExpression<'i32'> { return new DrawExpression('i32', [ExprOp.I32, ...varint(value)]); }
|
||||
static f32(value: number): DrawExpression<'f32'> {
|
||||
if (!Number.isFinite(Math.fround(value))) throw new Error('Invalid draw float');
|
||||
const bytes = new Uint8Array(4); new DataView(bytes.buffer).setFloat32(0, value, true);
|
||||
return new DrawExpression('f32', [ExprOp.F32, ...bytes]);
|
||||
}
|
||||
/** Time already elapsed on this list's timeline when the next PRESENT happens. */
|
||||
static elapsed(): DrawExpression<'i32'> { return new DrawExpression('i32', [ExprOp.ELAPSED]); }
|
||||
/** A 0..1 timeline fraction that survives subsequent PRESENT clock resets. */
|
||||
static progress(durationMs: number): DrawExpression<'f32'> {
|
||||
const duration = DrawExpression.i32(integer(durationMs, 1, 2147483647));
|
||||
const elapsed = DrawExpression.elapsed().min(duration);
|
||||
return duration.sub(elapsed).max(DrawExpression.i32(0)).time()
|
||||
.add(elapsed).toFloat().div(duration.toFloat());
|
||||
}
|
||||
static decode(code: Uint8Array): DrawExpression<'i32'> { return new DrawExpression('i32', Array.from(code)); }
|
||||
private binary(other: DrawExpression<T>, i: number, f: number): DrawExpression<T> {
|
||||
if (other.type !== this.type) throw new Error('Draw expression type mismatch');
|
||||
return new DrawExpression(this.type, [...this.code, ...other.code, this.type === 'i32' ? i : f]);
|
||||
}
|
||||
add(b: DrawExpression<T>): DrawExpression<T> { return this.binary(b, ExprOp.IADD, ExprOp.FADD); }
|
||||
sub(b: DrawExpression<T>): DrawExpression<T> { return this.binary(b, ExprOp.ISUB, ExprOp.FSUB); }
|
||||
mul(b: DrawExpression<T>): DrawExpression<T> { return this.binary(b, ExprOp.IMUL, ExprOp.FMUL); }
|
||||
div(b: DrawExpression<T>): DrawExpression<T> { return this.binary(b, ExprOp.IDIV, ExprOp.FDIV); }
|
||||
min(b: DrawExpression<T>): DrawExpression<T> { return this.binary(b, ExprOp.IMIN, ExprOp.FMIN); }
|
||||
max(b: DrawExpression<T>): DrawExpression<T> { return this.binary(b, ExprOp.IMAX, ExprOp.FMAX); }
|
||||
mod(this: DrawExpression<'i32'>, b: DrawExpression<'i32'>): DrawExpression<'i32'> { return this.binary(b, ExprOp.IMOD, ExprOp.IMOD); }
|
||||
neg(): DrawExpression<T> { return new DrawExpression(this.type, [...this.code, this.type === 'i32' ? ExprOp.INEG : ExprOp.FNEG]); }
|
||||
toFloat(this: DrawExpression<'i32'>): DrawExpression<'f32'> { return new DrawExpression('f32', [...this.code, ExprOp.I2F]); }
|
||||
toInt(this: DrawExpression<'f32'>): DrawExpression<'i32'> { return new DrawExpression('i32', [...this.code, ExprOp.F2I]); }
|
||||
time(this: DrawExpression<'i32'>): DrawExpression<'i32'> { return new DrawExpression('i32', [...this.code, ExprOp.TIME]); }
|
||||
ease(this: DrawExpression<'f32'>, op: number = ExprOp.SMOOTHSTEP): DrawExpression<'f32'> {
|
||||
integer(op, ExprOp.SMOOTHSTEP, ExprOp.EASE_IN_OUT_CUBIC);
|
||||
return new DrawExpression('f32', [...this.code, op]);
|
||||
}
|
||||
lerp(this: DrawExpression<'f32'>, from: DrawExpression<'f32'>, to: DrawExpression<'f32'>): DrawExpression<'f32'> {
|
||||
return new DrawExpression('f32', [...from.code, ...to.code, ...this.code, ExprOp.LERP]);
|
||||
}
|
||||
}
|
||||
export type DrawValue = number | DrawExpression<'i32'>;
|
||||
export function encodeValue(value: DrawValue): number[] {
|
||||
return typeof value === 'number' ? varint(value) : [255, ...varint(value.code.length, false), ...value.code];
|
||||
}
|
||||
export function readValue(reader: DrawBytes): DrawValue {
|
||||
if (reader.bytes[reader.offset] !== 255) return reader.variable();
|
||||
reader.u8(); return DrawExpression.decode(reader.take(reader.variable(false)));
|
||||
}
|
||||
|
||||
/** Software preview of the same VM; invalid programs return zero and discard pending animation. */
|
||||
export function evaluate(value: DrawValue, elapsed: number, presentTime = 0): { value: number; pending: boolean } {
|
||||
if (typeof value === 'number') return { value, pending: false };
|
||||
const reader = new DrawBytes(Uint8Array.from(value.code)), stack: { value: number; float: boolean }[] = [];
|
||||
let pending = false;
|
||||
const push = (value: number, float = false) => {
|
||||
value = float ? Math.fround(value) : value | 0;
|
||||
if (!Number.isFinite(value) || stack.length === 32) throw new Error('Invalid expression stack');
|
||||
stack.push({ value, float });
|
||||
};
|
||||
const pop = (float: boolean) => { const v = stack.pop(); if (!v || v.float !== float) throw new Error('Expression type mismatch'); return v.value; };
|
||||
const toInt = (v: number) => { if (v < -2147483648 || v >= 2147483648) throw new Error('Invalid integer conversion'); return Math.trunc(v); };
|
||||
try {
|
||||
while (reader.offset < reader.bytes.length) {
|
||||
const op = reader.u8();
|
||||
if (op === ExprOp.I32) push(reader.variable());
|
||||
else if (op === ExprOp.F32) { const b = reader.take(4); push(new DataView(b.buffer).getFloat32(0, true), true); }
|
||||
else if (op === ExprOp.ELAPSED) push(Math.min(2147483647, Math.max(0, elapsed)));
|
||||
else if (op === ExprOp.I2F) push(pop(false), true);
|
||||
else if (op === ExprOp.F2I) push(toInt(pop(true)));
|
||||
else if (op === ExprOp.TIME) { const max = pop(false); if (max < 0) throw new Error('Invalid time'); const t = Math.min(Math.max(0, presentTime), max); pending ||= t !== max; push(t); }
|
||||
else if (op === ExprOp.INEG || op === ExprOp.FNEG) push(-pop(op === ExprOp.FNEG), op === ExprOp.FNEG);
|
||||
else if (op >= ExprOp.IADD && op <= ExprOp.IMAX || op >= ExprOp.FADD && op <= ExprOp.FMAX) {
|
||||
const float = op >= ExprOp.FADD, b = pop(float), a = pop(float);
|
||||
const key = float ? op - ExprOp.FADD : op - ExprOp.IADD;
|
||||
if ((key === 3 || !float && key === 4) && b === 0) throw new Error('Division by zero');
|
||||
const result = key === 0 ? a + b : key === 1 ? a - b : key === 2 ? float ? a * b : Math.imul(a, b) : key === 3 ? a / b : !float && key === 4 ? a % b : key === (float ? 5 : 6) ? Math.min(a, b) : Math.max(a, b);
|
||||
push(result, float);
|
||||
} else if (op === ExprOp.LERP) { const t = pop(true), b = pop(true), a = pop(true); push(a + Math.fround(Math.fround(b - a) * t), true); }
|
||||
else if (op >= ExprOp.SMOOTHSTEP && op <= ExprOp.EASE_IN_OUT_CUBIC) {
|
||||
const t = Math.max(0, Math.min(1, pop(true))), u = Math.fround(1 - t), f = Math.fround;
|
||||
let result: number;
|
||||
switch (op) {
|
||||
case ExprOp.SMOOTHSTEP: result = f(t * t) * f(3 - f(2 * t)); break;
|
||||
case ExprOp.EASE_IN_QUAD: result = t * t; break;
|
||||
case ExprOp.EASE_OUT_QUAD: result = 1 - f(u * u); break;
|
||||
case ExprOp.EASE_IN_OUT_QUAD: result = t < .5 ? f(2 * t) * t : 1 - f(f(2 * u) * u); break;
|
||||
case ExprOp.EASE_IN_CUBIC: result = f(t * t) * t; break;
|
||||
case ExprOp.EASE_OUT_CUBIC: result = 1 - f(f(u * u) * u); break;
|
||||
default: result = t < .5 ? f(f(4 * t) * t) * t : 1 - f(f(f(4 * u) * u) * u);
|
||||
}
|
||||
push(result, true);
|
||||
} else if (op === ExprOp.DUP) { const a = stack[stack.length - 1]; if (!a) throw new Error('Underflow'); push(a.value, a.float); }
|
||||
else if (op === ExprOp.DROP) { if (!stack.pop()) throw new Error('Underflow'); }
|
||||
else if (op === ExprOp.SWAP) { if (stack.length < 2) throw new Error('Underflow'); const a = stack.pop()!, b = stack.pop()!; stack.push(a, b); }
|
||||
else throw new Error('Unknown expression opcode');
|
||||
}
|
||||
const top = stack.pop(); if (!top) throw new Error('Empty expression');
|
||||
return { value: top.float ? toInt(top.value) : top.value, pending };
|
||||
} catch { return { value: 0, pending: false }; }
|
||||
}
|
||||
@@ -159,6 +159,7 @@ export function prepareFrameDraws(draws: readonly DeferredDraw[]): ArrayBuffer |
|
||||
// Pass 1: resolve ids, register unseen rasters, size the buffer.
|
||||
let registration: Map<FontWireState, RegistrationGroup> | null = null;
|
||||
const fwRunOk = new Map<PlacedFwText, boolean>();
|
||||
const presentations = new Map<PlacedImage, Uint8Array>();
|
||||
let bytes = 0;
|
||||
for (const placed of draws) {
|
||||
if (placed.kind === "glyph") {
|
||||
@@ -177,7 +178,7 @@ export function prepareFrameDraws(draws: readonly DeferredDraw[]): ArrayBuffer |
|
||||
(placed.glyph.coverage ? group.aaGlyphs : group.glyphs).push(placed.glyph);
|
||||
} else if (placed.kind === "image") {
|
||||
if (!inRange16(placed.x) || !inRange16(placed.y)) continue;
|
||||
if (placed.presentation) bytes += encodePresentation(placed).length;
|
||||
if (placed.presentation) { const record = encodePresentation(placed); presentations.set(placed, record); bytes += record.length; }
|
||||
else if (imageId(placed) !== null) bytes += IMAGE_RECORD_BYTES;
|
||||
} else {
|
||||
const ok = prepareFwTextRun(placed);
|
||||
@@ -210,7 +211,7 @@ export function prepareFrameDraws(draws: readonly DeferredDraw[]): ArrayBuffer |
|
||||
offset += GLYPH_RECORD_BYTES;
|
||||
} else if (placed.kind === "image") {
|
||||
if (!inRange16(placed.x) || !inRange16(placed.y)) continue;
|
||||
if (placed.presentation) { const bytes = encodePresentation(placed); new Uint8Array(out.buffer).set(bytes, offset); offset += bytes.length; continue; }
|
||||
if (placed.presentation) { const bytes = presentations.get(placed)!; new Uint8Array(out.buffer).set(bytes, offset); offset += bytes.length; continue; }
|
||||
const id = imageId(placed);
|
||||
if (id === null) continue;
|
||||
out.setUint8(offset, DrawRecordKind.TEXTURE_IMAGE);
|
||||
|
||||
+21
-5
@@ -1,3 +1,5 @@
|
||||
import { menuSelectionList } from "./menu-selection-list";
|
||||
import { encodeDisplayList, dimDisplayList, paintDisplayList, type DisplayList } from "./display-list";
|
||||
import type { MenuHighlightAnimation } from "../ui/menu-highlight-motion";
|
||||
import { Glyph } from "./bdffont";
|
||||
import { wrapText } from "./textwrap";
|
||||
@@ -74,7 +76,7 @@ export type PlacedGlyph = {
|
||||
* from the moment it is placed.
|
||||
*/
|
||||
export type PlacedImage = {
|
||||
presentation?: { animation?: MenuHighlightAnimation; mode?: "image" | "masked-image"; radius: number; background: number; border: number; depth: number; occlusions?: readonly { x: number; y: number; width: number; height: number }[] };
|
||||
presentation?: { displayList?: DisplayList; mode?: "image" | "masked-image"; radius: number; background: number; border: number; depth: number; occlusions?: readonly { x: number; y: number; width: number; height: number }[] };
|
||||
kind: "image";
|
||||
source: GrayImage;
|
||||
x: number;
|
||||
@@ -395,7 +397,9 @@ export class GrayImage {
|
||||
hash = mixInt(hash, placed.source.width);
|
||||
hash = mixInt(hash, placed.source.height);
|
||||
hash = mixInt(hash, placed.source.sourceContentHash32());
|
||||
if (placed.presentation) { const p = placed.presentation; for (const value of [p.radius, p.background, p.border, p.depth, p.mode === "image" ? 1 : p.mode === "masked-image" ? 2 : 0, p.animation?.token ?? 0, p.animation?.dx ?? 0, p.animation?.dy ?? 0, p.animation?.durationMs ?? 0]) hash = mixInt(hash, value); }
|
||||
if (placed.presentation) { const p = placed.presentation; for (const value of [p.radius, p.background, p.border, p.depth, p.mode === "image" ? 1 : p.mode === "masked-image" ? 2 : 0]) hash = mixInt(hash, value);
|
||||
if (p.displayList) for (const byte of encodeDisplayList({ displayList: p.displayList, x: 0, y: 0, width: placed.source.width, height: placed.source.height, depth: p.depth }, p.displayList.timeline?.startedAt ?? 0)) hash = mixInt(hash, byte);
|
||||
}
|
||||
} else {
|
||||
hash = mixInt(hash, 0xf17e);
|
||||
hash = mixInt(hash, placed.font.atlasTag);
|
||||
@@ -508,8 +512,15 @@ export class GrayImage {
|
||||
|
||||
/** Retain the selected row separately from the menu surface for glasses-side composition. */
|
||||
drawMenuSelection(source: GrayImage, x: number, y: number, background: number, border: number, radius = 8, depth = 2, animation?: MenuHighlightAnimation): void {
|
||||
this.drawList.push({ kind: "image", source: source.withDrawsBaked(), x, y,
|
||||
presentation: { radius, background, border, depth, animation } });
|
||||
const baked = source.withDrawsBaked();
|
||||
this.drawList.push({ kind: "image", source: baked, x, y,
|
||||
presentation: { radius, background, border, depth, displayList: menuSelectionList(baked, background, border, radius, animation) } });
|
||||
}
|
||||
|
||||
/** Submit a retained list alongside this frame; coordinates are relative to x/y. */
|
||||
drawDisplayList(displayList: DisplayList, x: number, y: number, width: number, height: number, depth = 0): void {
|
||||
this.drawList.push({ kind: "image", source: new GrayImage(width, height), x, y,
|
||||
presentation: { radius: 0, background: 0, border: 0, depth, displayList } });
|
||||
}
|
||||
|
||||
/** Replay an image at stereo depth. Masked images preserve intentional gray8 black (1). */
|
||||
@@ -570,7 +581,7 @@ export class GrayImage {
|
||||
for (const placed of this.drawList) {
|
||||
if (placed.kind === "image" && placed.presentation) {
|
||||
const p = placed.presentation;
|
||||
copy.drawList.push({ ...placed, source: placed.source.dimmed(factor), presentation: { ...p, background: dimValue(p.background, scale), border: dimValue(p.border, scale) } });
|
||||
copy.drawList.push({ ...placed, source: placed.source.dimmed(factor), presentation: { ...p, background: dimValue(p.background, scale), border: dimValue(p.border, scale), displayList: p.displayList && dimDisplayList(p.displayList, factor) } });
|
||||
} else if (placed.kind !== "image") {
|
||||
copy.drawList.push({ ...placed, value: dimValue(placed.value, scale) });
|
||||
}
|
||||
@@ -613,6 +624,11 @@ export class GrayImage {
|
||||
} else if (placed.kind === "image") {
|
||||
if (placed.presentation) {
|
||||
if (!presentations) continue;
|
||||
if (placed.presentation.displayList) {
|
||||
paintDisplayList(target.pixels, target.pixels.slice(), target.width, target.height,
|
||||
{ displayList: placed.presentation.displayList, x: placed.x + dx, y: placed.y + dy, width: placed.source.width, height: placed.source.height, depth: placed.presentation.depth });
|
||||
continue;
|
||||
}
|
||||
if (placed.presentation.mode) {
|
||||
target.bitBlt(placed.source, placed.x + dx, placed.y + dy, { transparentZero: true });
|
||||
continue;
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
import type { MenuHighlightAnimation } from '../ui/menu-highlight-motion';
|
||||
import { DrawExpression as E } from './draw-expression';
|
||||
import { DrawOp, type DisplayList, type ListImage } from './display-list';
|
||||
|
||||
/** Menu policy and easing live in TypeScript; the bridge carries only generic calls/expressions. */
|
||||
export function menuSelectionList(image: ListImage, background: number, border: number, radius: number, animation?: MenuHighlightAnimation): DisplayList {
|
||||
const coordinate = (delta: number) => {
|
||||
if (!animation || !delta) return 0;
|
||||
const progress = E.progress(animation.durationMs).ease();
|
||||
return progress.lerp(E.i32(delta).toFloat(), E.f32(0)).toInt();
|
||||
};
|
||||
const q = (n: number) => Math.min(15, (n + 8) >> 4);
|
||||
return { resources: [image], timeline: animation,
|
||||
calls: [
|
||||
{ op: DrawOp.ROUNDED_RECT, x: coordinate(animation?.dx ?? 0), y: coordinate(animation?.dy ?? 0), width: image.width, height: image.height, radius, background: q(background), border: q(border) },
|
||||
{ op: DrawOp.IMAGE, resource: 0, x: 0, y: 0, transparent: true },
|
||||
] };
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
import type { PlacedImage } from './image'
|
||||
import type { MenuHighlightAnimation } from '../ui/menu-highlight-motion'
|
||||
import { DISPLAY_LIST_RECORD, DrawOp, SCREEN, encodeDisplayList, readDisplayList, paintDisplayList, type DisplayList } from './display-list'
|
||||
|
||||
/** TS/native bridge tags, not firmware draw opcodes. Keep in sync with DrawRecordKind.kt. */
|
||||
export const DrawRecordKind = {
|
||||
@@ -9,38 +9,36 @@ export const DrawRecordKind = {
|
||||
MENU_SELECTION: 3,
|
||||
TRANSPARENT_IMAGE: 4,
|
||||
MASKED_IMAGE: 5,
|
||||
ANIMATED_MENU_SELECTION: 6,
|
||||
DISPLAY_LIST: DISPLAY_LIST_RECORD,
|
||||
} as const
|
||||
|
||||
export function isPresentationKind(kind: number | undefined): boolean {
|
||||
return kind === DrawRecordKind.MENU_SELECTION || kind === DrawRecordKind.TRANSPARENT_IMAGE ||
|
||||
kind === DrawRecordKind.MASKED_IMAGE || kind === DrawRecordKind.ANIMATED_MENU_SELECTION
|
||||
kind === DrawRecordKind.MASKED_IMAGE || kind === DrawRecordKind.DISPLAY_LIST
|
||||
}
|
||||
|
||||
/** Presentation record: tag, signed xy, u16 wh/radius, gray fill/stroke, signed depth, restore-count, optional animation, gray pixels, restore rectangles. */
|
||||
/** Presentation record: tag, signed xy, u16 wh/radius, gray fill/stroke, signed depth, restore-count, gray pixels, restore rectangles. */
|
||||
export function encodePresentation(draw: PlacedImage): Uint8Array {
|
||||
const p = draw.presentation!
|
||||
const { width, height, pixels } = draw.source
|
||||
if (width < 1 || height < 1 || width > 640 || height > 480 || 5 + Math.ceil(width / 2) * height > 65536) throw new Error('Presentation image exceeds the resource size limit')
|
||||
if (width < 1 || height < 1 || width > 640 || height > 480 || !p.displayList && 5 + Math.ceil(width / 2) * height > 65536) throw new Error('Presentation image exceeds the resource size limit')
|
||||
if (!Number.isInteger(p.depth) || p.depth < -128 || p.depth > 127) throw new Error('Invalid menu depth')
|
||||
if ((p.occlusions?.length ?? 0) > 2048) throw new Error('Too many menu occlusion rectangles')
|
||||
const animation = p.animation;
|
||||
if (animation && (!Number.isInteger(animation.durationMs) || animation.durationMs < 1 || animation.durationMs > 65535)) throw new Error('Invalid menu animation duration')
|
||||
const header = animation ? 28 : 16;
|
||||
if (p.displayList) {
|
||||
const calls = [...p.displayList.calls, ...(p.occlusions ?? []).map(r => ({
|
||||
op: DrawOp.RECT_COPY, resource: SCREEN, x: r.x - draw.x, y: r.y - draw.y,
|
||||
width: r.width, height: r.height, dx: r.x - draw.x, dy: r.y - draw.y, depth: -p.depth,
|
||||
}))];
|
||||
return encodeDisplayList({ displayList: { ...p.displayList, calls }, x: draw.x, y: draw.y, width, height, depth: p.depth });
|
||||
}
|
||||
const header = 16;
|
||||
const bytes = new Uint8Array(header + width * height + (p.occlusions?.length ?? 0) * 8), view = new DataView(bytes.buffer)
|
||||
bytes[0] = animation ? DrawRecordKind.ANIMATED_MENU_SELECTION
|
||||
: p.mode === "image" ? DrawRecordKind.TRANSPARENT_IMAGE
|
||||
bytes[0] = p.mode === "image" ? DrawRecordKind.TRANSPARENT_IMAGE
|
||||
: p.mode === "masked-image" ? DrawRecordKind.MASKED_IMAGE : DrawRecordKind.MENU_SELECTION
|
||||
view.setInt16(1, draw.x, true); view.setInt16(3, draw.y, true)
|
||||
view.setUint16(5, width, true); view.setUint16(7, height, true); view.setUint16(9, p.radius, true)
|
||||
bytes[11] = p.background; bytes[12] = p.border; view.setInt8(13, p.depth)
|
||||
view.setUint16(14, p.occlusions?.length ?? 0, true)
|
||||
if (animation) {
|
||||
view.setInt16(16, animation.dx, true); view.setInt16(18, animation.dy, true);
|
||||
view.setUint16(20, Math.max(0, Math.min(animation.durationMs, Date.now() - animation.startedAt)), true);
|
||||
view.setUint32(22, animation.token, true);
|
||||
view.setUint16(26, animation.durationMs, true);
|
||||
}
|
||||
bytes.set(pixels, header)
|
||||
let offset = header + pixels.length
|
||||
for (const rect of p.occlusions ?? []) {
|
||||
@@ -50,20 +48,18 @@ export function encodePresentation(draw: PlacedImage): Uint8Array {
|
||||
return bytes
|
||||
}
|
||||
|
||||
export type Selection = { animation?: MenuHighlightAnimation; mode?: "image" | "masked-image"; x: number; y: number; width: number; height: number; radius: number; background: number; border: number; depth: number; pixels: Uint8Array; occlusions: { x: number; y: number; width: number; height: number }[] }
|
||||
export type Selection = { displayList?: DisplayList; mode?: "image" | "masked-image"; x: number; y: number; width: number; height: number; radius: number; background: number; border: number; depth: number; pixels: Uint8Array; occlusions: { x: number; y: number; width: number; height: number }[] }
|
||||
export function readPresentation(bytes: Uint8Array, offset: number): { selection: Selection; end: number } {
|
||||
if (bytes[offset] === DrawRecordKind.DISPLAY_LIST) {
|
||||
const { placed, end } = readDisplayList(bytes, offset);
|
||||
return { selection: { ...placed, radius: 0, background: 0, border: 0, pixels: new Uint8Array(0), occlusions: [] }, end };
|
||||
}
|
||||
const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), w = v.getUint16(offset + 5, true), h = v.getUint16(offset + 7, true)
|
||||
const kind = bytes[offset]
|
||||
const header = kind === DrawRecordKind.ANIMATED_MENU_SELECTION ? 28 : 16
|
||||
const header = 16
|
||||
const selection: Selection = { mode: kind === DrawRecordKind.TRANSPARENT_IMAGE ? "image" : kind === DrawRecordKind.MASKED_IMAGE ? "masked-image" : undefined, x: v.getInt16(offset+1,true), y: v.getInt16(offset+3,true), width:w, height:h,
|
||||
radius:v.getUint16(offset+9,true), background:bytes[offset+11]!, border:bytes[offset+12]!, depth:v.getInt8(offset+13),
|
||||
pixels:bytes.slice(offset+header,offset+header+w*h), occlusions:[] }
|
||||
if (kind === DrawRecordKind.ANIMATED_MENU_SELECTION) {
|
||||
const durationMs = v.getUint16(offset+26,true), elapsed = v.getUint16(offset+20,true)
|
||||
if (!durationMs || elapsed > durationMs) throw new Error('Invalid menu animation timing')
|
||||
selection.animation = { dx:v.getInt16(offset+16,true), dy:v.getInt16(offset+18,true),
|
||||
startedAt:Date.now()-elapsed, token:v.getUint32(offset+22,true), durationMs }
|
||||
}
|
||||
let end=offset+header+w*h
|
||||
for(let i=0;i<v.getUint16(offset+14,true);i++) { selection.occlusions.push({x:v.getUint16(end,true),y:v.getUint16(end+2,true),width:v.getUint16(end+4,true),height:v.getUint16(end+6,true)});end+=8 }
|
||||
return {selection,end}
|
||||
@@ -81,6 +77,7 @@ export function presentationRecords(buffer: ArrayBuffer | null): Selection[] {
|
||||
return result
|
||||
}
|
||||
export function paintPresentation(output: Uint8Array, screen: Uint8Array, width: number, height: number, row: Selection, right = false): void {
|
||||
if (row.displayList) { paintDisplayList(output, screen, width, height, { ...row, displayList: row.displayList }, right); return; }
|
||||
const q=(n:number)=>Math.min(15,(n+8)>>4), shift=right?-Math.floor((row.depth+1)/2):Math.floor(row.depth/2)
|
||||
const inside=(x:number,y:number,w:number,h:number,r:number)=>{
|
||||
if(x<0||y<0||x>=w||y>=h) return false
|
||||
@@ -88,10 +85,7 @@ export function paintPresentation(output: Uint8Array, screen: Uint8Array, width:
|
||||
const dx=Math.max(0,2*r-(2*Math.min(x,w-1-x)+1)),dy=Math.max(0,2*r-(2*Math.min(y,h-1-y)+1))
|
||||
return dx*dx+dy*dy<=4*r*r
|
||||
}
|
||||
const t = row.animation ? Math.max(0, Math.min(1, (Date.now() - row.animation.startedAt) / row.animation.durationMs)) : 1
|
||||
const remaining = 1 - t * t * (3 - 2 * t)
|
||||
const highlightX = Math.trunc(row.x + (row.animation?.dx ?? 0) * remaining)
|
||||
const highlightY = Math.trunc(row.y + (row.animation?.dy ?? 0) * remaining)
|
||||
const highlightX = row.x, highlightY = row.y
|
||||
if (!row.mode) for(let yy=0;yy<row.height;yy++) for(let xx=0;xx<row.width;xx++) {
|
||||
const x=highlightX+xx+shift,y=highlightY+yy
|
||||
if(x<0||y<0||x>=width||y>=height || !inside(xx,yy,row.width,row.height,row.radius)) continue
|
||||
|
||||
@@ -93,7 +93,7 @@ export class SurfaceCompositor {
|
||||
if(x+xx+shift>=0 && y+yy>=0 && x+xx+shift<this.width && y+yy<this.height) output[(y+yy)*this.width+x+xx+shift]=quantize(bytes[p+yy*w+xx])*16
|
||||
}
|
||||
p+=w*h
|
||||
for(let j=0;j<selections;j++) { const record=readPresentation(bytes,p);p=record.end;if(record.selection.animation) record.selection.animation.startedAt -= Date.now()-this.shellReceivedAt;paintPresentation(output,screen,this.width,this.height,record.selection) }
|
||||
for(let j=0;j<selections;j++) { const record=readPresentation(bytes,p);p=record.end;if(record.selection.displayList?.timeline) record.selection.displayList = { ...record.selection.displayList, presentedAt: this.shellReceivedAt, timeline: { ...record.selection.displayList.timeline, startedAt: record.selection.displayList.timeline.startedAt - (Date.now()-this.shellReceivedAt) } };paintPresentation(output,screen,this.width,this.height,record.selection) }
|
||||
}
|
||||
}
|
||||
return output
|
||||
|
||||
+1
-1
@@ -25,7 +25,7 @@ class ScenePlanner(private val cache: ResourceCacheState) {
|
||||
CachedResource(DrawProtocol.rawImage(layer.width, layer.height), keys[i])
|
||||
} }
|
||||
owned.keys.retainAll(keys.toSet()); pixels.keys.retainAll(keys.toSet())
|
||||
val selectedResources = scene.allSelections.map { it.resource }
|
||||
val selectedResources = scene.retainedResources
|
||||
cache.pin(surfaces + selectedResources)
|
||||
val absent = surfaces.map { cache.resourceId(it) < 0 }
|
||||
val prepared = cache.prepare(surfaces + selectedResources)
|
||||
|
||||
+2
-2
@@ -8,10 +8,10 @@ object DrawRecordKind {
|
||||
const val MENU_SELECTION = 3
|
||||
const val TRANSPARENT_IMAGE = 4
|
||||
const val MASKED_IMAGE = 5
|
||||
const val ANIMATED_MENU_SELECTION = 6
|
||||
const val DISPLAY_LIST = 7
|
||||
|
||||
fun isPresentation(kind: Int): Boolean = when (kind) {
|
||||
MENU_SELECTION, TRANSPARENT_IMAGE, MASKED_IMAGE, ANIMATED_MENU_SELECTION -> true
|
||||
MENU_SELECTION, TRANSPARENT_IMAGE, MASKED_IMAGE, DISPLAY_LIST -> true
|
||||
else -> false
|
||||
}
|
||||
}
|
||||
+133
@@ -0,0 +1,133 @@
|
||||
package com.faceclaw.app
|
||||
|
||||
/** A retained draw submitted with frame pixels, before cache IDs have been assigned. */
|
||||
interface RetainedDrawing {
|
||||
val resources: List<CachedResource>
|
||||
val fingerprint: String
|
||||
fun translated(dx: Int, dy: Int): RetainedDrawing
|
||||
fun calls(ids: IntArray, nowMs: Long): List<ByteArray>
|
||||
}
|
||||
|
||||
internal fun readRetainedDrawing(reader: ByteReader, kind: Int): RetainedDrawing =
|
||||
if (kind == DrawRecordKind.DISPLAY_LIST) FrameDisplayList.read(reader) else MenuSelection.read(reader, kind)
|
||||
|
||||
/** Generic TS-authored calls. No menu or easing policy lives in this bridge. */
|
||||
class FrameDisplayList private constructor(
|
||||
private val x: Int, private val y: Int, private val depth: Int,
|
||||
override val resources: List<CachedResource>, private val commands: List<Command>,
|
||||
internal val startedAt: Long, private val identity: String,
|
||||
) : RetainedDrawing {
|
||||
override val fingerprint: String get() = "$x,$y,$depth,$identity"
|
||||
override fun translated(dx: Int, dy: Int) = FrameDisplayList(x + dx, y + dy, depth, resources, commands, startedAt, identity)
|
||||
|
||||
private class Command(val op: Int, val depth: Int, val values: IntArray,
|
||||
val x: DrawValue = DrawValue.Integer(0), val y: DrawValue = DrawValue.Integer(0))
|
||||
|
||||
override fun calls(ids: IntArray, nowMs: Long): List<ByteArray> {
|
||||
require(ids.size == resources.size)
|
||||
val elapsed = (nowMs - startedAt).coerceIn(0, Int.MAX_VALUE.toLong()).toInt()
|
||||
fun resource(index: Int) = if (index == DrawProtocol.SCREEN) index else ids[index]
|
||||
return commands.map { c ->
|
||||
val v = c.values
|
||||
when (c.op) {
|
||||
DRAW_OP_ROUNDED_RECT -> DrawProtocol.roundedRect(bind(c.x, elapsed, x), bind(c.y, elapsed, y),
|
||||
v[0], v[1], v[2], v[3], v[4], depth + c.depth)
|
||||
DRAW_OP_IMAGE -> DrawProtocol.image(resource(v[0]), x + v[1], y + v[2], v[3], depth = depth + c.depth)
|
||||
DRAW_OP_RECT_COPY -> DrawProtocol.rectCopy(resource(v[0]),
|
||||
v[1] + if (v[0] == DrawProtocol.SCREEN) x else 0,
|
||||
v[2] + if (v[0] == DrawProtocol.SCREEN) y else 0,
|
||||
v[3], v[4], x + v[5], y + v[6], depth = depth + c.depth)
|
||||
else -> error("Unsupported frame display-list opcode")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
// Bridge-only constant binding, removed before a program reaches either renderer.
|
||||
private const val ELAPSED = 128
|
||||
private const val MAX_RECORD_BYTES = 4 * 1024 * 1024
|
||||
|
||||
private fun bind(value: DrawValue, elapsed: Int, offset: Int): DrawValue {
|
||||
if (value is DrawValue.Integer) return DrawValue.Integer(value.value + offset)
|
||||
val reader = DrawReader((value as DrawValue.Expression).program)
|
||||
val out = ByteSink()
|
||||
while (reader.remaining > 0) {
|
||||
when (val op = reader.readU8()) {
|
||||
ELAPSED -> { out.write(DrawExpression.PUSH_I32); out.write(ExtendedVarint.signed(elapsed)) }
|
||||
DrawExpression.PUSH_I32 -> { out.write(op); out.write(ExtendedVarint.signed(ExtendedVarint.read(reader, true))) }
|
||||
DrawExpression.PUSH_F32 -> { out.write(op); out.write(reader.readBytes(4)) }
|
||||
else -> out.write(op)
|
||||
}
|
||||
}
|
||||
if (offset != 0) {
|
||||
out.write(DrawExpression.PUSH_I32); out.write(ExtendedVarint.signed(offset)); out.write(DrawExpression.IADD)
|
||||
}
|
||||
val program = out.toByteArray()
|
||||
require(program.size <= DrawExpression.MAX_BYTES)
|
||||
return DrawValue.Expression(program)
|
||||
}
|
||||
|
||||
fun read(input: ByteReader, nowMs: Long = drawAnimationTimeMs()): FrameDisplayList {
|
||||
val length = input.getInt()
|
||||
require(length in 21..MAX_RECORD_BYTES && length <= input.remaining())
|
||||
val bytes = ByteArray(length).also { input.get(it) }
|
||||
val r = DrawReader(bytes)
|
||||
val x = r.readS16(); val y = r.readS16()
|
||||
val width = r.readU16(); val height = r.readU16()
|
||||
require(width in 1..640 && height in 1..480)
|
||||
val depth = r.readS8()
|
||||
r.readBytes(4) // Stable timeline token is included in the identity below.
|
||||
val elapsed = r.readU16() or (r.readU16() shl 16)
|
||||
require(elapsed >= 0)
|
||||
val resourceCount = r.readU16(); require(resourceCount <= 256)
|
||||
val resources = List(resourceCount) {
|
||||
val w = r.readU16(); val h = r.readU16()
|
||||
require(w in 1..640 && h in 1..480 && 5 + (w + 1) / 2 * h <= 65536)
|
||||
val gray = r.readBytes(w * h)
|
||||
CachedResource(DrawProtocol.rawImage(w, h, BmpUtil.pack4bppFromGray8(gray, w, h)))
|
||||
}
|
||||
fun value(): DrawValue {
|
||||
val first = r.readU8()
|
||||
if (first != 255) return DrawValue.Integer(ExtendedVarint.read(r, true, first))
|
||||
val size = ExtendedVarint.read(r, false).toUInt()
|
||||
require(size <= 900u)
|
||||
return DrawValue.Expression(r.readBytes(size.toInt())).also {
|
||||
// Validate framing and worst-case binding growth before retaining the frame.
|
||||
bind(it, Int.MAX_VALUE, Int.MAX_VALUE)
|
||||
}
|
||||
}
|
||||
fun resource(): Int = r.readU16().also { require(it == DrawProtocol.SCREEN || it in resources.indices) }
|
||||
val count = r.readU16(); require(count <= 4096)
|
||||
val calls = List(count) {
|
||||
val op = r.readU8(); val d = r.readS16(); require(depth + d in -128..127)
|
||||
when (op) {
|
||||
DRAW_OP_ROUNDED_RECT -> {
|
||||
val xx = value(); val yy = value()
|
||||
val w = r.readU16(); val h = r.readU16(); val radius = r.readU16()
|
||||
val background = r.readU8(); val border = r.readU8()
|
||||
require(w in 1..640 && h in 1..480 && background in 0..15 && border in 0..16)
|
||||
Command(op, d, intArrayOf(w, h, radius, background, border), xx, yy)
|
||||
}
|
||||
DRAW_OP_IMAGE -> {
|
||||
val id = resource(); require(id != DrawProtocol.SCREEN)
|
||||
val xx = r.readS16(); val yy = r.readS16(); val options = r.readU8()
|
||||
require(options == 15 || options == 31)
|
||||
Command(op, d, intArrayOf(id, xx, yy, options))
|
||||
}
|
||||
DRAW_OP_RECT_COPY -> {
|
||||
val id = resource(); val sx = r.readS16(); val sy = r.readS16()
|
||||
val w = r.readU16(); val h = r.readU16(); val dx = r.readS16(); val dy = r.readS16()
|
||||
require(w in 1..640 && h in 1..480)
|
||||
require(id == DrawProtocol.SCREEN || sx >= 0 && sy >= 0)
|
||||
Command(op, d, intArrayOf(id, sx, sy, w, h, dx, dy))
|
||||
}
|
||||
else -> error("Unsupported frame display-list opcode")
|
||||
}
|
||||
}
|
||||
r.requireDone()
|
||||
// Elapsed changes while the same timeline is resubmitted; it is not content identity.
|
||||
bytes.fill(0, 13, 17)
|
||||
return FrameDisplayList(x, y, depth, resources, calls, nowMs - elapsed, CachedResource(bytes).hash.toString())
|
||||
}
|
||||
}
|
||||
}
|
||||
+9
-22
@@ -2,17 +2,15 @@ package com.faceclaw.app
|
||||
|
||||
/** A retained selection or image, replayed at stereo depth over the screen and shell surfaces. */
|
||||
class MenuSelection(val x: Int, val y: Int, val width: Int, val height: Int, val radius: Int,
|
||||
val background: Int, val border: Int, val depth: Int, val packed: ByteArray, val occlusions: List<IntArray> = emptyList(), val kind: Int = DrawRecordKind.MENU_SELECTION, val mask: List<IntArray> = emptyList(), val animation: Animation? = null) {
|
||||
class Animation(val dx: Int, val dy: Int, val startedAt: Long, val token: Int, val durationMs: Int)
|
||||
val background: Int, val border: Int, val depth: Int, val packed: ByteArray, val occlusions: List<IntArray> = emptyList(), val kind: Int = DrawRecordKind.MENU_SELECTION, val mask: List<IntArray> = emptyList()) : RetainedDrawing {
|
||||
val resource = CachedResource(DrawProtocol.rawImage(width, height, packed))
|
||||
val fingerprint = "${animation?.token},${animation?.dx},${animation?.dy},${animation?.durationMs},$kind,${mask.joinToString { it.joinToString() }},$x,$y,$width,$height,$radius,$background,$border,$depth,${resource.hash},${occlusions.joinToString { it.joinToString() }}"
|
||||
fun translated(dx: Int, dy: Int) = MenuSelection(x + dx, y + dy, width, height, radius, background, border, depth, packed, occlusions.map { intArrayOf(it[0] + dx, it[1] + dy, it[2], it[3]) }, kind, mask, animation)
|
||||
fun calls(id: Int, nowMs: Long = drawAnimationTimeMs()): List<ByteArray> {
|
||||
val elapsed = animation?.let { (nowMs - it.startedAt).coerceIn(0, it.durationMs.toLong()).toInt() } ?: 0
|
||||
val highlightX = animation?.let { DrawValue.animate(x + it.dx, x, it.durationMs, elapsed) } ?: DrawValue.Integer(x)
|
||||
val highlightY = animation?.let { DrawValue.animate(y + it.dy, y, it.durationMs, elapsed) } ?: DrawValue.Integer(y)
|
||||
override val resources = listOf(resource)
|
||||
override val fingerprint = "$kind,${mask.joinToString { it.joinToString() }},$x,$y,$width,$height,$radius,$background,$border,$depth,${resource.hash},${occlusions.joinToString { it.joinToString() }}"
|
||||
override fun translated(dx: Int, dy: Int) = MenuSelection(x + dx, y + dy, width, height, radius, background, border, depth, packed, occlusions.map { intArrayOf(it[0] + dx, it[1] + dy, it[2], it[3]) }, kind, mask)
|
||||
override fun calls(ids: IntArray, nowMs: Long) = calls(ids.single())
|
||||
fun calls(id: Int): List<ByteArray> {
|
||||
val image = when (kind) {
|
||||
DrawRecordKind.MENU_SELECTION -> listOf(DrawProtocol.roundedRect(highlightX, highlightY, width, height, radius, background, border, depth),
|
||||
DrawRecordKind.MENU_SELECTION -> listOf(DrawProtocol.roundedRect(x, y, width, height, radius, background, border, depth),
|
||||
DrawProtocol.image(id, x, y, CFW_TEXTURE_OPT_BRIGHTNESS_MASK or CFW_TEXTURE_OPT_TRANSPARENT, depth = depth))
|
||||
DrawRecordKind.TRANSPARENT_IMAGE -> listOf(DrawProtocol.image(id, x, y, CFW_TEXTURE_OPT_BRIGHTNESS_MASK or CFW_TEXTURE_OPT_TRANSPARENT, depth = depth))
|
||||
// Gray8 zero is transparent but gray8 one is opaque black. Rect copies preserve
|
||||
@@ -31,7 +29,7 @@ class MenuSelection(val x: Int, val y: Int, val width: Int, val height: Int, val
|
||||
companion object {
|
||||
/** The caller has consumed a presentation tag from [DrawRecordKind]. Colors and pixels cross in gray8. */
|
||||
fun read(reader: ByteReader, kind: Int = DrawRecordKind.MENU_SELECTION): MenuSelection {
|
||||
require(DrawRecordKind.isPresentation(kind))
|
||||
require(kind in listOf(DrawRecordKind.MENU_SELECTION, DrawRecordKind.TRANSPARENT_IMAGE, DrawRecordKind.MASKED_IMAGE))
|
||||
require(reader.remaining() >= 15)
|
||||
val x = reader.getShort().toInt(); val y = reader.getShort().toInt()
|
||||
val w = reader.getShort().toInt() and 65535; val h = reader.getShort().toInt() and 65535
|
||||
@@ -42,16 +40,6 @@ class MenuSelection(val x: Int, val y: Int, val width: Int, val height: Int, val
|
||||
val count = reader.getShort().toInt() and 65535
|
||||
require(count <= 2048)
|
||||
require(w in 1..640 && h in 1..480 && 5 + (w + 1) / 2 * h <= 65536 && reader.remaining() >= w * h)
|
||||
val animation = if (kind == DrawRecordKind.ANIMATED_MENU_SELECTION) {
|
||||
require(reader.remaining() >= 12)
|
||||
val dx = reader.getShort().toInt()
|
||||
val dy = reader.getShort().toInt()
|
||||
val elapsed = reader.getShort().toInt() and 65535
|
||||
val token = reader.getInt()
|
||||
val duration = reader.getShort().toInt() and 65535
|
||||
require(duration > 0 && elapsed <= duration)
|
||||
Animation(dx, dy, drawAnimationTimeMs() - elapsed, token, duration)
|
||||
} else null
|
||||
val gray = ByteArray(w * h); reader.get(gray)
|
||||
require(reader.remaining() >= count * 8)
|
||||
val occlusions = List(count) { IntArray(4) { reader.getShort().toInt() and 65535 } }
|
||||
@@ -68,8 +56,7 @@ class MenuSelection(val x: Int, val y: Int, val width: Int, val height: Int, val
|
||||
}
|
||||
}
|
||||
}
|
||||
val normalizedKind = if (kind == DrawRecordKind.ANIMATED_MENU_SELECTION) DrawRecordKind.MENU_SELECTION else kind
|
||||
return MenuSelection(x, y, w, h, radius, background, border, depth, BmpUtil.pack4bppFromGray8(gray, w, h), occlusions, normalizedKind, mask, animation)
|
||||
return MenuSelection(x, y, w, h, radius, background, border, depth, BmpUtil.pack4bppFromGray8(gray, w, h), occlusions, kind, mask)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,18 +1,24 @@
|
||||
package com.faceclaw.app
|
||||
|
||||
/** Immutable shell snapshot. Keys identify writable surfaces across repaints, not their pixels. */
|
||||
class ShellScene(val layers: List<Layer>, val selections: List<MenuSelection> = emptyList()) {
|
||||
class Layer(val key: Int, val x: Int, val y: Int, val width: Int, val height: Int, val dim: Int, val packed: ByteArray, val selections: List<MenuSelection> = emptyList(), val depth: Int = 0)
|
||||
class ShellScene(val layers: List<Layer>, val selections: List<RetainedDrawing> = emptyList()) {
|
||||
class Layer(val key: Int, val x: Int, val y: Int, val width: Int, val height: Int, val dim: Int, val packed: ByteArray, val selections: List<RetainedDrawing> = emptyList(), val depth: Int = 0)
|
||||
val allSelections = selections + layers.flatMap { it.selections }
|
||||
val retainedResources = allSelections.flatMap { it.resources }
|
||||
init { require(retainedResources.size + layers.size < 511) }
|
||||
val fingerprint: String = layers.joinToString(";") { "${it.key},${it.x},${it.y},${it.width},${it.height},${it.dim},${it.depth},${CachedResource(it.packed).hash},${it.selections.joinToString { row -> row.fingerprint }}" } + selections.joinToString { it.fingerprint }
|
||||
fun calls(width: Int, height: Int, surfaces: IntArray, selected: IntArray): List<ByteArray> {
|
||||
val calls = ArrayList<ByteArray>(); var rowId = 0
|
||||
val now = drawAnimationTimeMs()
|
||||
for (row in selections) calls.addAll(row.calls(selected[rowId++], now))
|
||||
fun add(row: RetainedDrawing) {
|
||||
calls.addAll(row.calls(selected.copyOfRange(rowId, rowId + row.resources.size), now))
|
||||
rowId += row.resources.size
|
||||
}
|
||||
for (row in selections) add(row)
|
||||
for ((index, layer) in layers.withIndex()) {
|
||||
if (layer.dim < 256) calls.add(DrawProtocol.lut(width, height, layer.dim))
|
||||
calls.add(DrawProtocol.image(surfaces[index], layer.x, layer.y, depth = layer.depth))
|
||||
for (row in layer.selections) calls.addAll(row.calls(selected[rowId++], now))
|
||||
for (row in layer.selections) add(row)
|
||||
}
|
||||
return calls
|
||||
}
|
||||
@@ -22,7 +28,7 @@ class ShellScene(val layers: List<Layer>, val selections: List<MenuSelection> =
|
||||
val surfaces = IntArray(layers.size) { id ->
|
||||
val layer = layers[id]; resources[id] = DrawProtocol.rawImage(layer.width, layer.height, layer.packed); id
|
||||
}
|
||||
val rows = IntArray(allSelections.size) { id -> resources[id + layers.size] = allSelections[id].resource.bytes; id + layers.size }
|
||||
val rows = IntArray(retainedResources.size) { id -> resources[id + layers.size] = retainedResources[id].bytes; id + layers.size }
|
||||
resources[511] = DrawProtocol.displayList(calls(width, height, surfaces, rows))
|
||||
DisplayListRenderer(resources, rightLens = rightLens).render(511, DisplayListRenderer.Target(screen, width, height), DisplayListRenderer.Target(output, width, height))
|
||||
val target = DisplayListRenderer.Target(output, width, height)
|
||||
@@ -42,8 +48,8 @@ class ShellScene(val layers: List<Layer>, val selections: List<MenuSelection> =
|
||||
resources[id] = DrawProtocol.rawImage(layer.width, layer.height, layer.packed)
|
||||
id
|
||||
}
|
||||
val rows = IntArray(allSelections.size) { id ->
|
||||
resources[id + layers.size] = allSelections[id].resource.bytes
|
||||
val rows = IntArray(retainedResources.size) { id ->
|
||||
resources[id + layers.size] = retainedResources[id].bytes
|
||||
id + layers.size
|
||||
}
|
||||
resources[511] = DrawProtocol.displayList(calls(width, height, surfaces, rows))
|
||||
@@ -73,11 +79,11 @@ class ShellScene(val layers: List<Layer>, val selections: List<MenuSelection> =
|
||||
val depth = reader.getShort().toInt(); require(depth in -128..127)
|
||||
require(w in 1..640 && h in 1..480 && 5 + (w + 1) / 2 * h <= 65536 && reader.remaining() >= w * h)
|
||||
val gray = ByteArray(w * h); reader.get(gray)
|
||||
val selections = List(selectionCount) { MenuSelection.read(reader, reader.get().toInt()) }
|
||||
val selections = List(selectionCount) { readRetainedDrawing(reader, reader.get().toInt()) }
|
||||
layers.add(Layer(key, x, y, w, h, dim, BmpUtil.pack4bppFromGray8(gray, w, h), selections, depth))
|
||||
}
|
||||
require(reader.remaining() == 0)
|
||||
require(layers.sumOf { it.selections.size } + layers.size < 511)
|
||||
require(layers.sumOf { layer -> layer.selections.sumOf { it.resources.size } } + layers.size < 511)
|
||||
require(layers.map { it.key }.toSet().size == layers.size)
|
||||
return ShellScene(layers)
|
||||
}
|
||||
|
||||
+3
-3
@@ -51,7 +51,7 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
|
||||
var out: MutableList<ScreenDraw> = ArrayList()
|
||||
while ((cursor.remaining() >= 1)) {
|
||||
var kind: Int = (cursor.get() and 0xff)
|
||||
if (DrawRecordKind.isPresentation(kind)) { out.add(ScreenDraw.image(0, 0, 0).also { it.selection = MenuSelection.read(cursor, kind) }); continue }
|
||||
if (DrawRecordKind.isPresentation(kind)) { out.add(ScreenDraw.image(0, 0, 0).also { it.selection = readRetainedDrawing(cursor, kind) }); continue }
|
||||
if (((kind == ScreenDraw.KIND_GLYPH) && (cursor.remaining() >= 11))) {
|
||||
var fontId: Int = (cursor.getShort().toInt() and 0xffff)
|
||||
var encoding: Int = cursor.getInt()
|
||||
@@ -108,7 +108,7 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
|
||||
* raster comes from ImageAtlas under imageId.
|
||||
*/
|
||||
class ScreenDraw {
|
||||
@JvmField var selection: MenuSelection? = null
|
||||
@JvmField var selection: RetainedDrawing? = null
|
||||
companion object {
|
||||
const val KIND_GLYPH: Int = DrawRecordKind.GLYPH
|
||||
|
||||
@@ -631,7 +631,7 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
|
||||
var fingerprint: StringBuilder = StringBuilder()
|
||||
fingerprint.append(screenWidth).append('x').append(screenHeight)
|
||||
var draws: MutableList<ScreenDraw> = ArrayList()
|
||||
val selections = ArrayList<MenuSelection>()
|
||||
val selections = ArrayList<RetainedDrawing>()
|
||||
for (surface in ordered) {
|
||||
if (!surface.visible || (shellScene != null && surface.id == "shell")) {
|
||||
continue
|
||||
|
||||
@@ -355,7 +355,7 @@ function chatLayerEnv() {
|
||||
const env = conversations();
|
||||
const textwrap = load('app/graphics/textwrap.ts', {});
|
||||
const { BdfFont } = load('app/graphics/bdffont.ts', { '@nativescript/core': {} });
|
||||
const graphics = load('app/graphics/image.ts', { './textwrap': textwrap });
|
||||
const graphics = require('../.test-build/app/graphics/image.js');
|
||||
const font = BdfFont.parse(fs.readFileSync(path.join(__dirname, '../app/fonts/terminus/ter-u12n.bdf'), 'utf8'));
|
||||
let windowOptions;
|
||||
const { createAiChatWindow } = load('app/apps/ai-chat/ai-chat-app.ts', {
|
||||
|
||||
@@ -15,7 +15,7 @@ function load(file, modules = {}) {
|
||||
}
|
||||
|
||||
const textwrap = load('app/graphics/textwrap.ts');
|
||||
const graphics = load('app/graphics/image.ts', { './textwrap': textwrap });
|
||||
const graphics = require('../.test-build/app/graphics/image.js');
|
||||
const plane = load('app/graphics/plane.ts', { './image': graphics });
|
||||
const gestures = load('app/ui/gestures.ts');
|
||||
const numeric = load('app/util/numeric-util.ts');
|
||||
|
||||
@@ -17,7 +17,7 @@ function load(file, modules = {}, globals = {}) {
|
||||
return context.exports;
|
||||
}
|
||||
const textwrap = load('app/graphics/textwrap.ts');
|
||||
const graphics = load('app/graphics/image.ts', { './textwrap': textwrap });
|
||||
const graphics = require('../.test-build/app/graphics/image.js');
|
||||
const { BdfFont } = load('app/graphics/bdffont.ts', { '@nativescript/core': {} });
|
||||
const font = (size) => BdfFont.parse(fs.readFileSync(path.join(__dirname, `../app/fonts/terminus/ter-u${size}n.bdf`), 'utf8'));
|
||||
const small = font(18), large = font(32);
|
||||
|
||||
@@ -19,7 +19,7 @@ function load(file, modules = {}, extra = '', globals = {}) {
|
||||
|
||||
const textwrap = load('app/graphics/textwrap.ts');
|
||||
const { BdfFont } = load('app/graphics/bdffont.ts', { '@nativescript/core': {} });
|
||||
const graphics = load('app/graphics/image.ts', { './textwrap': textwrap });
|
||||
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'));
|
||||
@@ -156,7 +156,7 @@ test('the background registers once and uses a nine-byte image reference on late
|
||||
return 1;
|
||||
} } } } },
|
||||
});
|
||||
const { prepareFrameDraws } = load('app/graphics/glyph-wire.ts', { '../native/texture-atlas': atlas, './presentation-wire': load('app/graphics/presentation-wire.ts') });
|
||||
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();
|
||||
|
||||
@@ -0,0 +1,83 @@
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const { DrawExpression: E, ExprOp, varint, DrawBytes, evaluate } = require('../.test-build/app/graphics/draw-expression.js');
|
||||
const { DrawOp, SCREEN, encodeDisplayList, readDisplayList, paintDisplayList } = require('../.test-build/app/graphics/display-list.js');
|
||||
const { GrayImage } = require('../.test-build/app/graphics/image.js');
|
||||
const { encodePresentation } = require('../.test-build/app/graphics/presentation-wire.js');
|
||||
// Also consumed by FrameDisplayListTest.kt: bridge bytes, not independently rebuilt native calls.
|
||||
const MENU = '077e0000000300020002000200022a00000096000000010002000200ffffffff0200080000ff24017e30020000000001812c8001812c1611010017328001812c16103001812c3023414031ff24017c30020000000001812c8001812c1611010017328001812c16103001812c302341403102000200010001030400000000000000001f';
|
||||
const MULTI = '074c000000030002000400010002000000000000000002000200010000ff010001006003000400000000000000001f020000010000000000010001000200000002feffffffffff000001000100ffff0000';
|
||||
|
||||
test('extended integers agree with firmware widths and sign extension', () => {
|
||||
const vectors = [[63,'3f'],[-64,'40'],[64,'8040'],[-65,'bfbf'],[8191,'9fff'],[-8192,'a000'],[8192,'c02000'],[-8193,'dfdfff'],[1048575,'cfffff'],[-1048576,'d00000'],[1048576,'e0100000'],[-1048577,'efefffff'],[134217727,'e7ffffff'],[-134217728,'e8000000'],[134217728,'f008000000'],[2147483647,'f07fffffff'],[-2147483648,'f080000000']];
|
||||
for (const [value, hex] of vectors) {
|
||||
assert.equal(Buffer.from(varint(value)).toString('hex'), hex);
|
||||
assert.equal(new DrawBytes(Buffer.from(hex, 'hex')).variable(), value);
|
||||
}
|
||||
for (const n of [0,127,128,16383,16384,2097151,2097152,268435455,268435456,4294967295]) assert.equal(new DrawBytes(Uint8Array.from(varint(n,false))).variable(false), n);
|
||||
assert.throws(() => E.i32(2147483648));
|
||||
assert.throws(() => E.f32(Infinity));
|
||||
});
|
||||
|
||||
test('typed expressions follow i32/f32 arithmetic, easing, time and error semantics', () => {
|
||||
assert.equal(evaluate(E.i32(2147483647).add(E.i32(1)),0).value, -2147483648);
|
||||
assert.equal(evaluate(E.i32(7).neg().div(E.i32(2)),0).value, -3);
|
||||
assert.equal(evaluate(E.i32(-2147483648).div(E.i32(-1)),0).value, -2147483648);
|
||||
assert.equal(evaluate(E.f32(1.5).mul(E.f32(2)).toInt(),0).value, 3);
|
||||
for (let op = ExprOp.SMOOTHSTEP; op <= ExprOp.EASE_IN_OUT_CUBIC; op++) {
|
||||
assert.equal(evaluate(E.f32(0).ease(op),0).value, 0);
|
||||
assert.equal(evaluate(E.f32(1).ease(op),0).value, 1);
|
||||
}
|
||||
assert.deepEqual(evaluate(E.i32(300).time(),0,150), {value:150,pending:true});
|
||||
assert.deepEqual(evaluate(E.i32(300).time(),0,300), {value:300,pending:false});
|
||||
assert.deepEqual(evaluate(E.i32(300).time().div(E.i32(0)),0,150), {value:0,pending:false});
|
||||
assert.deepEqual(evaluate(E.decode(Uint8Array.of(ExprOp.IADD)),0), {value:0,pending:false});
|
||||
});
|
||||
|
||||
test('menu authors the golden generic list and stable timeline identity', () => {
|
||||
const original = Date.now; Date.now = () => 1150;
|
||||
try {
|
||||
const image = new GrayImage(8,4);
|
||||
image.drawMenuSelection(new GrayImage(2,2,255),3,2,16,48,1,2,{dx:-2,dy:-4,startedAt:1000,token:42,durationMs:300});
|
||||
assert.equal(Buffer.from(encodePresentation(image.draws[0])).toString('hex'), MENU);
|
||||
const before = image.fingerprint(); Date.now = () => 1250;
|
||||
assert.equal(image.fingerprint(), before, 'wall time does not change frame identity');
|
||||
const decoded = readDisplayList(Buffer.from(MENU,'hex'),0,1150).placed;
|
||||
const y = decoded.displayList.calls[0].y;
|
||||
assert.deepEqual(evaluate(y,150,0), {value:-2,pending:true});
|
||||
assert.deepEqual(evaluate(y,150,150), {value:0,pending:false});
|
||||
assert.deepEqual(evaluate(y,300,0), {value:0,pending:false});
|
||||
} finally { Date.now = original; }
|
||||
});
|
||||
|
||||
test('local resources, relative placement, stereo and screen restoration round-trip', () => {
|
||||
const list = { resources:[{width:2,height:1,pixels:Uint8Array.of(0,255)},{width:1,height:1,pixels:Uint8Array.of(96)}], calls:[
|
||||
{op:DrawOp.IMAGE,resource:0,x:0,y:0,transparent:true},
|
||||
{op:DrawOp.RECT_COPY,resource:1,x:0,y:0,width:1,height:1,dx:2,dy:0},
|
||||
{op:DrawOp.RECT_COPY,resource:SCREEN,x:-1,y:0,width:1,height:1,dx:-1,dy:0,depth:-2},
|
||||
] };
|
||||
const bytes = encodeDisplayList({displayList:list,x:3,y:2,width:4,height:1,depth:2});
|
||||
assert.equal(Buffer.from(bytes).toString('hex'), MULTI);
|
||||
const {placed,end} = readDisplayList(bytes,0);
|
||||
assert.equal(end,bytes.length);
|
||||
for (const right of [false,true]) {
|
||||
const screen = new Uint8Array(64).fill(32), output = screen.slice();
|
||||
paintDisplayList(output,screen,8,8,placed,right);
|
||||
assert.equal(output[2*8+(right?3:5)],240);
|
||||
assert.equal(output[2*8+(right?4:6)],96);
|
||||
assert.equal(output[2*8+2],32);
|
||||
}
|
||||
for (let i=0;i<bytes.length;i++) assert.throws(() => readDisplayList(bytes.slice(0,i),0));
|
||||
const invalid = {...list, calls:[{op:DrawOp.IMAGE,resource:2,x:0,y:0,transparent:true}]};
|
||||
assert.throws(() => encodeDisplayList({displayList:invalid,x:0,y:0,width:4,height:1,depth:0}));
|
||||
});
|
||||
|
||||
test('frame submission supports resource-free lists and plain PRESENT-relative time', () => {
|
||||
const image = new GrayImage(8,8);
|
||||
image.drawDisplayList({resources:[],calls:[{op:DrawOp.ROUNDED_RECT,x:E.i32(4).time(),y:0,width:2,height:2,radius:0,background:15,border:16}]},0,0,8,8);
|
||||
const bytes = encodePresentation(image.draws[0]);
|
||||
const {placed} = readDisplayList(bytes,0,1000);
|
||||
const output = new Uint8Array(64), screen = output.slice();
|
||||
paintDisplayList(output,screen,8,8,placed,false,1002);
|
||||
assert.equal(output[2],240); assert.equal(output[0],0);
|
||||
});
|
||||
@@ -83,7 +83,7 @@ test('bounded history preserves equal-time events, snapshots and arrival gaps; p
|
||||
|
||||
test('Input events captures while visible, pauses for history, and unsubscribes on removal', () => {
|
||||
const textwrap = load('app/graphics/textwrap.ts');
|
||||
const graphics = load('app/graphics/image.ts', { './textwrap': textwrap });
|
||||
const graphics = require('../.test-build/app/graphics/image.js');
|
||||
const { BdfFont } = load('app/graphics/bdffont.ts', { '@nativescript/core': {} });
|
||||
const font = BdfFont.parse(read('app/fonts/terminus/ter-u18n.bdf'));
|
||||
class RecordingImage extends graphics.GrayImage {
|
||||
|
||||
@@ -72,48 +72,6 @@ class DrawExpressionTest {
|
||||
assertEquals(110 to false, evaluate(continued.program, 250))
|
||||
}
|
||||
|
||||
@Test fun animatedMenuBridgePreservesElapsedTimeAndTranslation() {
|
||||
// Tag 6 record emitted by the TypeScript bridge: elapsed=200, delta=(-2,-4), duration=300.
|
||||
val wire = hex("06030002000200020001001030020000fefffcffc8002a0000002c01ffffffff")
|
||||
val input = ArrayByteReader(wire)
|
||||
assertEquals(6, input.get().toInt())
|
||||
val row = MenuSelection.read(input, DrawRecordKind.ANIMATED_MENU_SELECTION).translated(10, 10)
|
||||
assertEquals(0, input.remaining())
|
||||
val motion = assertNotNull(row.animation)
|
||||
assertEquals(42, motion.token)
|
||||
assertEquals(300, motion.durationMs)
|
||||
assertEquals(-2, motion.dx)
|
||||
assertEquals(-4, motion.dy)
|
||||
val call = row.calls(7, motion.startedAt + 200).first()
|
||||
for ((elapsed, expected) in listOf(0L to (12 to 10), 100L to (13 to 12))) {
|
||||
val reader = DrawReader(call)
|
||||
assertEquals(8, reader.readU8())
|
||||
assertEquals(DRAW_FLAG_DEPTH, reader.readU8())
|
||||
assertEquals(2, reader.readS8())
|
||||
val frame = DrawEvaluation(elapsed)
|
||||
assertEquals(expected.first, ExtendedVarint.evaluate(reader, frame))
|
||||
assertEquals(expected.second, ExtendedVarint.evaluate(reader, frame))
|
||||
assertEquals(elapsed < 100, frame.animationPending)
|
||||
}
|
||||
for (end in 1 until wire.size) assertFails {
|
||||
MenuSelection.read(ArrayByteReader(wire.copyOf(end), 1), DrawRecordKind.ANIMATED_MENU_SELECTION)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun menuCoordinatesUseTheSuppliedDuration() {
|
||||
val row = MenuSelection(0, 4, 2, 2, 0, 15, 16, 0, ByteArray(2),
|
||||
animation = MenuSelection.Animation(0, -4, 1000, 42, 120))
|
||||
val call = row.calls(7, 1000).first()
|
||||
for ((elapsed, y) in listOf(0L to 0, 60L to 2, 120L to 4)) {
|
||||
val reader = DrawReader(call)
|
||||
reader.readBytes(3) // opcode, flags, depth
|
||||
val frame = DrawEvaluation(elapsed)
|
||||
assertEquals(0, ExtendedVarint.evaluate(reader, frame))
|
||||
assertEquals(y, ExtendedVarint.evaluate(reader, frame))
|
||||
assertEquals(elapsed < 120, frame.animationPending)
|
||||
}
|
||||
}
|
||||
|
||||
@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))))
|
||||
|
||||
@@ -0,0 +1,90 @@
|
||||
package com.faceclaw.app
|
||||
|
||||
import kotlin.test.*
|
||||
|
||||
class FrameDisplayListTest {
|
||||
// Golden records emitted by display-list-authoring.test.cjs.
|
||||
private val menu = "077e0000000300020002000200022a00000096000000010002000200ffffffff0200080000ff24017e30020000000001812c8001812c1611010017328001812c16103001812c3023414031ff24017c30020000000001812c8001812c1611010017328001812c16103001812c302341403102000200010001030400000000000000001f"
|
||||
private val multi = "074c000000030002000400010002000000000000000002000200010000ff010001006003000400000000000000001f020000010000000000010001000200000002feffffffffff000001000100ffff0000"
|
||||
private fun hex(s: String) = s.chunked(2).map { it.toInt(16).toByte() }.toByteArray()
|
||||
private fun read(bytes: ByteArray, now: Long = 1150): FrameDisplayList {
|
||||
val reader = ArrayByteReader(bytes)
|
||||
assertEquals(DrawRecordKind.DISPLAY_LIST, reader.get().toInt())
|
||||
return FrameDisplayList.read(reader, now).also { assertEquals(0, reader.remaining()) }
|
||||
}
|
||||
|
||||
@Test fun authoredExpressionsRebindOnPresentAndTranslateWithTheSurface() {
|
||||
val row = read(hex(menu)).translated(10, 10)
|
||||
assertEquals(1, row.resources.size)
|
||||
fun coordinates(now: Long, elapsed: Long): Triple<Int, Int, Boolean> {
|
||||
val call = DrawReader(row.calls(intArrayOf(7), now).first())
|
||||
assertEquals(DRAW_OP_ROUNDED_RECT, call.readU8())
|
||||
assertEquals(DRAW_FLAG_DEPTH, call.readU8())
|
||||
assertEquals(2, call.readS8())
|
||||
val frame = DrawEvaluation(elapsed)
|
||||
val x = ExtendedVarint.evaluate(call, frame)
|
||||
val y = ExtendedVarint.evaluate(call, frame)
|
||||
return Triple(x, y, frame.animationPending)
|
||||
}
|
||||
assertEquals(Triple(12, 10, true), coordinates(1150, 0))
|
||||
assertEquals(Triple(13, 12, false), coordinates(1150, 150))
|
||||
assertEquals(coordinates(1150, 75), coordinates(1225, 0), "another PRESENT preserves progress")
|
||||
assertEquals(Triple(13, 12, false), coordinates(1400, 0))
|
||||
val later = hex(menu).also { it[18] = 200.toByte() } // envelope 5 + elapsed offset 13
|
||||
assertEquals(read(hex(menu)).fingerprint, read(later).fingerprint)
|
||||
val other = hex(menu).also { it[14] = 43 } // timeline token
|
||||
assertNotEquals(read(hex(menu)).fingerprint, read(other).fingerprint)
|
||||
}
|
||||
|
||||
@Test fun localResourceIdsAreResolvedAndScreenCopiesStayAtScreenDepth() {
|
||||
val list = read(hex(multi)).translated(10, 10)
|
||||
val calls = list.calls(intArrayOf(41, 42), 1150)
|
||||
assertContentEquals(DrawProtocol.image(41, 13, 12, 31, depth = 2), calls[0])
|
||||
assertContentEquals(DrawProtocol.rectCopy(42, 0, 0, 1, 1, 15, 12, depth = 2), calls[1])
|
||||
assertContentEquals(DrawProtocol.rectCopy(DrawProtocol.SCREEN, 12, 12, 1, 1, 12, 12, depth = 0), calls[2])
|
||||
val scene = ShellScene(emptyList(), listOf(read(hex(multi))))
|
||||
assertEquals(2, scene.retainedResources.size)
|
||||
for (right in listOf(false, true)) {
|
||||
val pixels = scene.preview(ByteArray(64) { 32 }, 8, 8, right)
|
||||
assertEquals(240, pixels[16 + if (right) 3 else 5].toInt() and 255)
|
||||
assertEquals(96, pixels[16 + if (right) 4 else 6].toInt() and 255)
|
||||
assertEquals(32, pixels[18].toInt() and 255)
|
||||
}
|
||||
val cache = ResourceCacheState()
|
||||
val planner = ScenePlanner(cache)
|
||||
val screen = ByteArray(32) { 0x22 }
|
||||
planner.plan(screen, 8, 8, null, scene, 1)
|
||||
val ids = scene.retainedResources.map { cache.resourceId(it) }
|
||||
assertTrue(ids.all { it >= 0 }); assertNotEquals(ids[0], ids[1])
|
||||
planner.plan(screen, 8, 8, null, scene, 1)
|
||||
assertEquals(ids, scene.retainedResources.map { cache.resourceId(it) })
|
||||
}
|
||||
|
||||
@Test fun frameAndShellSubmissionUseTheSameGenericDecoder() {
|
||||
val c = SurfaceCompositor()
|
||||
c.configureScreen(8, 8)
|
||||
c.configureSurface("app", 0, 0, 8, 8, 0, 0)
|
||||
c.submitSurface("app", ArrayByteReader(ByteArray(64) { 32 }), 0, 0, 8, 8, "list",
|
||||
ArrayByteReader(hex(multi)))
|
||||
val frame = c.composite()
|
||||
assertEquals(2, frame.shellScene.retainedResources.size)
|
||||
assertEquals(240, frame.gray[21].toInt() and 255)
|
||||
assertTrue(frame.screenGray.all { it.toInt() == 32 })
|
||||
// One opaque 1x1 shell layer, with one generic list after its pixels.
|
||||
val layer = DrawProtocol.word(1) + DrawProtocol.word(1) + DrawProtocol.word(0) + DrawProtocol.word(0) +
|
||||
DrawProtocol.word(1) + DrawProtocol.word(1) + DrawProtocol.word(256) + DrawProtocol.word(1) +
|
||||
DrawProtocol.word(0) + byteArrayOf(32) + hex(multi)
|
||||
val shell = ShellScene.decode(ArrayByteReader(layer))
|
||||
assertEquals(2, shell.retainedResources.size)
|
||||
assertEquals(240, shell.preview(ByteArray(64) { 32 }, 8, 8)[21].toInt() and 255)
|
||||
}
|
||||
|
||||
@Test fun rejectsTruncationBadResourcesAndTrailingData() {
|
||||
val bytes = hex(multi)
|
||||
for (end in 1 until bytes.size) assertFails { read(bytes.copyOf(end)) }
|
||||
assertFails { read(bytes.copyOf().also { it[40] = 9 }) } // first image's local resource
|
||||
val trailing = bytes + byteArrayOf(0)
|
||||
trailing[1] = (trailing[1] + 1).toByte()
|
||||
assertFails { read(trailing) }
|
||||
}
|
||||
}
|
||||
@@ -48,7 +48,7 @@ test('shell menu selection survives serialization and is not baked into its surf
|
||||
test('later opaque planes occlude a replayed selection without erasing its visible part',()=>{
|
||||
const image=menu().paint(),row=image.draws.find(d=>d.presentation),cover=new graphics.GrayImage(10,8,1);
|
||||
const flat=planes.flattenPlanesWithDraws([{image,x:0,y:0},{image:cover,x:row.x+10,y:row.y+2}]);
|
||||
const records=wire.presentationRecords(prepareFrameDraws(flat.draws));assert.ok(records[0].occlusions.length);
|
||||
const records=wire.presentationRecords(prepareFrameDraws(flat.draws));assert.ok(records[0].displayList.calls.some(c => c.op === 2 && c.resource === 65535));
|
||||
const c=new SurfaceCompositor(80,80);c.configureSurface('app',{x:0,y:0,width:80,height:80,zOrder:0,transparency:'opaque'});
|
||||
c.submitSurfaceFrame('app',flat.image.pixels,{x:0,y:0,width:80,height:80},prepareFrameDraws(flat.draws));
|
||||
const preview=c.composite();
|
||||
|
||||
@@ -35,7 +35,7 @@ test('bridge and fallback preview use the supplied animation duration', () => {
|
||||
image.drawMenuSelection(new GrayImage(2, 2), 5, 0, 0, 255, 0, 0,
|
||||
{ dx: -4, dy: 0, startedAt: 1000, token: 1, durationMs: 100 });
|
||||
const record = readPresentation(encodePresentation(image.draws[0]), 0);
|
||||
assert.equal(record.selection.animation.durationMs, 100);
|
||||
assert.ok(record.selection.displayList);
|
||||
const screen = new Uint8Array(16), output = new Uint8Array(16);
|
||||
paintPresentation(output, screen, 8, 2, record.selection);
|
||||
assert.equal(output[3], 240, 'halfway at 50 ms');
|
||||
@@ -56,11 +56,11 @@ test('animated selection bridge carries relative start, elapsed time and stable
|
||||
image.drawMenuSelection(new GrayImage(2, 2, 255), 3, 2, 16, 48, 1, 2,
|
||||
{ dx: -2, dy: -4, startedAt: 1000, token: 42, durationMs: MENU_HIGHLIGHT_DURATION_MS });
|
||||
const bytes = encodePresentation(image.draws[0]);
|
||||
assert.equal(bytes[0], 6);
|
||||
assert.equal(bytes.length, 32);
|
||||
assert.equal(bytes[0], 7);
|
||||
const record = readPresentation(bytes, 0);
|
||||
assert.equal(record.end, bytes.length);
|
||||
assert.deepEqual(record.selection.animation, { dx: -2, dy: -4, startedAt: 1000, token: 42, durationMs: MENU_HIGHLIGHT_DURATION_MS });
|
||||
assert.deepEqual(record.selection.displayList.timeline, { startedAt: 1000, token: 42 });
|
||||
assert.equal(record.selection.displayList.calls[0].op, 8);
|
||||
assert.equal(record.selection.x, 3);
|
||||
assert.equal(record.selection.y, 2);
|
||||
} finally { Date.now = now; }
|
||||
|
||||
@@ -137,7 +137,7 @@ test('Music settings keeps toggles and selection when a new app arrives and supp
|
||||
const { prefs } = store();
|
||||
let refreshes = 0, closes = 0;
|
||||
const textwrap = load('app/graphics/textwrap.ts');
|
||||
const graphics = load('app/graphics/image.ts', () => textwrap);
|
||||
const graphics = require('../.test-build/app/graphics/image.js');
|
||||
const { BdfFont } = load('app/graphics/bdffont.ts', () => ({}));
|
||||
const font = BdfFont.parse(source('app/fonts/terminus/ter-u20n.bdf'));
|
||||
class RecordingImage extends graphics.GrayImage {
|
||||
|
||||
@@ -53,7 +53,7 @@ function ui(fontSize = 12) {
|
||||
let dismissals = 0;
|
||||
let closes = 0;
|
||||
const textwrap = load('app/graphics/textwrap.ts');
|
||||
const graphics = load('app/graphics/image.ts', () => textwrap);
|
||||
const graphics = require('../.test-build/app/graphics/image.js');
|
||||
const { BdfFont } = load('app/graphics/bdffont.ts', () => ({}));
|
||||
const font = BdfFont.parse(source(`app/fonts/terminus/ter-u${fontSize}n.bdf`));
|
||||
class RecordingImage extends graphics.GrayImage {
|
||||
|
||||
Reference in new issue
Block a user