Edit mover patterns from the SMC-PAD and save the corner aims.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
jimmyandCursor committed 2026-10-21 15:53:22 +13:00
1 parent 1b181640dd
commit b1181e6f28
8 files changed
+859

No files matched your search

+1
View File
@@ -0,0 +1 @@
"""Web editor for mover patterns, driven by the SMC-PAD and the page."""
+73
View File
@@ -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())
+386
View File
@@ -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
+141
View File
@@ -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()
+53
View File
@@ -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; }
+127
View File
@@ -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();
+53
View File
@@ -0,0 +1,53 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Patterns</title>
<link rel="stylesheet" href="/app.css">
</head>
<body>
<main>
<h1>Patterns</h1>
<p class="meta" id="meta">Connecting…</p>
<div class="corners" id="corners">
<button type="button" data-corner="front_left">Front left<small></small></button>
<button type="button" data-corner="front_right">Front right<small></small></button>
<button type="button" data-corner="back_left">Back left<small></small></button>
<button type="button" data-corner="back_right">Back right<small></small></button>
</div>
<p class="hint">Pad 13 front left, 14 front right, 9 back left, 10 back right.</p>
<label class="slider">Pan <output id="pan-out"></output>
<input id="pan" type="range" min="0" max="255" value="0">
</label>
<label class="slider">Tilt <output id="tilt-out"></output>
<input id="tilt" type="range" min="0" max="255" value="0">
</label>
<label class="slider">Rotate <output id="rot-out"></output>
<input id="rotate" type="range" min="0" max="255" value="0">
</label>
<p class="hint">Knob 7 pan, knob 8 tilt, knob 5 rotate. Focus stays at 255 so the lens can spin.</p>
<div class="modes" id="modes">
<button type="button" data-mode="hold">Hold</button>
<button type="button" data-mode="box">Box</button>
<button type="button" data-mode="cross">Cross</button>
<button type="button" data-mode="circle">Circle</button>
<button type="button" data-mode="figure8">Figure 8</button>
</div>
<div class="row">
<label>Loop
<input id="loop" type="number" min="0.4" max="60" step="0.1" value="6">
s
</label>
<button type="button" id="save">Save</button>
<span id="live"></span>
</div>
<p class="status" id="status"></p>
</main>
<script src="/app.js"></script>
</body>
</html>
+25
View File
@@ -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
}