@origingame/create-game 0.0.0-stage → 0.1.0

package/archetypes/match3/tools/make-assets.py

@@ -0,0 +1,404 @@
+#!/usr/bin/env python3
+"""Regenerates the match3 archetype's self-made assets (CC0), byte for byte:
+
+    python3 tools/make-assets.py            # from the archetype directory
+
+- assets/sprites/gems.png + gems.ogt: the gem flipbook, one row per colour
+  (idle with a glint after a long hold, a clear burst), lossless,
+- assets/sprites/panel.png (the board's nine-slice backing), backdrop.png
+  and ring.png (the selection frame),
+- assets/sprites/cells.png + cells.ogt + board.ogt: the checker tileset and
+  the 7 x 7 tilemap under the gems,
+- assets/audio/*.wav: select, swap, refused, clear, cascade, won and lost,
+- assets/fonts/ui.ttf (+ ui.ttf.ogt): Noto Sans SC subset to Latin-1 and the
+  HUD's characters (needs fontTools and the project template's font; skipped
+  with a note when either is missing, since the committed subset is there).
+
+Standard library only except the font subset; deterministic.
+"""
+import math, os, sys
+
+here = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, here)
+from oglite import Canvas, hex_rgb, png_bytes, write_wav, tone, noise, mix, concat, subset_font  # noqa: E402
+
+root = os.path.dirname(here)
+assets = os.path.join(root, "assets")
+
+
+INK = "#14161b"  # the brand ink: the backdrop, the panel's shadow and the gems' outlines
+
+
+def blank(w, h):
+    return Canvas(w, h)
+
+
+def mixc(a, b, t):
+    """Mix two #rrggbb colours."""
+    ra, ga, ba = hex_rgb(a)
+    rb, gb, bb = hex_rgb(b)
+    return "#%02x%02x%02x" % tuple(round(x + (y - x) * t) for x, y in ((ra, rb), (ga, gb), (ba, bb)))
+
+
+def inside_poly(pts):
+    def inside(px, py):
+        c = False
+        j = len(pts) - 1
+        for i in range(len(pts)):
+            xi, yi = pts[i]; xj, yj = pts[j]
+            if (yi > py) != (yj > py) and px < (xj - xi) * (py - yi) / (yj - yi) + xi:
+                c = not c
+            j = i
+        return c
+    return inside
+
+
+def paint_where(c, inside, colour, alpha=1.0):
+    c._paint(inside, (0, 0, c.w, c.h), colour, alpha)
+
+
+# ── the gems: six colours, six cuts, so colour is never the only cue ─────
+
+GEMS = [
+    # name, body, dark, light, cut
+    ("ruby", "#ff3048", "#a3122a", "#ff9aa6", "round"),
+    ("sky", "#2c8bff", "#1449a8", "#9fd0ff", "emerald"),
+    ("leaf", "#25d36a", "#0f7a3a", "#a4f5c2", "trillion"),
+    ("sun", "#ffc414", "#b57800", "#fff0a0", "kite"),
+    ("plum", "#b057ff", "#5f22a8", "#e2bcff", "hex"),
+    ("coral", "#ff7424", "#ad3b00", "#ffc49a", "star"),
+]
+
+FRAME = 80        # px per frame (the gem sits in it with a margin)
+FRAMES = 8        # per colour: 0 idle, 1-3 the glint, 4-7 the clear burst
+GLINT = (1, 2, 3)
+BURST = (4, 5, 6, 7)
+
+
+def cut(name, cx, cy, r):
+    """The outline of a cut, clockwise from the top (pixels, y down)."""
+    def ring(n, rot, rad=r):
+        return [(cx + rad * math.cos(rot + i * 2 * math.pi / n), cy + rad * math.sin(rot + i * 2 * math.pi / n)) for i in range(n)]
+    if name == "round":
+        return ring(12, -math.pi / 2)
+    if name == "emerald":  # a square with clipped corners
+        k = r * 0.82; s = r * 0.38
+        return [(cx - k + s, cy - k), (cx + k - s, cy - k), (cx + k, cy - k + s), (cx + k, cy + k - s),
+                (cx + k - s, cy + k), (cx - k + s, cy + k), (cx - k, cy + k - s), (cx - k, cy - k + s)]
+    if name == "trillion":
+        return ring(3, -math.pi / 2, r * 1.12)
+    if name == "kite":
+        return [(cx, cy - r * 1.05), (cx + r * 0.78, cy - r * 0.1), (cx, cy + r * 1.05), (cx - r * 0.78, cy - r * 0.1)]
+    if name == "hex":
+        return ring(6, -math.pi / 2)
+    pts = []  # star
+    for i in range(10):
+        rad = r * (1.08 if i % 2 == 0 else 0.5)
+        a = -math.pi / 2 + i * math.pi / 5
+        pts.append((cx + rad * math.cos(a), cy + rad * math.sin(a)))
+    return pts
+
+
+def scaled(pts, cx, cy, k, dy=0.0):
+    return [(cx + (x - cx) * k, cy + (y - cy) * k + dy) for x, y in pts]
+
+
+def gem(c, spec, cx, cy, r, bright=0.0):
+    """A faceted gem: an ink rim, facets lit from the top left, a table, a highlight."""
+    _, body, dark, light, name = spec
+    if bright:
+        body, dark, light = mixc(body, "#ffffff", bright), mixc(dark, "#ffffff", bright), mixc(light, "#ffffff", bright)
+    outer = cut(name, cx, cy, r)
+    c.poly(scaled(outer, cx, cy, 1.0, 3.0), INK, 0.55)          # its shadow on the cell
+    c.poly(scaled(outer, cx, cy, 1.09), INK)                     # the rim
+    c.poly(outer, body)
+    table = scaled(outer, cx, cy - r * 0.06, 0.56)
+    lx, ly = -0.62, -0.78                                        # towards the light
+    n = len(outer)
+    for i in range(n):
+        a, b = outer[i], outer[(i + 1) % n]
+        ta, tb = table[i], table[(i + 1) % n]
+        mx, my = (a[0] + b[0]) / 2 - cx, (a[1] + b[1]) / 2 - cy
+        ln = math.hypot(mx, my) or 1.0
+        lit = (mx * lx + my * ly) / ln                           # -1 away from the light, 1 facing it
+        col = mixc(body, light, lit * 0.75) if lit > 0 else mixc(body, dark, -lit * 0.7)
+        c.poly([a, b, tb, ta], col)
+    c.poly(table, mixc(body, light, 0.35))
+    c.poly(scaled(table, cx, cy, 0.55, -r * 0.08), mixc(body, light, 0.6), 0.7)
+    c.ellipse(cx - r * 0.3, cy - r * 0.42, r * 0.2, r * 0.12, "#ffffff", 0.75)
+    return outer
+
+
+def sparkle(c, x, y, s, alpha=1.0):
+    c.poly([(x, y - s), (x + s * 0.22, y - s * 0.22), (x + s, y), (x + s * 0.22, y + s * 0.22),
+            (x, y + s), (x - s * 0.22, y + s * 0.22), (x - s, y), (x - s * 0.22, y - s * 0.22)], "#ffffff", alpha)
+
+
+def gem_frame(spec, f):
+    c = blank(FRAME, FRAME)
+    cx = cy = FRAME / 2
+    r = FRAME * 0.36
+    if f == 0 or f in GLINT:
+        outer = gem(c, spec, cx, cy, r)
+        if f in GLINT:
+            # A diagonal band of light sweeping across the gem, kept inside its outline.
+            t = (f - GLINT[0] + 0.5) / len(GLINT)
+            inside = inside_poly(outer)
+            u0 = -0.6 + 1.2 * t
+            band = lambda px, py: inside(px, py) and abs(((px - cx) + (py - cy)) / (2 * r) - u0) < 0.16
+            paint_where(c, band, "#ffffff", 0.7)
+            if f == GLINT[1]:
+                sparkle(c, cx + r * 0.45, cy - r * 0.55, r * 0.42)
+        return c
+    k = f - BURST[0]  # 0..3: a white-hot gem, then it breaks into a ring and shards
+    if k == 0:
+        gem(c, spec, cx, cy, r * 1.06, bright=0.55)
+        sparkle(c, cx, cy, r * 0.9, 0.9)
+        return c
+    _, body, _, light, name = spec
+    spread = (0.0, 0.55, 0.85, 1.05)[k]
+    fade = (1.0, 0.95, 0.7, 0.35)[k]
+    rr = r * (0.55 + 0.22 * k)
+    c.ring(cx, cy, rr, max(2.0, 7 - 2 * k), light, fade)
+    for i in range(6):
+        a = -math.pi / 2 + i * math.pi / 3 + 0.3
+        d = r * spread
+        x, y = cx + d * math.cos(a), cy + d * math.sin(a)
+        s = r * (0.36 - 0.07 * k)
+        shard = cut(name, x, y, s)
+        c.poly(scaled(shard, x, y, 1.15), INK, fade)
+        c.poly(shard, body if i % 2 == 0 else light, fade)
+    if k < 3:
+        sparkle(c, cx, cy, r * (0.5 - 0.12 * k), fade)
+    return c
+
+
+def gem_sheet():
+    """gems.png: one row per colour, FRAMES frames across."""
+    w, h = FRAME * FRAMES, FRAME * len(GEMS)
+    rows = [bytearray(w * 4) for _ in range(h)]
+    for gi, spec in enumerate(GEMS):
+        for f in range(FRAMES):
+            fr = gem_frame(spec, f).rgba()
+            for y in range(FRAME):
+                rows[gi * FRAME + y][f * FRAME * 4:(f + 1) * FRAME * 4] = fr[y]
+    return png_bytes(w, h, rows)
+
+
+def gem_flipbook():
+    """gems.ogt: idle_<colour> loops the glint after a long hold, clear_<colour> bursts once."""
+    lines = [
+        "type flipbook",
+        "version 1",
+        "---",
+        "# Written by tools/make-assets.py. Clip 2c is colour c's idle loop, 2c + 1 its clear",
+        "# burst (src/art.ts relies on that order).",
+        'texture "gems.png"',
+        "filter linear",
+        "pivot 0.5 0.5",
+        f"grid {FRAME} {FRAME} {FRAMES} {len(GEMS)}",
+    ]
+    for gi, (name, *_rest) in enumerate(GEMS):
+        base = gi * FRAMES
+        idle = " ".join(str(base + f) for f in (0,) + GLINT)
+        burst = " ".join(str(base + f) for f in BURST)
+        lines += [
+            f"clip idle_{name} {{",
+            f"  frames {idle}",
+            "  durations 2.4 0.05 0.06 0.05",
+            "  mode loop",
+            "}",
+            f"clip clear_{name} {{",
+            f"  frames {burst}",
+            "  fps 24",
+            "  mode once",
+            '  event 1 "burst"',
+            "}",
+        ]
+    return "\n".join(lines) + "\n"
+
+
+# ── the board and the frame ───────────────────────────────────────────────
+
+PANEL = 96
+PANEL_INSET = 32  # nine-slice insets in px, every side
+
+
+def panel():
+    """The board's backing, drawn nine-sliced: a soft ink shadow, a rim catching the light, a dark well."""
+    c = blank(PANEL, PANEL)
+    c.rect(2, 6, 92, 88, "#08090c", radius=26, alpha=0.8)
+    c.rect(2, 2, 92, 90, "#2a2f3c", radius=26)
+    c.rect(4, 5, 88, 86, "#0e1015", radius=24)
+    c.rect(7, 8, 82, 80, "#111318", radius=21)
+    return c
+
+
+def backdrop():
+    """A quiet lift of the light behind the board, fading to nothing at its edge (the ink
+    around it is the camera's background): a tiny smooth image the sampler stretches."""
+    n = 16
+    rows = []
+    lift = hex_rgb("#262b3b")
+    for y in range(n):
+        row = bytearray()
+        for x in range(n):
+            d = min(1.0, math.hypot((x + 0.5) / n - 0.5, (y + 0.5) / n - 0.5) / 0.5)
+            t = 1 - d * d * (3 - 2 * d)
+            row += bytes(lift) + bytes([round(255 * 0.55 * t)])
+        rows.append(bytes(row))
+    return png_bytes(n, n, rows)
+
+
+def ring():
+    """The selection frame: a warm rounded square outline with a faint inner glow."""
+    n = 96
+    c = blank(n, n)
+    c.rect(3, 3, 90, 90, "#ffd76a", radius=22, alpha=0.25)
+    c.rect(4, 4, 88, 88, "#fff1c2", radius=21)
+    lo, hi, rad = 11, 85, 15
+    for i, p in enumerate(c.px):
+        x, y = i % n + 0.5, i // n + 0.5
+        if lo <= x < hi and lo <= y < hi:
+            qx = min(max(x, lo + rad), hi - rad)
+            qy = min(max(y, lo + rad), hi - rad)
+            d = math.hypot(x - qx, y - qy)
+            if d <= rad:
+                keep = 0.18 * max(0.0, 1 - (min(x - lo, hi - x, y - lo, hi - y)) / 10)
+                for j in range(4):
+                    p[j] *= keep
+    return c
+
+
+TILE = 64  # px per checker cell
+
+
+def cells():
+    """cells.png: two checker cells (a tileset of 2 x 1)."""
+    c = blank(TILE * 2, TILE)
+    c.rect(2, 2, TILE - 4, TILE - 4, "#1c1f28", radius=9)
+    c.rect(2, 2, TILE - 4, 6, "#232733", radius=9, alpha=0.6)
+    c.rect(TILE + 2, 2, TILE - 4, TILE - 4, "#171a21", radius=9)
+    c.rect(TILE + 2, 2, TILE - 4, 6, "#1d2029", radius=9, alpha=0.6)
+    return c
+
+
+def cells_tileset():
+    return "\n".join([
+        "type tileset",
+        "version 1",
+        "---",
+        "# Written by tools/make-assets.py: the board's two checker cells.",
+        'texture "sprites/cells.png"',
+        f"grid {TILE} {TILE} 2 1",
+        "filter nearest",
+    ]) + "\n"
+
+
+def board_map(size=7):
+    rows = []
+    for y in range(size):
+        rows.append('  row "' + "".join("ab"[(x + y) % 2] for x in range(size)) + '"')
+    return "\n".join([
+        "type tilemap",
+        "version 1",
+        "---",
+        "# Written by tools/make-assets.py: the 7 x 7 checker under the gems, one world unit a cell;",
+        "# src/main.ts places its top-left corner at the board's.",
+        f"size {size} {size}",
+        f"tile {TILE} {TILE}",
+        "unit 1",
+        'tileset "sprites/cells.ogt"',
+        "layer cells {",
+        "  z 0",
+        '  legend "a" 0',
+        '  legend "b" 1',
+        *rows,
+        "}",
+    ]) + "\n"
+
+
+PIXEL_IMPORT = """type import
+version 1
+---
+# Written by tools/make-assets.py: lossless RGBA8 ({why}).
+texture {{
+  kind pixel
+}}
+"""
+
+
+CHARS = "三消开始游戏点击或拖动交换相邻方块连成同色分数步数目标胜利失败再来一次剩余最高"
+
+FONT_IMPORT = """type import
+version 1
+---
+# Written by tools/make-assets.py: the atlas holds Latin-1 and the HUD's own
+# CJK characters (CHARS there); add a character to CHARS before showing it.
+font {{
+  charset latin
+  chars "{chars}"
+  em_px 48
+  px_range 6
+}}
+"""
+
+
+def main():
+    sprites = os.path.join(assets, "sprites")
+    os.makedirs(sprites, exist_ok=True)
+    preview = os.environ.get("OG_SPRITE_PREVIEW")
+
+    def png(name, data, why=None):
+        open(os.path.join(sprites, name), "wb").write(data)
+        if why:
+            with open(os.path.join(sprites, name + ".ogt"), "w") as f:
+                f.write(PIXEL_IMPORT.format(why=why))
+        if preview:
+            os.makedirs(preview, exist_ok=True)
+            open(os.path.join(preview, name), "wb").write(data)
+
+    def canvas_png(name, canvas, why=None):
+        png(name, png_bytes(canvas.w, canvas.h, canvas.rgba()), why)
+
+    # The gem sheet is a colour texture (filtered, with mips), not `kind pixel`: the runtime
+    # samples a pixel-kind texture nearest even when its flipbook says `filter linear`.
+    png("gems.png", gem_sheet())
+    with open(os.path.join(sprites, "gems.ogt"), "w") as f:
+        f.write(gem_flipbook())
+    canvas_png("panel.png", panel())
+    png("backdrop.png", backdrop())
+    canvas_png("ring.png", ring())
+    canvas_png("cells.png", cells(), "a tileset, drawn one texel to a pixel")
+    with open(os.path.join(sprites, "cells.ogt"), "w") as f:
+        f.write(cells_tileset())
+    with open(os.path.join(sprites, "board.ogt"), "w") as f:
+        f.write(board_map())
+
+    a = os.path.join(assets, "audio")
+    os.makedirs(a, exist_ok=True)
+    write_wav(os.path.join(a, "select.wav"), tone(0.08, 880, shape="tri", decay=0.04, gain=0.35))
+    write_wav(os.path.join(a, "swap.wav"), tone(0.14, 440, 660, shape="tri", decay=0.07, gain=0.35))
+    write_wav(os.path.join(a, "refused.wav"), concat(tone(0.08, 220, shape="square", decay=0.05, gain=0.25),
+                                                     tone(0.12, 185, shape="square", decay=0.06, gain=0.25)))
+    write_wav(os.path.join(a, "clear.wav"), mix(tone(0.3, 660, 1320, shape="sine", decay=0.12, gain=0.4),
+                                                 noise(0.12, decay=0.03, gain=0.15, seed=3)))
+    write_wav(os.path.join(a, "cascade.wav"), concat(tone(0.08, 784, shape="tri", decay=0.05, gain=0.35),
+                                                     tone(0.08, 988, shape="tri", decay=0.05, gain=0.35),
+                                                     tone(0.16, 1175, shape="tri", decay=0.08, gain=0.35)))
+    write_wav(os.path.join(a, "won.wav"), concat(*[tone(0.12, f, shape="tri", decay=0.1, gain=0.4) for f in (523, 659, 784, 1047)]))
+    write_wav(os.path.join(a, "lost.wav"), concat(*[tone(0.18, f, shape="tri", decay=0.12, gain=0.4) for f in (392, 330, 262)]))
+
+    fonts = os.path.join(assets, "fonts")
+    os.makedirs(fonts, exist_ok=True)
+    font_src = os.path.join(root, "..", "..", "game", "assets", "fonts", "NotoSansSC-Regular-subset.ttf")
+    try:
+        subset_font(font_src, os.path.join(fonts, "ui.ttf"), CHARS)
+    except Exception as e:  # noqa: BLE001
+        print(f"font subset skipped ({e}); the committed assets/fonts/ui.ttf stays")
+    with open(os.path.join(fonts, "ui.ttf.ogt"), "w") as f:
+        f.write(FONT_IMPORT.format(chars=CHARS))
+
+
+if __name__ == "__main__":
+    main()

