spine-rigc 0.2.1

package/tools/font5x7.ts

@@ -0,0 +1,101 @@
+/**
+ * A 5x7 bitmap font, uppercase + digits + a little punctuation.
+ *
+ * It exists so a generated plate can burn its own name into its own pixels with
+ * no font file, no canvas and no dependency. That matters more than it sounds:
+ * the whole point of a synthetic stand-in plate is that nobody can mistake it
+ * for real art, and the strongest form of that is the word PLACEHOLDER sitting
+ * in the image itself.
+ *
+ * Each glyph is 7 rows of 5 bits, MSB = leftmost column.
+ */
+const GLYPHS: Record<string, number[]> = {
+  A: [0x0e, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11],
+  B: [0x1e, 0x11, 0x11, 0x1e, 0x11, 0x11, 0x1e],
+  C: [0x0e, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0e],
+  D: [0x1e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x1e],
+  E: [0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x1f],
+  F: [0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x10],
+  G: [0x0e, 0x11, 0x10, 0x17, 0x11, 0x11, 0x0e],
+  H: [0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11],
+  I: [0x0e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e],
+  J: [0x07, 0x02, 0x02, 0x02, 0x02, 0x12, 0x0c],
+  K: [0x11, 0x12, 0x14, 0x18, 0x14, 0x12, 0x11],
+  L: [0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1f],
+  M: [0x11, 0x1b, 0x15, 0x15, 0x11, 0x11, 0x11],
+  N: [0x11, 0x19, 0x19, 0x15, 0x13, 0x13, 0x11],
+  O: [0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e],
+  P: [0x1e, 0x11, 0x11, 0x1e, 0x10, 0x10, 0x10],
+  Q: [0x0e, 0x11, 0x11, 0x11, 0x15, 0x13, 0x0d],
+  R: [0x1e, 0x11, 0x11, 0x1e, 0x14, 0x12, 0x11],
+  S: [0x0f, 0x10, 0x10, 0x0e, 0x01, 0x01, 0x1e],
+  T: [0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04],
+  U: [0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e],
+  V: [0x11, 0x11, 0x11, 0x11, 0x11, 0x0a, 0x04],
+  W: [0x11, 0x11, 0x11, 0x15, 0x15, 0x1b, 0x11],
+  X: [0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11],
+  Y: [0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04],
+  Z: [0x1f, 0x01, 0x02, 0x04, 0x08, 0x10, 0x1f],
+  '0': [0x0e, 0x11, 0x13, 0x15, 0x19, 0x11, 0x0e],
+  '1': [0x04, 0x0c, 0x04, 0x04, 0x04, 0x04, 0x0e],
+  '2': [0x0e, 0x11, 0x01, 0x02, 0x04, 0x08, 0x1f],
+  '3': [0x1f, 0x02, 0x04, 0x06, 0x01, 0x11, 0x0e],
+  '4': [0x02, 0x06, 0x0a, 0x12, 0x1f, 0x02, 0x02],
+  '5': [0x1f, 0x10, 0x1e, 0x01, 0x01, 0x11, 0x0e],
+  '6': [0x06, 0x08, 0x10, 0x1e, 0x11, 0x11, 0x0e],
+  '7': [0x1f, 0x01, 0x02, 0x04, 0x08, 0x08, 0x08],
+  '8': [0x0e, 0x11, 0x11, 0x0e, 0x11, 0x11, 0x0e],
+  '9': [0x0e, 0x11, 0x11, 0x0f, 0x01, 0x02, 0x0c],
+  ' ': [0, 0, 0, 0, 0, 0, 0],
+  _: [0, 0, 0, 0, 0, 0, 0x1f],
+  '-': [0, 0, 0, 0x1f, 0, 0, 0],
+  '.': [0, 0, 0, 0, 0, 0x0c, 0x0c],
+  ',': [0, 0, 0, 0, 0x0c, 0x0c, 0x04],
+  ':': [0, 0x0c, 0x0c, 0, 0x0c, 0x0c, 0],
+  '/': [0x01, 0x02, 0x02, 0x04, 0x08, 0x08, 0x10],
+  '(': [0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02],
+  ')': [0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08],
+  '!': [0x04, 0x04, 0x04, 0x04, 0x04, 0, 0x04],
+  '+': [0, 0x04, 0x04, 0x1f, 0x04, 0x04, 0],
+  '=': [0, 0, 0x1f, 0, 0x1f, 0, 0],
+  '<': [0x02, 0x04, 0x08, 0x10, 0x08, 0x04, 0x02],
+  '>': [0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08],
+};
+
+export const GLYPH_W = 5;
+export const GLYPH_H = 7;
+
+/** Width in pixels of `text` drawn at `scale` with a one-column gap. */
+export function textWidth(text: string, scale: number): number {
+  if (!text.length) return 0;
+  return (text.length * (GLYPH_W + 1) - 1) * scale;
+}
+
+/**
+ * Rasterise `text` by calling `plot(x, y)` for every lit pixel, with the top
+ * left of the first glyph at (x0, y0). Unknown characters draw as a full block
+ * so a typo is loud rather than invisible.
+ */
+export function drawText(
+  text: string,
+  x0: number,
+  y0: number,
+  scale: number,
+  plot: (x: number, y: number) => void,
+): void {
+  let cursor = x0;
+  for (const ch of text.toUpperCase()) {
+    const glyph = GLYPHS[ch] ?? [0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f];
+    for (let row = 0; row < GLYPH_H; row++) {
+      for (let col = 0; col < GLYPH_W; col++) {
+        if (!(glyph[row] & (1 << (GLYPH_W - 1 - col)))) continue;
+        for (let sy = 0; sy < scale; sy++) {
+          for (let sx = 0; sx < scale; sx++) {
+            plot(cursor + col * scale + sx, y0 + row * scale + sy);
+          }
+        }
+      }
+    }
+    cursor += (GLYPH_W + 1) * scale;
+  }
+}

