From b1181e6f28199308b73360a03d648ba39fa5a9d1 Mon Sep 17 00:00:00 2001 From: Jimmy Date: Wed, 21 Oct 2026 15:53:22 +1300 Subject: [PATCH] Edit mover patterns from the SMC-PAD and save the corner aims. Co-authored-by: Cursor --- pattern_pad/__init__.py | 1 + pattern_pad/__main__.py | 73 +++++++ pattern_pad/engine.py | 386 ++++++++++++++++++++++++++++++++++ pattern_pad/server.py | 141 +++++++++++++ pattern_pad/static/app.css | 53 +++++ pattern_pad/static/app.js | 127 +++++++++++ pattern_pad/static/index.html | 53 +++++ shows/pad_pattern.json | 25 +++ 8 files changed, 859 insertions(+) create mode 100644 pattern_pad/__init__.py create mode 100644 pattern_pad/__main__.py create mode 100644 pattern_pad/engine.py create mode 100644 pattern_pad/server.py create mode 100644 pattern_pad/static/app.css create mode 100644 pattern_pad/static/app.js create mode 100644 pattern_pad/static/index.html create mode 100644 shows/pad_pattern.json diff --git a/pattern_pad/__init__.py b/pattern_pad/__init__.py new file mode 100644 index 0000000..49252ce --- /dev/null +++ b/pattern_pad/__init__.py @@ -0,0 +1 @@ +"""Web editor for mover patterns, driven by the SMC-PAD and the page.""" diff --git a/pattern_pad/__main__.py b/pattern_pad/__main__.py new file mode 100644 index 0000000..478e453 --- /dev/null +++ b/pattern_pad/__main__.py @@ -0,0 +1,73 @@ +"""Dev runner: restart the server when Python changes. + +The page reloads itself when static files change, and again after the +server comes back from a Python restart. + + pipenv run pattern +""" + +from __future__ import annotations + +import os +import signal +import subprocess +import sys +import time +from pathlib import Path + +PKG = Path(__file__).resolve().parent +ROOT = PKG.parent + + +def stamp(root: Path, suffix: str) -> dict[str, int]: + found: dict[str, int] = {} + for path in root.rglob(f"*{suffix}"): + if "__pycache__" in path.parts or not path.is_file(): + continue + found[str(path)] = path.stat().st_mtime_ns + return found + + +def stop_child(proc: subprocess.Popen) -> None: + if proc.poll() is not None: + return + proc.send_signal(signal.SIGINT) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + proc.wait() + + +def main() -> int: + os.chdir(ROOT) + cmd = [sys.executable, "-m", "pattern_pad.server", *sys.argv[1:]] + print("pattern editor — reload on Python and page changes", flush=True) + while True: + py = stamp(PKG, ".py") + parent = Path(__file__).stat().st_mtime_ns + proc = subprocess.Popen(cmd) + try: + while proc.poll() is None: + time.sleep(0.25) + if Path(__file__).stat().st_mtime_ns != parent: + stop_child(proc) + os.execv(sys.executable, [sys.executable, "-m", "pattern_pad", *sys.argv[1:]]) + if stamp(PKG, ".py") != py: + print("reload backend", flush=True) + stop_child(proc) + break + else: + code = proc.returncode or 0 + if code not in (0, -signal.SIGINT, 128 + signal.SIGINT): + print(f"server exited ({code})", flush=True) + return code + return 0 + except KeyboardInterrupt: + print("\nstopped", flush=True) + stop_child(proc) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/pattern_pad/engine.py b/pattern_pad/engine.py new file mode 100644 index 0000000..db699b9 --- /dev/null +++ b/pattern_pad/engine.py @@ -0,0 +1,386 @@ +"""Corner aims, SMC-PAD input, and Art-Net output for the pattern editor.""" + +from __future__ import annotations + +import json +import math +import re +import signal +import subprocess +import sys +import threading +import time +from dataclasses import dataclass +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +SCRIPTS = ROOT / "scripts" +if str(SCRIPTS) not in sys.path: + sys.path.insert(0, str(SCRIPTS)) + +from cabaret_movers import ( # noqa: E402 + M1_ADDR, + M2_ADDR, + ArtNetSender, + Mover, + clamp, + discover_artnet_node, +) + +DEFAULT_PATH = ROOT / "shows" / "pad_pattern.json" +FOCUS_FULL = 255 + +# SMC-PAD preset 1. Pad 1 (bottom-left) is note 36, counting right then up. +PAD_NOTES = { + 48: "front_left", # pad 13 + 49: "front_right", # pad 14 + 44: "back_left", # pad 9 + 45: "back_right", # pad 10 +} +CC_PAN = 16 # knob 7 +CC_TILT = 80 # knob 8 +CC_ROTATE = 17 # knob 5 + +CORNERS = ("front_left", "front_right", "back_left", "back_right") +MODES = ("hold", "box", "cross", "circle", "figure8") +ROUTES = { + "box": ("front_left", "front_right", "back_right", "back_left"), + "cross": ("front_left", "back_right", "front_right", "back_left"), + "circle": ("front_left", "front_right", "back_right", "back_left"), +} + +NOTE_ON_RE = re.compile(r"Note on\s+\d+,\s+note (\d+),\s+velocity (\d+)") +CC_RE = re.compile(r"Control change\s+\d+,\s+controller (\d+),\s+value (\d+)") +CLIENT_RE = re.compile(r"^client (\d+): '([^']*)'") +PORT_RE = re.compile(r"^\s+(\d+) '([^']*)'") + + +@dataclass +class Aim: + pan: int = 133 + tilt: int = 113 + rotate: int = 0 + + def clamped(self) -> Aim: + return Aim(clamp(self.pan), clamp(self.tilt), clamp(self.rotate)) + + def as_dict(self) -> dict[str, int]: + return {"pan": self.pan, "tilt": self.tilt, "rotate": self.rotate} + + +def encoder_delta(value: int) -> int: + """Relative encoder step. 1..63 clockwise, 65..127 counter-clockwise.""" + if value <= 0 or value == 64 or value > 127: + return 0 + if value < 64: + return value + return value - 128 + + +def lerp_aim(a: Aim, b: Aim, frac: float) -> Aim: + def mix(x: int, y: int) -> int: + return clamp(x + (y - x) * frac) + + return Aim(mix(a.pan, b.pan), mix(a.tilt, b.tilt), mix(a.rotate, b.rotate)) + + +def ease(frac: float) -> float: + return 0.5 - 0.5 * math.cos(math.pi * frac) + + +class Pattern: + def __init__(self, corners: dict[str, Aim]): + self.corners = corners + self.selected = "front_left" + self.mode = "hold" + self.loop_s = 6.0 + self.t0 = time.monotonic() + self._lock = threading.Lock() + + def select(self, name: str) -> None: + if name not in self.corners: + raise ValueError("Unknown corner") + with self._lock: + self.selected = name + self.mode = "hold" + + def nudge(self, channel: str, delta: int) -> None: + if delta == 0: + return + with self._lock: + aim = self.corners[self.selected] + if channel == "pan": + aim.pan = clamp(aim.pan + delta) + elif channel == "tilt": + aim.tilt = clamp(aim.tilt + delta) + elif channel == "rotate": + aim.rotate = clamp(aim.rotate + delta) + + def set_aim(self, pan: int, tilt: int, rotate: int) -> None: + with self._lock: + aim = self.corners[self.selected] + aim.pan = clamp(pan) + aim.tilt = clamp(tilt) + aim.rotate = clamp(rotate) + + def play(self, mode: str) -> None: + if mode not in MODES: + raise ValueError("Unknown pattern") + with self._lock: + self.mode = mode + self.t0 = time.monotonic() + + def set_loop(self, seconds: float) -> None: + with self._lock: + self.loop_s = max(0.4, float(seconds)) + self.t0 = time.monotonic() + + def sample(self, now: float) -> tuple[Aim, str]: + with self._lock: + if self.mode == "hold": + aim = self.corners[self.selected] + return Aim(aim.pan, aim.tilt, aim.rotate), self.selected.replace("_", " ") + if self.mode == "figure8": + return self._figure8(now), "figure of 8" + aim = self._route(now) + return aim, self._route_label + + def _route(self, now: float) -> Aim: + order = ROUTES[self.mode] + u = ((now - self.t0) / self.loop_s) % 1.0 + x = u * len(order) + i = int(x) % len(order) + frac = x - int(x) + if self.mode == "circle": + frac = ease(frac) + here = order[i].replace("_", " ") + nxt = order[(i + 1) % len(order)].replace("_", " ") + self._route_label = f"{here} → {nxt}" + a = self.corners[order[i]] + b = self.corners[order[(i + 1) % len(order)]] + return lerp_aim(a, b, frac) + + def _figure8(self, now: float) -> Aim: + pans = [self.corners[name].pan for name in CORNERS] + tilts = [self.corners[name].tilt for name in CORNERS] + cx = (min(pans) + max(pans)) / 2.0 + cy = (min(tilts) + max(tilts)) / 2.0 + hw = (max(pans) - min(pans)) / 2.0 + hh = (max(tilts) - min(tilts)) / 2.0 + t = ((now - self.t0) / self.loop_s) % 1.0 * 2.0 * math.pi + return Aim( + clamp(cx + (-math.sin(2.0 * t)) * hw), + clamp(cy + math.cos(t) * hh), + self.corners[self.selected].rotate, + ) + + def snapshot(self) -> dict: + with self._lock: + return { + "corners": {name: self.corners[name].as_dict() for name in CORNERS}, + "loop_s": self.loop_s, + } + + def state(self, now: float) -> dict: + live, label = self.sample(now) + with self._lock: + return { + "selected": self.selected, + "mode": self.mode, + "loop_s": self.loop_s, + "label": label, + "live": live.as_dict(), + "corners": {name: self.corners[name].as_dict() for name in CORNERS}, + } + + +def default_aim() -> Aim: + path = ROOT / "shows" / "mover_positions.json" + try: + down = json.loads(path.read_text())["positions"]["Down"]["m1"] + return Aim(int(down["pan"]), int(down["tilt"]), 0) + except (OSError, KeyError, TypeError, ValueError): + return Aim() + + +def load_pattern(path: Path) -> Pattern: + seed = default_aim() + corners = {name: Aim(seed.pan, seed.tilt, seed.rotate) for name in CORNERS} + loop_s = 6.0 + if path.is_file(): + data = json.loads(path.read_text()) + loop_s = float(data.get("loop_s", loop_s)) + for name in CORNERS: + raw = data.get("corners", {}).get(name, {}) + corners[name] = Aim( + int(raw.get("pan", seed.pan)), + int(raw.get("tilt", seed.tilt)), + int(raw.get("rotate", 0)), + ).clamped() + pattern = Pattern(corners) + pattern.loop_s = max(0.4, loop_s) + return pattern + + +def save_pattern(path: Path, pattern: Pattern) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(pattern.snapshot(), indent=2) + "\n") + + +def list_smc_ports() -> list[tuple[str, str]]: + try: + text = subprocess.check_output(["aconnect", "-l"], text=True, stderr=subprocess.DEVNULL) + except (OSError, subprocess.CalledProcessError): + return [] + found: list[tuple[str, str]] = [] + client_id = "" + client_name = "" + for line in text.splitlines(): + client = CLIENT_RE.match(line) + if client: + client_id = client.group(1) + client_name = client.group(2) + continue + port = PORT_RE.match(line) + if not port or not client_id: + continue + label = f"{client_name} {port.group(2)}".strip() + if "smc-pad" not in label.lower() and "sinco" not in label.lower(): + continue + if "private" in port.group(2).lower(): + continue + found.append((f"{client_id}:{port.group(1)}", label)) + return found + + +def parse_midi_line(line: str) -> tuple[str, int, int] | None: + note = NOTE_ON_RE.search(line) + if note and int(note.group(2)) > 0: + return ("note", int(note.group(1)), int(note.group(2))) + cc = CC_RE.search(line) + if cc: + return ("cc", int(cc.group(1)), int(cc.group(2))) + return None + + +class Studio: + """Holds the pattern, sends Art-Net, and listens to the SMC-PAD.""" + + def __init__(self, pattern: Pattern, sender: ArtNetSender, movers: list[Mover], path: Path, midi_port: str | None, midi_label: str): + self.pattern = pattern + self.sender = sender + self.movers = movers + self.path = path + self.artnet = sender.destination() + self.midi_port = midi_port + self.midi_label = midi_label + self._running = True + self._midi: subprocess.Popen[str] | None = None + self._threads: list[threading.Thread] = [] + self._seen_notes: set[int] = set() + + def state(self) -> dict: + data = self.pattern.state(time.monotonic()) + data["artnet"] = self.artnet + data["midi"] = self.midi_label + data["file"] = str(self.path) + return data + + def apply(self, aim: Aim) -> None: + rgb = (255, 255, 255) + for mover in self.movers: + mover.apply( + pan=aim.pan, + tilt=aim.tilt, + rgb=rgb, + dimmer=255, + focus=FOCUS_FULL, + speed=0, + zoom=0, + rotate=aim.rotate, + ) + + def output_loop(self) -> None: + while self._running: + aim, _label = self.pattern.sample(time.monotonic()) + self.apply(aim) + time.sleep(0.025) + + def handle_midi(self, kind: str, number: int, value: int) -> None: + if kind == "note": + name = PAD_NOTES.get(number) + if name is None: + if number not in self._seen_notes: + self._seen_notes.add(number) + print(f"pad note {number} is not a corner", flush=True) + return + self.pattern.select(name) + return + channel = {CC_PAN: "pan", CC_TILT: "tilt", CC_ROTATE: "rotate"}.get(number) + if channel is None: + return + self.pattern.nudge(channel, encoder_delta(value)) + + def midi_loop(self, port: str) -> None: + self._midi = subprocess.Popen( + ["aseqdump", "-p", port], + stdout=subprocess.PIPE, + stderr=subprocess.DEVNULL, + text=True, + bufsize=1, + ) + assert self._midi.stdout is not None + for line in self._midi.stdout: + if not self._running: + break + parsed = parse_midi_line(line) + if parsed: + self.handle_midi(*parsed) + if self._running and self._midi.poll() not in (None, 0): + self.midi_label = "SMC-PAD disconnected" + print("MIDI input stopped. Is the SMC-PAD still connected?", flush=True) + + def start(self) -> None: + out = threading.Thread(target=self.output_loop, daemon=True) + self._threads.append(out) + out.start() + if self.midi_port: + midi = threading.Thread(target=self.midi_loop, args=(self.midi_port,), daemon=True) + self._threads.append(midi) + midi.start() + + def save(self) -> None: + save_pattern(self.path, self.pattern) + + def close(self) -> None: + self._running = False + midi = self._midi + if midi is not None and midi.poll() is None: + midi.send_signal(signal.SIGINT) + try: + midi.wait(timeout=1.0) + except subprocess.TimeoutExpired: + midi.kill() + for thread in self._threads: + thread.join(timeout=1.0) + self.save() + self.sender.close() + + +def open_studio(path: Path, ip: str | None, universe: int, address: int, address2: int, midi: str | None) -> Studio: + ports = list_smc_ports() + if midi: + midi_port, midi_label = midi, midi + elif ports: + midi_port, midi_label = ports[0] + else: + midi_port, midi_label = None, "SMC-PAD not found" + pattern = load_pattern(path) + node = ip or discover_artnet_node() + sender = ArtNetSender(node, universe=universe) + movers = [Mover(sender, address, "M1"), Mover(sender, address2, "M2")] + studio = Studio(pattern, sender, movers, path, midi_port, midi_label) + print(f"Art-Net → {node} universe {universe} M1 @{address} M2 @{address2}") + print(f"MIDI {midi_label}") + print("Stop QLC+ Art-Net output first. Focus stays at 255 so rotate can spin.") + return studio diff --git a/pattern_pad/server.py b/pattern_pad/server.py new file mode 100644 index 0000000..e8f23f4 --- /dev/null +++ b/pattern_pad/server.py @@ -0,0 +1,141 @@ +"""HTTP server for the pattern editor. Run via `python -m pattern_pad`.""" + +from __future__ import annotations + +import argparse +import json +import signal +import threading +import time +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from pathlib import Path + +from pattern_pad.engine import DEFAULT_PATH, M1_ADDR, M2_ADDR, MODES, ROOT, open_studio + +STATIC = Path(__file__).resolve().parent / "static" +BOOT = str(time.time_ns()) +HOST = "127.0.0.1" +PORT = 8766 + +MIME = { + ".html": "text/html; charset=utf-8", + ".css": "text/css; charset=utf-8", + ".js": "text/javascript; charset=utf-8", + ".svg": "image/svg+xml", +} + + +def static_stamp(directory: Path) -> str: + latest = 0 + if directory.is_dir(): + for path in directory.rglob("*"): + if path.is_file(): + latest = max(latest, path.stat().st_mtime_ns) + return str(latest) + + +def make_handler(studio): + class Handler(BaseHTTPRequestHandler): + protocol_version = "HTTP/1.1" + + def log_message(self, fmt: str, *args) -> None: + return + + def _send(self, code: int, body: bytes, content_type: str) -> None: + self.send_response(code) + self.send_header("Content-Type", content_type) + self.send_header("Content-Length", str(len(body))) + self.send_header("Cache-Control", "no-store") + self.end_headers() + self.wfile.write(body) + + def _json(self, code: int, payload: dict) -> None: + self._send(code, json.dumps(payload).encode(), "application/json") + + def _read_json(self) -> dict: + length = int(self.headers.get("Content-Length", "0") or 0) + if length <= 0: + return {} + raw = self.rfile.read(length) + data = json.loads(raw.decode() or "{}") + if not isinstance(data, dict): + raise ValueError("Expected a JSON object") + return data + + def do_GET(self) -> None: # noqa: N802 + path = self.path.split("?", 1)[0] + if path == "/api/state": + self._json(200, studio.state()) + return + if path == "/api/dev": + self._json(200, {"boot": BOOT, "static": static_stamp(STATIC)}) + return + if path == "/": + path = "/index.html" + file_path = (STATIC / path.lstrip("/")).resolve() + if not str(file_path).startswith(str(STATIC)) or not file_path.is_file(): + self._send(404, b"not found", "text/plain; charset=utf-8") + return + self._send(200, file_path.read_bytes(), MIME.get(file_path.suffix, "application/octet-stream")) + + def do_POST(self) -> None: # noqa: N802 + path = self.path.split("?", 1)[0] + try: + body = self._read_json() + if path == "/api/select": + studio.pattern.select(str(body.get("name", ""))) + elif path == "/api/aim": + studio.pattern.set_aim(int(body["pan"]), int(body["tilt"]), int(body["rotate"])) + elif path == "/api/play": + studio.pattern.play(str(body.get("mode", ""))) + elif path == "/api/loop": + studio.pattern.set_loop(float(body["seconds"])) + elif path == "/api/save": + studio.save() + else: + self._json(404, {"error": "Unknown request"}) + return + except (KeyError, TypeError, ValueError) as exc: + self._json(400, {"error": str(exc) or "Bad request"}) + return + self._json(200, studio.state()) + + return Handler + + +def parse_args(): + p = argparse.ArgumentParser(description="Pattern editor web server") + p.add_argument("--host", default=HOST) + p.add_argument("--port", type=int, default=PORT) + p.add_argument("--ip", default=None, help="Art-Net destination (default: poll the network)") + p.add_argument("--universe", type=int, default=0) + p.add_argument("--address", type=int, default=M1_ADDR, help="M1 DMX start, 1-based") + p.add_argument("--address2", type=int, default=M2_ADDR, help="M2 DMX start, 1-based") + p.add_argument("--midi", default=None, help="ALSA port, for example 128:0") + p.add_argument("--file", type=Path, default=DEFAULT_PATH, help="Corner file to load and save") + return p.parse_args() + + +def main() -> None: + args = parse_args() + path = args.file if args.file.is_absolute() else ROOT / args.file + studio = open_studio(path, args.ip, args.universe, args.address, args.address2, args.midi) + studio.start() + ThreadingHTTPServer.allow_reuse_address = True + httpd = ThreadingHTTPServer((args.host, args.port), make_handler(studio)) + + def stop(_signum, _frame) -> None: + threading.Thread(target=httpd.shutdown, daemon=True).start() + + signal.signal(signal.SIGINT, stop) + signal.signal(signal.SIGTERM, stop) + print(f"http://{args.host}:{args.port}", flush=True) + try: + httpd.serve_forever() + finally: + httpd.server_close() + studio.close() + + +if __name__ == "__main__": + main() diff --git a/pattern_pad/static/app.css b/pattern_pad/static/app.css new file mode 100644 index 0000000..b0327f2 --- /dev/null +++ b/pattern_pad/static/app.css @@ -0,0 +1,53 @@ +:root { color-scheme: dark; } +* { box-sizing: border-box; } +body { + margin: 0; + font: 16px/1.4 system-ui, sans-serif; + background: #12141a; + color: #eee; +} +main { max-width: 36rem; margin: 0 auto; padding: 1.25rem 1.25rem 3rem; } +h1 { font-size: 1.35rem; font-weight: 650; margin: 0 0 0.2rem; } +.meta, .hint, .status { color: #8e98a8; font-size: 0.85rem; } +.meta { margin: 0 0 1rem; word-break: break-all; } +.hint { margin: 0.35rem 0 1rem; } +.corners, .modes, .row { display: flex; gap: 0.5rem; } +.corners { display: grid; grid-template-columns: 1fr 1fr; } +button, input { font: inherit; color: inherit; } +button { + border: 1px solid #3a4050; + background: #1c2030; + border-radius: 8px; + padding: 0.7rem 0.8rem; + cursor: pointer; + text-align: left; +} +.corners button small { + display: block; + color: #8e98a8; + font-size: 0.75rem; + margin-top: 0.2rem; +} +button.active { + background: #f0a030; + border-color: #f0a030; + color: #1a1206; + font-weight: 650; +} +button.active small { color: #5c4316; } +.modes { flex-wrap: wrap; margin: 0.4rem 0 1rem; } +.modes button { text-align: center; } +.slider { display: block; margin: 0.75rem 0; } +.slider output { float: right; font-variant-numeric: tabular-nums; } +input[type="range"] { width: 100%; margin-top: 0.25rem; } +.row { align-items: center; margin-top: 0.5rem; } +.row label { display: flex; align-items: center; gap: 0.35rem; } +input[type="number"] { + width: 4.5rem; + border: 1px solid #3a4050; + background: #1c2030; + border-radius: 8px; + padding: 0.45rem 0.5rem; +} +#live { margin-left: auto; font-variant-numeric: tabular-nums; color: #d5dbe6; } +.status { min-height: 1.2em; } diff --git a/pattern_pad/static/app.js b/pattern_pad/static/app.js new file mode 100644 index 0000000..250ab62 --- /dev/null +++ b/pattern_pad/static/app.js @@ -0,0 +1,127 @@ +const $ = (id) => document.getElementById(id); + +const pan = $("pan"); +const tilt = $("tilt"); +const rotate = $("rotate"); +const loop = $("loop"); +let dragging = false; +let seenDev = null; +let devDown = false; + +function paint(data, writeSliders) { + $("meta").textContent = `${data.artnet} · ${data.midi}`; + for (const button of document.querySelectorAll("#corners button")) { + const name = button.dataset.corner; + const aim = data.corners[name]; + button.classList.toggle("active", name === data.selected); + button.querySelector("small").textContent = `pan ${aim.pan} tilt ${aim.tilt} rot ${aim.rotate}`; + } + for (const button of document.querySelectorAll("#modes button")) { + button.classList.toggle("active", button.dataset.mode === data.mode); + } + if (writeSliders) { + const aim = data.corners[data.selected]; + pan.value = aim.pan; + tilt.value = aim.tilt; + rotate.value = aim.rotate; + } + $("pan-out").textContent = pan.value; + $("tilt-out").textContent = tilt.value; + $("rot-out").textContent = rotate.value; + if (document.activeElement !== loop) loop.value = data.loop_s; + const live = data.live; + $("live").textContent = `${data.label} ${live.pan} / ${live.tilt} / ${live.rotate}`; +} + +async function post(url, body) { + const res = await fetch(url, { + method: "POST", + headers: {"Content-Type": "application/json"}, + body: JSON.stringify(body || {}), + }); + const data = await res.json(); + if (!res.ok) throw new Error(data.error || "request failed"); + paint(data, !dragging); + return data; +} + +function sendAim() { + $("pan-out").textContent = pan.value; + $("tilt-out").textContent = tilt.value; + $("rot-out").textContent = rotate.value; + post("/api/aim", { + pan: Number(pan.value), + tilt: Number(tilt.value), + rotate: Number(rotate.value), + }).catch((err) => { + $("status").textContent = err.message; + }); +} + +for (const input of [pan, tilt, rotate]) { + input.addEventListener("pointerdown", () => { + dragging = true; + }); + input.addEventListener("input", sendAim); +} +window.addEventListener("pointerup", () => { + dragging = false; +}); + +$("corners").addEventListener("click", (ev) => { + const button = ev.target.closest("button"); + if (!button) return; + post("/api/select", {name: button.dataset.corner}).catch((err) => { + $("status").textContent = err.message; + }); +}); + +$("modes").addEventListener("click", (ev) => { + const button = ev.target.closest("button"); + if (!button) return; + post("/api/play", {mode: button.dataset.mode}).catch((err) => { + $("status").textContent = err.message; + }); +}); + +loop.addEventListener("change", () => { + post("/api/loop", {seconds: Number(loop.value)}).catch((err) => { + $("status").textContent = err.message; + }); +}); + +$("save").addEventListener("click", () => { + post("/api/save").then(() => { + $("status").textContent = "Saved"; + }).catch((err) => { + $("status").textContent = err.message; + }); +}); + +async function poll() { + try { + const data = await fetch("/api/state", {cache: "no-store"}).then((res) => res.json()); + paint(data, !dragging); + } catch { + $("meta").textContent = "Reconnecting…"; + } + setTimeout(poll, 200); +} + +async function watchDev() { + try { + const dev = await fetch("/api/dev", {cache: "no-store"}).then((res) => res.json()); + if (devDown || (seenDev && (dev.boot !== seenDev.boot || dev.static !== seenDev.static))) { + location.reload(); + return; + } + seenDev = dev; + devDown = false; + } catch { + devDown = seenDev !== null; + } + setTimeout(watchDev, 400); +} + +poll(); +watchDev(); diff --git a/pattern_pad/static/index.html b/pattern_pad/static/index.html new file mode 100644 index 0000000..f4cbb13 --- /dev/null +++ b/pattern_pad/static/index.html @@ -0,0 +1,53 @@ + + + + + +Patterns + + + +
+

Patterns

+

Connecting…

+ +
+ + + + +
+

Pad 13 front left, 14 front right, 9 back left, 10 back right.

+ + + + +

Knob 7 pan, knob 8 tilt, knob 5 rotate. Focus stays at 255 so the lens can spin.

+ +
+ + + + + +
+ +
+ + + +
+

+
+ + + diff --git a/shows/pad_pattern.json b/shows/pad_pattern.json new file mode 100644 index 0000000..66ed3ab --- /dev/null +++ b/shows/pad_pattern.json @@ -0,0 +1,25 @@ +{ + "corners": { + "front_left": { + "pan": 133, + "tilt": 149, + "rotate": 0 + }, + "front_right": { + "pan": 133, + "tilt": 113, + "rotate": 0 + }, + "back_left": { + "pan": 133, + "tilt": 113, + "rotate": 0 + }, + "back_right": { + "pan": 133, + "tilt": 185, + "rotate": 0 + } + }, + "loop_s": 6.0 +}