package/archetypes/match3/tools/oglite.py

@@ -0,0 +1,285 @@
+"""A tiny, standard-library-only sprite kit for Origin Engine archetypes.
+
+It draws antialiased vector shapes into RGBA images (4x4 supersampling),
+writes PNGs, packs sprites into one glTF binary (.glb) of unit quads, one
+mesh and one emissive, alpha-masked material per sprite, and writes 16-bit
+WAV sounds. Everything is a pure function of its inputs, so the assets it
+makes are byte-for-byte reproducible.
+
+A sprite quad lies in the xy plane facing +z, 1 x 1 units, centred on the
+origin, with uv (0,0) at the image's top left. Its material is black base
+colour (alpha from the image, for the mask), roughness 1, and the image as
+the emissive texture: with no light, no environment and tone mapping off,
+the frame shows the image's colours exactly.
+"""
+import json, math, struct, wave, zlib
+
+SS = 4  # supersamples per axis
+
+
+def hex_rgb(h):
+    h = h.lstrip("#")
+    return tuple(int(h[i:i + 2], 16) for i in (0, 2, 4))
+
+
+class Canvas:
+    """An RGBA canvas; shapes are painted in order with coverage antialiasing.
+    Coordinates are in pixels, origin top left, y down."""
+
+    def __init__(self, w, h):
+        self.w, self.h = w, h
+        self.px = [[0.0, 0.0, 0.0, 0.0] for _ in range(w * h)]  # premultiplied
+
+    def _paint(self, inside, bbox, colour, alpha=1.0):
+        r, g, b = (c / 255.0 for c in hex_rgb(colour))
+        x0, y0, x1, y1 = bbox
+        x0 = max(0, int(math.floor(x0))); y0 = max(0, int(math.floor(y0)))
+        x1 = min(self.w, int(math.ceil(x1))); y1 = min(self.h, int(math.ceil(y1)))
+        n = SS * SS
+        for y in range(y0, y1):
+            for x in range(x0, x1):
+                hits = 0
+                for sy in range(SS):
+                    py = y + (sy + 0.5) / SS
+                    for sx in range(SS):
+                        if inside(x + (sx + 0.5) / SS, py):
+                            hits += 1
+                if hits == 0:
+                    continue
+                a = alpha * hits / n
+                p = self.px[y * self.w + x]
+                p[0] = r * a + p[0] * (1 - a)
+                p[1] = g * a + p[1] * (1 - a)
+                p[2] = b * a + p[2] * (1 - a)
+                p[3] = a + p[3] * (1 - a)
+
+    def rect(self, x, y, w, h, colour, radius=0.0, alpha=1.0):
+        rad = min(radius, w / 2, h / 2)
+
+        def inside(px, py):
+            if px < x or px > x + w or py < y or py > y + h:
+                return False
+            if rad <= 0:
+                return True
+            cx = min(max(px, x + rad), x + w - rad)
+            cy = min(max(py, y + rad), y + h - rad)
+            return (px - cx) ** 2 + (py - cy) ** 2 <= rad * rad
+
+        self._paint(inside, (x, y, x + w, y + h), colour, alpha)
+
+    def circle(self, cx, cy, r, colour, alpha=1.0):
+        self.ellipse(cx, cy, r, r, colour, alpha)
+
+    def ellipse(self, cx, cy, rx, ry, colour, alpha=1.0):
+        def inside(px, py):
+            return ((px - cx) / rx) ** 2 + ((py - cy) / ry) ** 2 <= 1.0
+
+        self._paint(inside, (cx - rx, cy - ry, cx + rx, cy + ry), colour, alpha)
+
+    def ring(self, cx, cy, r, width, colour, alpha=1.0):
+        def inside(px, py):
+            d = math.hypot(px - cx, py - cy)
+            return r - width <= d <= r
+
+        self._paint(inside, (cx - r, cy - r, cx + r, cy + r), colour, alpha)
+
+    def poly(self, pts, colour, alpha=1.0):
+        xs = [p[0] for p in pts]; ys = [p[1] for p in pts]
+
+        def inside(px, py):
+            c = False
+            j = len(pts) - 1
+            for i in range(len(pts)):
+                xi, yi = pts[i]; xj, yj = pts[j]
+                if (yi > py) != (yj > py) and px < (xj - xi) * (py - yi) / (yj - yi) + xi:
+                    c = not c
+                j = i
+            return c
+
+        self._paint(inside, (min(xs), min(ys), max(xs), max(ys)), colour, alpha)
+
+    def line(self, x0, y0, x1, y1, width, colour, alpha=1.0):
+        dx, dy = x1 - x0, y1 - y0
+        ln = math.hypot(dx, dy) or 1.0
+        nx, ny = -dy / ln * width / 2, dx / ln * width / 2
+        self.poly([(x0 + nx, y0 + ny), (x1 + nx, y1 + ny), (x1 - nx, y1 - ny), (x0 - nx, y0 - ny)], colour, alpha)
+        self.circle(x0, y0, width / 2, colour, alpha)
+        self.circle(x1, y1, width / 2, colour, alpha)
+
+    def rgba(self):
+        """Straight-alpha RGBA8 rows. Transparent pixels take the colour of
+        the nearest painted pixel (a few dilation passes), so filtering and
+        mips never pull a dark fringe into the edge."""
+        w, h = self.w, self.h
+        col = [None] * (w * h)
+        for i, p in enumerate(self.px):
+            if p[3] > 0:
+                col[i] = (p[0] / p[3], p[1] / p[3], p[2] / p[3])
+        for _ in range(8):
+            nxt = list(col)
+            changed = False
+            for y in range(h):
+                for x in range(w):
+                    i = y * w + x
+                    if col[i] is not None:
+                        continue
+                    for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)):
+                        xx, yy = x + dx, y + dy
+                        if 0 <= xx < w and 0 <= yy < h and col[yy * w + xx] is not None:
+                            nxt[i] = col[yy * w + xx]
+                            changed = True
+                            break
+            col = nxt
+            if not changed:
+                break
+        rows = []
+        for y in range(h):
+            row = bytearray()
+            for x in range(w):
+                i = y * w + x
+                c = col[i] or (0.0, 0.0, 0.0)
+                a = self.px[i][3]
+                row += bytes([round(min(1, max(0, c[0])) * 255), round(min(1, max(0, c[1])) * 255),
+                              round(min(1, max(0, c[2])) * 255), round(min(1, max(0, a)) * 255)])
+            rows.append(bytes(row))
+        return rows
+
+
+def png_bytes(w, h, rows):
+    raw = b"".join(b"\x00" + r for r in rows)
+
+    def chunk(t, d):
+        return struct.pack(">I", len(d)) + t + d + struct.pack(">I", zlib.crc32(t + d) & 0xFFFFFFFF)
+
+    return (b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", struct.pack(">IIBBBBB", w, h, 8, 6, 0, 0, 0))
+            + chunk(b"IDAT", zlib.compress(raw, 9)) + chunk(b"IEND", b""))
+
+
+def write_glb(path, sprites):
+    """sprites: list of (name, png bytes, masked). One quad mesh per sprite,
+    in list order: GltfInfo.geometries[i] and materials[i] are sprite i."""
+    bin_ = bytearray()
+
+    def add(data, align=4):
+        while len(bin_) % align:
+            bin_.append(0)
+        off = len(bin_)
+        bin_.extend(data)
+        return off, len(data)
+
+    pos = struct.pack("<12f", -0.5, -0.5, 0, 0.5, -0.5, 0, 0.5, 0.5, 0, -0.5, 0.5, 0)
+    nrm = struct.pack("<12f", *([0, 0, 1] * 4))
+    uv = struct.pack("<8f", 0, 1, 1, 1, 1, 0, 0, 0)
+    idx = struct.pack("<6H", 0, 1, 2, 0, 2, 3)
+    views, accessors = [], []
+    for data, target in ((pos, 34962), (nrm, 34962), (uv, 34962), (idx, 34963)):
+        o, n = add(data)
+        views.append({"buffer": 0, "byteOffset": o, "byteLength": n, "target": target})
+    accessors = [
+        {"bufferView": 0, "componentType": 5126, "count": 4, "type": "VEC3", "min": [-0.5, -0.5, 0], "max": [0.5, 0.5, 0]},
+        {"bufferView": 1, "componentType": 5126, "count": 4, "type": "VEC3"},
+        {"bufferView": 2, "componentType": 5126, "count": 4, "type": "VEC2"},
+        {"bufferView": 3, "componentType": 5123, "count": 6, "type": "SCALAR"},
+    ]
+    images, textures, materials, meshes, nodes = [], [], [], [], []
+    for i, (name, data, masked) in enumerate(sprites):
+        o, n = add(data)
+        views.append({"buffer": 0, "byteOffset": o, "byteLength": n})
+        images.append({"bufferView": len(views) - 1, "mimeType": "image/png", "name": name})
+        textures.append({"source": i, "sampler": 0})
+        m = {
+            "name": name,
+            "pbrMetallicRoughness": {"baseColorFactor": [0, 0, 0, 1], "baseColorTexture": {"index": i},
+                                     "metallicFactor": 0, "roughnessFactor": 1},
+            "emissiveTexture": {"index": i},
+            "emissiveFactor": [1, 1, 1],
+        }
+        if masked:
+            m["alphaMode"] = "MASK"
+            m["alphaCutoff"] = 0.5
+        materials.append(m)
+        meshes.append({"name": name, "primitives": [{"attributes": {"POSITION": 0, "NORMAL": 1, "TEXCOORD_0": 2},
+                                                     "indices": 3, "material": i}]})
+        nodes.append({"name": name, "mesh": i, "translation": [i * 1.2, 0, 0]})
+    while len(bin_) % 4:
+        bin_.append(0)
+    doc = {
+        "asset": {"version": "2.0", "generator": "oglite.py"},
+        "scene": 0, "scenes": [{"nodes": list(range(len(nodes)))}], "nodes": nodes, "meshes": meshes,
+        "materials": materials, "textures": textures, "images": images,
+        "samplers": [{"magFilter": 9729, "minFilter": 9987, "wrapS": 33071, "wrapT": 33071}],
+        "accessors": accessors, "bufferViews": views, "buffers": [{"byteLength": len(bin_)}],
+    }
+    js = json.dumps(doc, separators=(",", ":")).encode()
+    while len(js) % 4:
+        js += b" "
+    out = struct.pack("<III", 0x46546C67, 2, 12 + 8 + len(js) + 8 + len(bin_))
+    out += struct.pack("<II", len(js), 0x4E4F534A) + js + struct.pack("<II", len(bin_), 0x004E4942) + bytes(bin_)
+    with open(path, "wb") as f:
+        f.write(out)
+
+
+def write_wav(path, samples, rate=22050):
+    """samples: floats in [-1, 1], mono."""
+    with wave.open(path, "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(rate)
+        w.writeframes(b"".join(struct.pack("<h", int(max(-1, min(1, s)) * 32000)) for s in samples))
+
+
+def tone(seconds, f0, f1=None, rate=22050, shape="sine", attack=0.005, decay=None, gain=0.6):
+    """A sweep from f0 to f1 Hz with a short attack and an exponential decay."""
+    f1 = f0 if f1 is None else f1
+    n = int(seconds * rate)
+    out, phase = [], 0.0
+    decay = decay or seconds / 4
+    for i in range(n):
+        t = i / rate
+        f = f0 + (f1 - f0) * (i / max(1, n - 1))
+        phase += 2 * math.pi * f / rate
+        if shape == "square":
+            s = 1.0 if math.sin(phase) >= 0 else -1.0
+            s *= 0.5
+        elif shape == "tri":
+            s = 2 / math.pi * math.asin(math.sin(phase))
+        else:
+            s = math.sin(phase)
+        env = min(1.0, t / attack) * math.exp(-t / decay)
+        out.append(s * env * gain)
+    return out
+
+
+def noise(seconds, rate=22050, decay=0.08, gain=0.5, seed=1):
+    x = seed & 0xFFFFFFFF
+    out = []
+    for i in range(int(seconds * rate)):
+        x ^= (x << 13) & 0xFFFFFFFF; x ^= x >> 17; x ^= (x << 5) & 0xFFFFFFFF
+        out.append(((x / 0xFFFFFFFF) * 2 - 1) * math.exp(-(i / rate) / decay) * gain)
+    return out
+
+
+def mix(*parts):
+    n = max(len(p) for p in parts)
+    return [sum(p[i] for p in parts if i < len(p)) for i in range(n)]
+
+
+def concat(*parts):
+    out = []
+    for p in parts:
+        out.extend(p)
+    return out
+
+
+def subset_font(src, dst, text):
+    """Subset a TTF to Latin-1 plus `text` (needs fontTools)."""
+    from fontTools import subset
+    opts = subset.Options()
+    opts.name_IDs = ["*"]
+    opts.notdef_outline = True
+    opts.layout_features = []
+    font = subset.load_font(src, opts)
+    s = subset.Subsetter(opts)
+    s.populate(text="".join(chr(c) for c in range(0x20, 0x7F)) + "".join(chr(c) for c in range(0xA0, 0x100)) + text)
+    s.subset(font)
+    subset.save_font(font, dst, opts)