package/tools/plate.ts

@@ -0,0 +1,286 @@
+/**
+ * Minimal RGBA canvas + PNG writer.
+ *
+ * `src/png.ts` reads 26 bytes of header because that is all the compiler needs;
+ * this writes whole files, because a rig has to have something to point at
+ * before its art exists — synthetic stand-in plates, reference frames, the
+ * selftest's own fixtures. Node's zlib is the only thing it leans on, so the
+ * rigc package still has exactly one dependency.
+ *
+ * Straight (non-premultiplied) alpha, colour type 6. Premultiplied alpha is the
+ * single most consequential export setting to get wrong — the renderer does not
+ * un-premultiply, so every part gains a dark rim — and a writer that cannot
+ * produce it is the cheapest possible guarantee.
+ */
+import { deflateSync, inflateSync } from 'node:zlib';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { drawText, textWidth } from './font5x7.ts';
+
+export type RGBA = [number, number, number, number];
+
+export class Plate {
+  readonly width: number;
+  readonly height: number;
+  readonly data: Uint8Array;
+
+  constructor(width: number, height: number) {
+    this.width = width;
+    this.height = height;
+    this.data = new Uint8Array(width * height * 4);
+  }
+
+  /** Source-over composite of one pixel. Alpha in 0..255. */
+  blend(x: number, y: number, [r, g, b, a]: RGBA): void {
+    const px = Math.round(x);
+    const py = Math.round(y);
+    if (px < 0 || py < 0 || px >= this.width || py >= this.height) return;
+    if (a <= 0) return;
+    const i = (py * this.width + px) * 4;
+    const sa = a / 255;
+    const da = this.data[i + 3] / 255;
+    const oa = sa + da * (1 - sa);
+    if (oa <= 0) return;
+    for (let c = 0; c < 3; c++) {
+      const sc = [r, g, b][c];
+      this.data[i + c] = Math.round((sc * sa + this.data[i + c] * da * (1 - sa)) / oa);
+    }
+    this.data[i + 3] = Math.round(oa * 255);
+  }
+
+  /** Overwrite one pixel outright, alpha included. */
+  set(x: number, y: number, [r, g, b, a]: RGBA): void {
+    const px = Math.round(x);
+    const py = Math.round(y);
+    if (px < 0 || py < 0 || px >= this.width || py >= this.height) return;
+    const i = (py * this.width + px) * 4;
+    this.data[i] = r;
+    this.data[i + 1] = g;
+    this.data[i + 2] = b;
+    this.data[i + 3] = a;
+  }
+
+  get(x: number, y: number): RGBA {
+    const i = (y * this.width + x) * 4;
+    return [this.data[i], this.data[i + 1], this.data[i + 2], this.data[i + 3]];
+  }
+
+  /** Multiply the whole plate's alpha by a per-pixel factor in 0..1. */
+  maskAlpha(f: (x: number, y: number) => number): void {
+    for (let y = 0; y < this.height; y++) {
+      for (let x = 0; x < this.width; x++) {
+        const i = (y * this.width + x) * 4;
+        const k = Math.max(0, Math.min(1, f(x, y)));
+        this.data[i + 3] = Math.round(this.data[i + 3] * k);
+      }
+    }
+  }
+
+  rect(x0: number, y0: number, w: number, h: number, colour: RGBA): void {
+    for (let y = y0; y < y0 + h; y++) for (let x = x0; x < x0 + w; x++) this.blend(x, y, colour);
+  }
+
+  frame(x0: number, y0: number, w: number, h: number, t: number, colour: RGBA): void {
+    this.rect(x0, y0, w, t, colour);
+    this.rect(x0, y0 + h - t, w, t, colour);
+    this.rect(x0, y0, t, h, colour);
+    this.rect(x0 + w - t, y0, t, h, colour);
+  }
+
+  line(x0: number, y0: number, x1: number, y1: number, t: number, colour: RGBA): void {
+    const steps = Math.ceil(Math.hypot(x1 - x0, y1 - y0)) * 2 + 1;
+    for (let s = 0; s <= steps; s++) {
+      const u = s / steps;
+      const cx = x0 + (x1 - x0) * u;
+      const cy = y0 + (y1 - y0) * u;
+      for (let dy = -t; dy <= t; dy++) for (let dx = -t; dx <= t; dx++) this.blend(cx + dx, cy + dy, colour);
+    }
+  }
+
+  disc(cx: number, cy: number, r: number, colour: RGBA): void {
+    for (let y = Math.floor(cy - r); y <= Math.ceil(cy + r); y++) {
+      for (let x = Math.floor(cx - r); x <= Math.ceil(cx + r); x++) {
+        if (Math.hypot(x - cx, y - cy) <= r) this.blend(x, y, colour);
+      }
+    }
+  }
+
+  ring(cx: number, cy: number, r: number, t: number, colour: RGBA): void {
+    for (let y = Math.floor(cy - r - t); y <= Math.ceil(cy + r + t); y++) {
+      for (let x = Math.floor(cx - r - t); x <= Math.ceil(cx + r + t); x++) {
+        const d = Math.hypot(x - cx, y - cy);
+        if (Math.abs(d - r) <= t) this.blend(x, y, colour);
+      }
+    }
+  }
+
+  text(str: string, x: number, y: number, scale: number, colour: RGBA): void {
+    drawText(str, x, y, scale, (px, py) => this.blend(px, py, colour));
+  }
+
+  textCentred(str: string, cx: number, y: number, scale: number, colour: RGBA): void {
+    this.text(str, Math.round(cx - textWidth(str, scale) / 2), y, scale, colour);
+  }
+
+  /** Alpha-weighted pixel count, and how much of it sits outside a predicate. */
+  alphaStats(inside: (x: number, y: number) => boolean): {
+    total: number;
+    outside: number;
+    outsideMaxAlpha: number;
+  } {
+    let total = 0;
+    let outside = 0;
+    let outsideMaxAlpha = 0;
+    for (let y = 0; y < this.height; y++) {
+      for (let x = 0; x < this.width; x++) {
+        const a = this.data[(y * this.width + x) * 4 + 3];
+        if (a === 0) continue;
+        total++;
+        if (!inside(x, y)) {
+          outside++;
+          if (a > outsideMaxAlpha) outsideMaxAlpha = a;
+        }
+      }
+    }
+    return { total, outside, outsideMaxAlpha };
+  }
+
+  writePng(path: string): void {
+    writeFileSync(path, encodePng(this.width, this.height, this.data));
+  }
+}
+
+// ---------------------------------------------------------------------------
+// PNG encoding
+// ---------------------------------------------------------------------------
+
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+
+function crc32(buf: Uint8Array): number {
+  let c = 0xffffffff;
+  for (let i = 0; i < buf.length; i++) c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+function chunk(type: string, body: Uint8Array): Uint8Array {
+  const out = new Uint8Array(body.length + 12);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, body.length);
+  for (let i = 0; i < 4; i++) out[4 + i] = type.charCodeAt(i);
+  out.set(body, 8);
+  view.setUint32(body.length + 8, crc32(out.subarray(4, body.length + 8)));
+  return out;
+}
+
+export function encodePng(width: number, height: number, rgba: Uint8Array): Uint8Array {
+  // Filter type 0 (none) on every scanline. The plates are flat colour and
+  // deterministic output is worth more here than a few kilobytes.
+  const raw = new Uint8Array(height * (width * 4 + 1));
+  for (let y = 0; y < height; y++) {
+    raw[y * (width * 4 + 1)] = 0;
+    raw.set(rgba.subarray(y * width * 4, (y + 1) * width * 4), y * (width * 4 + 1) + 1);
+  }
+  const ihdr = new Uint8Array(13);
+  const view = new DataView(ihdr.buffer);
+  view.setUint32(0, width);
+  view.setUint32(4, height);
+  ihdr[8] = 8; // bit depth
+  ihdr[9] = 6; // colour type: truecolour + alpha
+  ihdr[10] = 0;
+  ihdr[11] = 0;
+  ihdr[12] = 0;
+  const parts = [
+    new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+    chunk('IHDR', ihdr),
+    chunk('IDAT', new Uint8Array(deflateSync(raw, { level: 9 }))),
+    chunk('IEND', new Uint8Array(0)),
+  ];
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const out = new Uint8Array(total);
+  let at = 0;
+  for (const p of parts) {
+    out.set(p, at);
+    at += p.length;
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// PNG decoding
+// ---------------------------------------------------------------------------
+
+/**
+ * Read an 8-bit RGB/RGBA PNG back into a `Plate`.
+ *
+ * `src/png.ts` parses 26 bytes because that is all the COMPILER needs, and it
+ * stays that way: the compiler never re-measures art. This
+ * decoder is for the measuring tools, which is where art measurement belongs -
+ * the same division that puts `mesh.center` in the manifest as a measured number
+ * rather than as something the compiler derives at build time.
+ */
+export function decodePng(buf: Uint8Array): Plate {
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  let at = 8;
+  let width = 0;
+  let height = 0;
+  let colourType = 6;
+  const idat: Uint8Array[] = [];
+  while (at < buf.length) {
+    const len = view.getUint32(at);
+    const type = String.fromCharCode(buf[at + 4], buf[at + 5], buf[at + 6], buf[at + 7]);
+    const body = buf.subarray(at + 8, at + 8 + len);
+    if (type === 'IHDR') {
+      width = view.getUint32(at + 8);
+      height = view.getUint32(at + 12);
+      if (body[8] !== 8) throw new Error(`unsupported bit depth ${body[8]}`);
+      colourType = body[9];
+      if (body[12] !== 0) throw new Error('interlaced PNG');
+    } else if (type === 'IDAT') idat.push(body);
+    at += 12 + len;
+  }
+  const bpp = colourType === 6 ? 4 : colourType === 2 ? 3 : 0;
+  if (!bpp) throw new Error(`unsupported colour type ${colourType}`);
+  const raw = new Uint8Array(inflateSync(Buffer.concat(idat.map((c) => Buffer.from(c)))));
+  const stride = width * bpp + 1;
+  const plate = new Plate(width, height);
+  let prev = new Uint8Array(width * bpp);
+  for (let y = 0; y < height; y++) {
+    const filter = raw[y * stride];
+    const line = raw.slice(y * stride + 1, (y + 1) * stride);
+    for (let x = 0; x < width * bpp; x++) {
+      const a = x >= bpp ? line[x - bpp] : 0;
+      const b = prev[x];
+      const c = x >= bpp ? prev[x - bpp] : 0;
+      if (filter === 1) line[x] = (line[x] + a) & 255;
+      else if (filter === 2) line[x] = (line[x] + b) & 255;
+      else if (filter === 3) line[x] = (line[x] + ((a + b) >> 1)) & 255;
+      else if (filter === 4) {
+        const p = a + b - c;
+        const pa = Math.abs(p - a);
+        const pb = Math.abs(p - b);
+        const pc = Math.abs(p - c);
+        line[x] = (line[x] + (pa <= pb && pa <= pc ? a : pb <= pc ? b : c)) & 255;
+      }
+    }
+    for (let x = 0; x < width; x++) {
+      const o = (y * width + x) * 4;
+      plate.data[o] = line[x * bpp];
+      plate.data[o + 1] = line[x * bpp + 1];
+      plate.data[o + 2] = line[x * bpp + 2];
+      plate.data[o + 3] = bpp === 4 ? line[x * bpp + 3] : 255;
+    }
+    prev = line;
+  }
+  return plate;
+}
+
+export function readPlate(path: string): Plate {
+  return decodePng(readFileSync(path));
+}