Add a stage simulator that draws the rig from Art-Net.
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
9b5f6b5bdd
commit
24f9ca300e
10 files changed
+2237
No files matched your search
@@ -0,0 +1 @@
|
||||
"""Stage visualiser that listens for Art-Net."""
|
||||
@@ -0,0 +1,172 @@
|
||||
"""Stage simulator.
|
||||
|
||||
Loads a stage map, patches DMX addresses from a QLC+ show, and listens for
|
||||
Art-Net. Open the printed URL and point QLC+ Art-Net output at this machine.
|
||||
|
||||
python -m simulator
|
||||
python -m simulator --stage stage/map.json --show shows/templeoftechno.qxw
|
||||
python -m simulator --demo
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import math
|
||||
import threading
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
from simulator.artnet import ArtNetNode
|
||||
from simulator.server import Simulator, make_server
|
||||
from simulator.stage import Fixture, apply_show, load_stage
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
def _hsv(hue: float) -> tuple[int, int, int]:
|
||||
hue = hue % 1.0
|
||||
i = int(hue * 6)
|
||||
f = hue * 6 - i
|
||||
q = int(255 * (1 - f))
|
||||
t = int(255 * f)
|
||||
segment = i % 6
|
||||
if segment == 0:
|
||||
return 255, t, 0
|
||||
if segment == 1:
|
||||
return q, 255, 0
|
||||
if segment == 2:
|
||||
return 0, 255, t
|
||||
if segment == 3:
|
||||
return 0, q, 255
|
||||
if segment == 4:
|
||||
return t, 0, 255
|
||||
return 255, 0, q
|
||||
|
||||
|
||||
def _slot(fixture: Fixture, name: str) -> int | None:
|
||||
if fixture.address is None:
|
||||
return None
|
||||
for index, channel in enumerate(fixture.channel_names):
|
||||
if channel.lower() == name.lower():
|
||||
return fixture.address + index
|
||||
return None
|
||||
|
||||
|
||||
def _put(frame: bytearray, fixture: Fixture, name: str, value: int) -> None:
|
||||
slot = _slot(fixture, name)
|
||||
if slot is not None and 0 <= slot < len(frame):
|
||||
frame[slot] = max(0, min(255, value))
|
||||
|
||||
|
||||
def _demo_frame(fixtures: list[Fixture], elapsed: float) -> bytearray:
|
||||
frame = bytearray(512)
|
||||
cans = [fixture for fixture in fixtures if fixture.kind == "can" and fixture.address is not None]
|
||||
cans.sort(key=lambda fixture: fixture.label)
|
||||
# Walk the BCC145 macro: RGBW mix, colour jump, pulse, then gradient.
|
||||
look = int(elapsed / 5) % 4
|
||||
macro = (0, 120, 170, 220)[look]
|
||||
speed = int(40 + (math.sin(elapsed * 0.7) * 0.5 + 0.5) * 180)
|
||||
for index, fixture in enumerate(cans):
|
||||
_put(frame, fixture, "Dimmer", 255)
|
||||
_put(frame, fixture, "Macro", macro)
|
||||
_put(frame, fixture, "Speed", speed)
|
||||
if macro == 0:
|
||||
red, green, blue = _hsv(elapsed * 0.05 + index / max(1, len(cans)))
|
||||
_put(frame, fixture, "Red", red)
|
||||
_put(frame, fixture, "Green", green)
|
||||
_put(frame, fixture, "Blue", blue)
|
||||
movers = [fixture for fixture in fixtures if fixture.kind == "mover" and fixture.address is not None]
|
||||
for index, fixture in enumerate(movers):
|
||||
pan = int(32768 + math.sin(elapsed * 0.6 + index * math.pi) * 9000)
|
||||
pan = max(0, min(65535, pan))
|
||||
tilt = 42000
|
||||
_put(frame, fixture, "Pan", (pan >> 8) & 0xFF)
|
||||
_put(frame, fixture, "Pan Fine", pan & 0xFF)
|
||||
_put(frame, fixture, "Tilt", (tilt >> 8) & 0xFF)
|
||||
_put(frame, fixture, "Tilt Fine", tilt & 0xFF)
|
||||
_put(frame, fixture, "Zoom", 40)
|
||||
_put(frame, fixture, "Center Brightness", 255)
|
||||
color = (255, 40, 0) if index % 2 == 0 else (40, 80, 255)
|
||||
for pixel in range(1, 8):
|
||||
_put(frame, fixture, f"Red {pixel}", color[0])
|
||||
_put(frame, fixture, f"Green {pixel}", color[1])
|
||||
_put(frame, fixture, f"Blue {pixel}", color[2])
|
||||
_put(frame, fixture, "Dynamic Effect", 30 if index % 2 == 0 else 160)
|
||||
_put(frame, fixture, "Lens Rotate", 210 if index % 2 == 0 else 40)
|
||||
return frame
|
||||
|
||||
|
||||
def _demo_loop(node: ArtNetNode, fixtures: list[Fixture], stop: threading.Event) -> None:
|
||||
started = time.monotonic()
|
||||
while not stop.is_set():
|
||||
frame = _demo_frame(fixtures, time.monotonic() - started)
|
||||
node.write(0, frame)
|
||||
stop.wait(0.05)
|
||||
|
||||
|
||||
def _parse_host_port(value: str, default_port: int) -> tuple[str, int]:
|
||||
if ":" not in value:
|
||||
return value, default_port
|
||||
host, port = value.rsplit(":", 1)
|
||||
return host or "0.0.0.0", int(port)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
parser.add_argument("--stage", type=Path, default=ROOT / "stage" / "map.json")
|
||||
parser.add_argument("--show", type=Path, default=ROOT / "shows" / "templeoftechno.qxw")
|
||||
parser.add_argument("--no-show", action="store_true", help="Use addresses stored in the stage file only")
|
||||
parser.add_argument("--http", default="0.0.0.0:8765", help="Web view host:port")
|
||||
parser.add_argument("--artnet", default="0.0.0.0:6454", help="Art-Net listen host:port")
|
||||
parser.add_argument("--demo", action="store_true", help="Play a local look when you want to see the rig without QLC+")
|
||||
args = parser.parse_args()
|
||||
|
||||
stage = load_stage(args.stage)
|
||||
if not args.no_show:
|
||||
if not args.show.is_file():
|
||||
raise SystemExit(f"Show not found: {args.show}")
|
||||
apply_show(stage, args.show)
|
||||
|
||||
http_host, http_port = _parse_host_port(args.http, 8765)
|
||||
artnet_host, artnet_port = _parse_host_port(args.artnet, 6454)
|
||||
node = ArtNetNode(artnet_host, artnet_port)
|
||||
node.start()
|
||||
server = make_server(Simulator(stage, node), http_host, http_port)
|
||||
|
||||
print("Stage simulator", flush=True)
|
||||
print(f" stage: {args.stage}", flush=True)
|
||||
if stage.show:
|
||||
print(f" show: {args.show}", flush=True)
|
||||
print(f" Art-Net {artnet_host}:{artnet_port}", flush=True)
|
||||
print(f" view: http://127.0.0.1:{server.server_address[1]}", flush=True)
|
||||
if stage.output_ip:
|
||||
print(f" QLC+ Art-Net output in this show is {stage.output_ip}.", flush=True)
|
||||
print(" Point that output at this computer (universe 0), or broadcast.", flush=True)
|
||||
for fixture in stage.fixtures:
|
||||
if fixture.dmx is None:
|
||||
print(f" {fixture.label:<4} no address", flush=True)
|
||||
else:
|
||||
print(
|
||||
f" {fixture.label:<4} {fixture.name:<16} universe {fixture.universe} DMX {fixture.dmx}",
|
||||
flush=True,
|
||||
)
|
||||
for warning in stage.warnings:
|
||||
print(f" warning: {warning}", flush=True)
|
||||
|
||||
stop = threading.Event()
|
||||
if args.demo:
|
||||
threading.Thread(target=_demo_loop, args=(node, stage.fixtures, stop), daemon=True).start()
|
||||
print(" demo look is running", flush=True)
|
||||
|
||||
try:
|
||||
server.serve_forever()
|
||||
except KeyboardInterrupt:
|
||||
print("\nStopping.", flush=True)
|
||||
finally:
|
||||
stop.set()
|
||||
server.shutdown()
|
||||
node.close()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,214 @@
|
||||
"""Art-Net receiver. Speaks ArtDMX and answers ArtPoll."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import socket
|
||||
import threading
|
||||
import time
|
||||
from collections import deque
|
||||
|
||||
ARTNET_PORT = 6454
|
||||
HEADER = b"Art-Net\x00"
|
||||
OP_POLL = 0x2000
|
||||
OP_POLL_REPLY = 0x2100
|
||||
OP_DMX = 0x5000
|
||||
|
||||
|
||||
def build_artdmx(channels: bytes, universe: int = 0, sequence: int = 1) -> bytes:
|
||||
"""ArtDMX packet. `channels` is the 0-based DMX frame (up to 512)."""
|
||||
data = bytearray(channels)
|
||||
n = len(data)
|
||||
if n < 2:
|
||||
data.extend(b"\x00" * (2 - n))
|
||||
n = 2
|
||||
if n & 1:
|
||||
data.append(0)
|
||||
n += 1
|
||||
if n > 512:
|
||||
data = data[:512]
|
||||
n = 512
|
||||
pkt = bytearray(18 + n)
|
||||
pkt[0:8] = HEADER
|
||||
pkt[8] = OP_DMX & 0xFF
|
||||
pkt[9] = (OP_DMX >> 8) & 0xFF
|
||||
pkt[11] = 14
|
||||
pkt[12] = sequence & 0xFF
|
||||
pkt[14] = universe & 0xFF
|
||||
pkt[15] = (universe >> 8) & 0x7F
|
||||
pkt[16] = (n >> 8) & 0xFF
|
||||
pkt[17] = n & 0xFF
|
||||
pkt[18 : 18 + n] = data
|
||||
return bytes(pkt)
|
||||
|
||||
|
||||
def parse_artdmx(packet: bytes) -> tuple[int, bytes] | None:
|
||||
"""Return (port-address, dmx) for an ArtDMX packet, else None."""
|
||||
if len(packet) < 18 or not packet.startswith(HEADER):
|
||||
return None
|
||||
opcode = packet[8] | (packet[9] << 8)
|
||||
if opcode != OP_DMX:
|
||||
return None
|
||||
universe = packet[14] | ((packet[15] & 0x7F) << 8)
|
||||
length = (packet[16] << 8) | packet[17]
|
||||
if length < 2 or 18 + length > len(packet):
|
||||
return None
|
||||
return universe, packet[18 : 18 + length]
|
||||
|
||||
|
||||
def parse_opcode(packet: bytes) -> int | None:
|
||||
if len(packet) < 10 or not packet.startswith(HEADER):
|
||||
return None
|
||||
return packet[8] | (packet[9] << 8)
|
||||
|
||||
|
||||
def poll_reply(ip: str) -> bytes:
|
||||
"""Short ArtPollReply so QLC+ can list this node."""
|
||||
pkt = bytearray(239)
|
||||
pkt[0:8] = HEADER
|
||||
pkt[8] = OP_POLL_REPLY & 0xFF
|
||||
pkt[9] = (OP_POLL_REPLY >> 8) & 0xFF
|
||||
pkt[11] = 14
|
||||
parts = [int(part) for part in ip.split(".")]
|
||||
if len(parts) != 4:
|
||||
parts = [127, 0, 0, 1]
|
||||
pkt[12:16] = bytes(parts)
|
||||
pkt[16] = ARTNET_PORT & 0xFF
|
||||
pkt[17] = (ARTNET_PORT >> 8) & 0xFF
|
||||
pkt[19] = 1
|
||||
pkt[25] = 0xD0
|
||||
short = b"Stage sim"
|
||||
pkt[28 : 28 + len(short)] = short
|
||||
long = b"QLC+ stage Art-Net simulator"
|
||||
pkt[46 : 46 + len(long)] = long
|
||||
pkt[175] = 1
|
||||
pkt[176] = 0x80
|
||||
pkt[184] = 0x80
|
||||
return bytes(pkt)
|
||||
|
||||
|
||||
def local_ip_toward(peer: str) -> str:
|
||||
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
try:
|
||||
sock.connect((peer, ARTNET_PORT))
|
||||
return sock.getsockname()[0]
|
||||
except OSError:
|
||||
return "127.0.0.1"
|
||||
finally:
|
||||
sock.close()
|
||||
|
||||
|
||||
class ArtNetNode:
|
||||
"""Holds the latest DMX frame per Art-Net universe."""
|
||||
|
||||
def __init__(self, host: str = "0.0.0.0", port: int = ARTNET_PORT):
|
||||
self.host = host
|
||||
self.port = port
|
||||
self._lock = threading.Lock()
|
||||
self._universes: dict[int, bytearray] = {}
|
||||
self.packets = 0
|
||||
self._times: deque[float] = deque()
|
||||
self.last_rx = 0.0
|
||||
self.last_universe: int | None = None
|
||||
self._sock: socket.socket | None = None
|
||||
self._running = False
|
||||
self._thread: threading.Thread | None = None
|
||||
self._announced = False
|
||||
|
||||
def start(self) -> None:
|
||||
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||||
if hasattr(socket, "SO_REUSEPORT"):
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
|
||||
try:
|
||||
sock.bind((self.host, self.port))
|
||||
except OSError as exc:
|
||||
sock.close()
|
||||
raise OSError(
|
||||
f"Cannot listen for Art-Net on {self.host}:{self.port} ({exc}). "
|
||||
"Close the other program using that port, or pass --artnet-port."
|
||||
) from exc
|
||||
sock.settimeout(0.5)
|
||||
self._sock = sock
|
||||
self._running = True
|
||||
self._thread = threading.Thread(target=self._loop, name="artnet", daemon=True)
|
||||
self._thread.start()
|
||||
|
||||
def close(self) -> None:
|
||||
self._running = False
|
||||
sock = self._sock
|
||||
if sock is not None:
|
||||
try:
|
||||
sock.close()
|
||||
except OSError:
|
||||
pass
|
||||
if self._thread is not None:
|
||||
self._thread.join(timeout=1.5)
|
||||
|
||||
def write(self, universe: int, data: bytes) -> None:
|
||||
with self._lock:
|
||||
buf = self._universes.get(universe)
|
||||
if buf is None:
|
||||
buf = bytearray(512)
|
||||
self._universes[universe] = buf
|
||||
n = min(512, len(data))
|
||||
buf[:n] = data[:n]
|
||||
if n < 512:
|
||||
buf[n:] = b"\x00" * (512 - n)
|
||||
now = time.monotonic()
|
||||
self.packets += 1
|
||||
self.last_rx = now
|
||||
self.last_universe = universe
|
||||
self._times.append(now)
|
||||
|
||||
def snapshot(self) -> dict[int, bytes]:
|
||||
with self._lock:
|
||||
return {universe: bytes(buf) for universe, buf in self._universes.items()}
|
||||
|
||||
def stats(self) -> dict:
|
||||
now = time.monotonic()
|
||||
with self._lock:
|
||||
while self._times and now - self._times[0] > 1.0:
|
||||
self._times.popleft()
|
||||
age = None if self.last_rx == 0 else now - self.last_rx
|
||||
return {
|
||||
"packets": self.packets,
|
||||
"rate": len(self._times),
|
||||
"age": None if age is None else round(age, 3),
|
||||
"universe": self.last_universe,
|
||||
"listen": f"{self.host}:{self.port}",
|
||||
}
|
||||
|
||||
def _loop(self) -> None:
|
||||
sock = self._sock
|
||||
assert sock is not None
|
||||
while self._running:
|
||||
try:
|
||||
packet, addr = sock.recvfrom(2048)
|
||||
except TimeoutError:
|
||||
continue
|
||||
except OSError:
|
||||
break
|
||||
self._handle(packet, addr)
|
||||
|
||||
def _handle(self, packet: bytes, addr: tuple) -> None:
|
||||
opcode = parse_opcode(packet)
|
||||
if opcode == OP_DMX:
|
||||
parsed = parse_artdmx(packet)
|
||||
if parsed is None:
|
||||
return
|
||||
universe, data = parsed
|
||||
self.write(universe, data)
|
||||
if not self._announced:
|
||||
self._announced = True
|
||||
print(
|
||||
f"Art-Net DMX from {addr[0]}:{addr[1]} "
|
||||
f"universe {universe} ({len(data)} channels)",
|
||||
flush=True,
|
||||
)
|
||||
return
|
||||
if opcode == OP_POLL and self._sock is not None:
|
||||
ip = local_ip_toward(addr[0])
|
||||
try:
|
||||
self._sock.sendto(poll_reply(ip), (addr[0], ARTNET_PORT))
|
||||
except OSError:
|
||||
pass
|
||||
@@ -0,0 +1,430 @@
|
||||
"""Turn a DMX frame into colours, beams, and strobe rates.
|
||||
|
||||
Channel order comes from the stage map's fixture definitions. Role names
|
||||
such as Dimmer, Red, Pan, and Zoom select the slots.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
|
||||
from simulator.stage import Fixture, Stage
|
||||
|
||||
_PIXEL = re.compile(r"^(red|green|blue|white) (\d+)$", re.IGNORECASE)
|
||||
|
||||
PAN_DEGREES = 540.0
|
||||
ZOOM_MIN = 5.0
|
||||
ZOOM_MAX = 45.0
|
||||
|
||||
# BCC145 8ch: strobe 0–7 is open. Small Eye centre strobe 0–3 is open.
|
||||
CAN_STROBE_OPEN = 7
|
||||
MOVER_STROBE_OPEN = 3
|
||||
|
||||
# beamZ BCC145 8ch macro, matching fixtures/beamZ-BCC145.qxf.
|
||||
# 0–50 RGBW mix, 51–100 fixed colour, 101–150 jump, 151–200 pulse,
|
||||
# 201–250 gradient, 251–255 sound. Speed is slow to fast.
|
||||
_PAR_PALETTE = (
|
||||
(255, 0, 0),
|
||||
(255, 96, 0),
|
||||
(255, 200, 0),
|
||||
(255, 255, 0),
|
||||
(0, 255, 0),
|
||||
(0, 255, 160),
|
||||
(0, 64, 255),
|
||||
(140, 0, 255),
|
||||
(255, 0, 160),
|
||||
(255, 255, 255),
|
||||
)
|
||||
|
||||
# Small Eye 43ch colour macros, static masks, and dynamic chases.
|
||||
# Ranges match fixtures/Small-Eye-7-Mover.qxf: 0–9 is no function.
|
||||
_MOVER_MACROS = (
|
||||
(255, 0, 0),
|
||||
(255, 80, 0),
|
||||
(255, 255, 0),
|
||||
(0, 255, 0),
|
||||
(0, 255, 255),
|
||||
(0, 40, 255),
|
||||
(160, 0, 255),
|
||||
(255, 0, 180),
|
||||
(255, 255, 255),
|
||||
(255, 180, 80),
|
||||
)
|
||||
_STATIC_MASKS = (
|
||||
("all", (1, 1, 1, 1, 1, 1, 1)),
|
||||
("odds", (1, 0, 1, 0, 1, 0, 1)),
|
||||
("evens", (0, 1, 0, 1, 0, 1, 0)),
|
||||
("center", (0, 0, 0, 1, 0, 0, 0)),
|
||||
("ends", (1, 0, 0, 0, 0, 0, 1)),
|
||||
("left", (1, 1, 1, 1, 0, 0, 0)),
|
||||
("right", (0, 0, 0, 1, 1, 1, 1)),
|
||||
("one", None),
|
||||
)
|
||||
_DYNAMIC = ("chase", "reverse", "rainbow", "bounce", "pulse", "pairs")
|
||||
_DYNAMIC_LABELS = {
|
||||
"chase": "chase",
|
||||
"reverse": "reverse chase",
|
||||
"rainbow": "rainbow",
|
||||
"bounce": "bounce",
|
||||
"pulse": "pixel pulse",
|
||||
"pairs": "pairs",
|
||||
}
|
||||
|
||||
MOVER_43 = [
|
||||
"Pan", "Pan Fine", "Tilt", "Tilt Fine", "Pan/Tilt Speed", "Lens Rotate", "Zoom", "Focus",
|
||||
"Center Brightness", "Center Strobe",
|
||||
"Red 1", "Green 1", "Blue 1", "White 1",
|
||||
"Red 2", "Green 2", "Blue 2", "White 2",
|
||||
"Red 3", "Green 3", "Blue 3", "White 3",
|
||||
"Red 4", "Green 4", "Blue 4", "White 4",
|
||||
"Red 5", "Green 5", "Blue 5", "White 5",
|
||||
"Red 6", "Green 6", "Blue 6", "White 6",
|
||||
"Red 7", "Green 7", "Blue 7", "White 7",
|
||||
"Colour Temperature", "Colour Macro", "Static Effect", "Dynamic Effect", "Reset",
|
||||
]
|
||||
|
||||
|
||||
def _find(names: list[str], wanted: str) -> int | None:
|
||||
wanted = wanted.lower()
|
||||
for index, name in enumerate(names):
|
||||
if name.lower() == wanted:
|
||||
return index
|
||||
return None
|
||||
|
||||
|
||||
def _value(channels: list[int], names: list[str], wanted: str, default: int = 0) -> int:
|
||||
index = _find(names, wanted)
|
||||
if index is None or index >= len(channels):
|
||||
return default
|
||||
return channels[index]
|
||||
|
||||
|
||||
def _pixels(channels: list[int], names: list[str], dimmer: int) -> list[list[int]]:
|
||||
groups: dict[int, dict[str, int]] = {}
|
||||
for index, name in enumerate(names):
|
||||
match = _PIXEL.match(name.strip())
|
||||
if match is None:
|
||||
continue
|
||||
groups.setdefault(int(match.group(2)), {})[match.group(1).lower()] = index
|
||||
|
||||
def at(group: dict[str, int], color: str) -> int:
|
||||
index = group.get(color)
|
||||
if index is None or index >= len(channels):
|
||||
return 0
|
||||
return channels[index]
|
||||
|
||||
return [
|
||||
list(mix_rgbw(at(groups[number], "red"), at(groups[number], "green"), at(groups[number], "blue"), at(groups[number], "white"), dimmer))
|
||||
for number in sorted(groups)
|
||||
]
|
||||
|
||||
|
||||
def slots_at(frame: bytes, address: int, count: int) -> list[int]:
|
||||
out: list[int] = []
|
||||
for offset in range(count):
|
||||
index = address + offset
|
||||
out.append(frame[index] if 0 <= index < len(frame) else 0)
|
||||
return out
|
||||
|
||||
|
||||
def mix_rgbw(red: int, green: int, blue: int, white: int, dimmer: int) -> tuple[int, int, int]:
|
||||
"""White is a fourth emitter. Dimmer scales the whole mix."""
|
||||
level = max(0, min(255, dimmer)) / 255.0
|
||||
return (
|
||||
int(round(min(255, red + white) * level)),
|
||||
int(round(min(255, green + white) * level)),
|
||||
int(round(min(255, blue + white) * level)),
|
||||
)
|
||||
|
||||
|
||||
def strobe_hz(value: int, open_max: int) -> float:
|
||||
if value <= open_max:
|
||||
return 0.0
|
||||
span = max(1, 255 - open_max)
|
||||
return round(1.0 + (value - open_max) / span * 18.0, 2)
|
||||
|
||||
|
||||
def lens_angle(value: int) -> float:
|
||||
"""Indexed lens position, 0–60°. Spin ranges are not an index."""
|
||||
if value <= 127:
|
||||
return round(value / 127.0 * 60.0, 1)
|
||||
return 0.0
|
||||
|
||||
|
||||
def lens_spin(value: int) -> float:
|
||||
"""Degrees per second. Negative is counter-clockwise.
|
||||
|
||||
0–127 index, 128–188 CCW fast to slow, 189–193 stop, 194–255 CW slow to fast.
|
||||
"""
|
||||
if 128 <= value <= 188:
|
||||
rate = (188 - value) / 60.0
|
||||
return round(-(40.0 + rate * 320.0), 1)
|
||||
if 194 <= value <= 255:
|
||||
rate = (value - 194) / 61.0
|
||||
return round(40.0 + rate * 320.0, 1)
|
||||
return 0.0
|
||||
|
||||
|
||||
def _beam_color(pixels: list[list[int]]) -> tuple[int, int, int]:
|
||||
"""Brightness-weighted mix, so one lit pixel stays its own colour."""
|
||||
red = green = blue = weight = 0.0
|
||||
for pr, pg, pb in pixels:
|
||||
w = pr + pg + pb
|
||||
red += pr * w
|
||||
green += pg * w
|
||||
blue += pb * w
|
||||
weight += w
|
||||
if weight <= 0:
|
||||
return 0, 0, 0
|
||||
return int(round(red / weight)), int(round(green / weight)), int(round(blue / weight))
|
||||
|
||||
|
||||
def _scale(colour: tuple[int, int, int], dimmer: int) -> tuple[int, int, int]:
|
||||
level = max(0, min(255, dimmer)) / 255.0
|
||||
return tuple(int(round(channel * level)) for channel in colour)
|
||||
|
||||
|
||||
def _speed_hz(speed: int, *, slow: float = 0.35, fast: float = 8.0) -> float:
|
||||
return round(slow + max(0, min(255, speed)) / 255.0 * (fast - slow), 2)
|
||||
|
||||
|
||||
def _can_mode(macro: int) -> str:
|
||||
if macro <= 50:
|
||||
return "mix"
|
||||
if macro <= 100:
|
||||
return "fixed"
|
||||
if macro <= 150:
|
||||
return "jump"
|
||||
if macro <= 200:
|
||||
return "pulse"
|
||||
if macro <= 250:
|
||||
return "gradient"
|
||||
return "sound"
|
||||
|
||||
|
||||
def _range_pick(value: int, start: int, count: int) -> tuple[int, float] | None:
|
||||
"""Map value onto `count` bands from `start` through 255. Returns index and 0–1 position."""
|
||||
if value < start or count <= 0:
|
||||
return None
|
||||
span = 256 - start
|
||||
index = min(count - 1, (value - start) * count // span)
|
||||
band = span / count
|
||||
frac = ((value - start) - index * band) / band
|
||||
return index, max(0.0, min(0.999, frac))
|
||||
|
||||
|
||||
def apply_cto(red: int, green: int, blue: int, amount: int) -> tuple[int, int, int]:
|
||||
"""0 leaves the colour alone. Higher values warm it, the way a CTO does."""
|
||||
if amount <= 0:
|
||||
return red, green, blue
|
||||
warm = max(0, min(255, amount)) / 255.0
|
||||
return (
|
||||
red,
|
||||
int(round(green * (1 - 0.35 * warm))),
|
||||
int(round(blue * (1 - 0.75 * warm))),
|
||||
)
|
||||
|
||||
|
||||
def _can_view(
|
||||
dimmer: int,
|
||||
strobe: int,
|
||||
red: int,
|
||||
green: int,
|
||||
blue: int,
|
||||
white: int,
|
||||
macro: int,
|
||||
speed: int,
|
||||
channels: list[int],
|
||||
) -> dict:
|
||||
mode = _can_mode(macro)
|
||||
mixed = mix_rgbw(red, green, blue, white, dimmer)
|
||||
peak = mix_rgbw(red, green, blue, white, 255)
|
||||
if peak == (0, 0, 0):
|
||||
peak = (255, 255, 255)
|
||||
shown = mixed
|
||||
palette = None
|
||||
sound = 0
|
||||
hz = 0.0
|
||||
if mode == "fixed":
|
||||
span = 50
|
||||
index = min(len(_PAR_PALETTE) - 1, max(0, macro - 51) * len(_PAR_PALETTE) // span)
|
||||
shown = _scale(_PAR_PALETTE[index], dimmer)
|
||||
elif mode == "pulse":
|
||||
shown = _scale(peak, dimmer)
|
||||
hz = _speed_hz(speed, slow=0.4, fast=6.0)
|
||||
elif mode in ("jump", "gradient", "sound"):
|
||||
palette = [list(colour) for colour in _PAR_PALETTE]
|
||||
hz = _speed_hz(speed)
|
||||
shown = _scale(_PAR_PALETTE[0], dimmer)
|
||||
if mode == "sound":
|
||||
sound = 2 if macro >= 254 else 1
|
||||
labels = {
|
||||
"mix": "RGBW",
|
||||
"fixed": "fixed colour",
|
||||
"jump": "colour jump",
|
||||
"pulse": "colour pulse",
|
||||
"gradient": "colour gradient",
|
||||
"sound": "sound 2" if sound == 2 else "sound 1",
|
||||
}
|
||||
viewed = {
|
||||
"r": shown[0],
|
||||
"g": shown[1],
|
||||
"b": shown[2],
|
||||
"dimmer": dimmer,
|
||||
"strobe_hz": strobe_hz(strobe, CAN_STROBE_OPEN),
|
||||
"strobe_mode": "strobe" if strobe > CAN_STROBE_OPEN else "open",
|
||||
"effect": mode != "mix",
|
||||
"function": mode,
|
||||
"function_label": labels[mode],
|
||||
"speed_hz": hz,
|
||||
"sound": sound,
|
||||
"channels": channels,
|
||||
}
|
||||
if palette is not None:
|
||||
viewed["palette"] = palette
|
||||
return viewed
|
||||
|
||||
|
||||
def decode_can(channels: list[int]) -> dict:
|
||||
def at(index: int) -> int:
|
||||
return channels[index] if index < len(channels) else 0
|
||||
|
||||
return _can_view(at(0), at(1), at(2), at(3), at(4), at(5), at(6), at(7), channels)
|
||||
|
||||
|
||||
def decode_named(channels: list[int], names: list[str], *, kind: str) -> dict:
|
||||
"""Read a fixture using the channel names from the stage map."""
|
||||
if kind == "mover" or (_find(names, "Pan") is not None and _find(names, "Tilt") is not None):
|
||||
return _decode_mover_named(channels, names)
|
||||
return _decode_can_named(channels, names)
|
||||
|
||||
|
||||
def _decode_can_named(channels: list[int], names: list[str]) -> dict:
|
||||
dimmer = 255 if _find(names, "Dimmer") is None else _value(channels, names, "Dimmer")
|
||||
return _can_view(
|
||||
dimmer,
|
||||
_value(channels, names, "Strobe"),
|
||||
_value(channels, names, "Red"),
|
||||
_value(channels, names, "Green"),
|
||||
_value(channels, names, "Blue"),
|
||||
_value(channels, names, "White"),
|
||||
_value(channels, names, "Macro"),
|
||||
_value(channels, names, "Speed"),
|
||||
channels,
|
||||
)
|
||||
|
||||
|
||||
def _mover_strobe(value: int) -> tuple[float, str]:
|
||||
"""Centre strobe: open, linear strobe, then three random-strobe bands."""
|
||||
if value <= MOVER_STROBE_OPEN:
|
||||
return 0.0, "open"
|
||||
if value <= 200:
|
||||
return strobe_hz(value, MOVER_STROBE_OPEN), "strobe"
|
||||
if value <= 215:
|
||||
return 6.0, "random"
|
||||
if value <= 234:
|
||||
return 12.0, "random"
|
||||
return 18.0, "random"
|
||||
|
||||
|
||||
def _decode_mover_named(channels: list[int], names: list[str]) -> dict:
|
||||
pan = (_value(channels, names, "Pan") << 8) | _value(channels, names, "Pan Fine")
|
||||
tilt = (_value(channels, names, "Tilt") << 8) | _value(channels, names, "Tilt Fine")
|
||||
zoom = _value(channels, names, "Zoom")
|
||||
rotate = _value(channels, names, "Lens Rotate")
|
||||
dimmer = 255 if _find(names, "Center Brightness") is None else _value(channels, names, "Center Brightness")
|
||||
strobe = _value(channels, names, "Center Strobe")
|
||||
pixels = _pixels(channels, names, dimmer)
|
||||
macro_value = _value(channels, names, "Colour Macro")
|
||||
static_value = _value(channels, names, "Static Effect")
|
||||
dynamic_value = _value(channels, names, "Dynamic Effect")
|
||||
cto = _value(channels, names, "Colour Temperature")
|
||||
macro = _range_pick(macro_value, 10, len(_MOVER_MACROS))
|
||||
static = _range_pick(static_value, 10, len(_STATIC_MASKS))
|
||||
dynamic = _range_pick(dynamic_value, 10, len(_DYNAMIC))
|
||||
|
||||
source = [list(pixel) for pixel in pixels]
|
||||
function = "pixels"
|
||||
label = "pixels"
|
||||
dynamic_name = None
|
||||
speed = 0.0
|
||||
if macro is not None:
|
||||
colour = list(_scale(_MOVER_MACROS[macro[0]], dimmer))
|
||||
source = [colour[:] for _ in range(7)]
|
||||
function = "macro"
|
||||
label = "colour macro"
|
||||
if static is not None or dynamic is not None:
|
||||
if not any(sum(pixel) > 0 for pixel in source):
|
||||
white = list(_scale((255, 255, 255), dimmer))
|
||||
source = [white[:] for _ in range(7)]
|
||||
if static is not None and dynamic is None:
|
||||
name, mask = _STATIC_MASKS[static[0]]
|
||||
if name == "one":
|
||||
pixel = min(6, int(static[1] * 7))
|
||||
mask = tuple(1 if index == pixel else 0 for index in range(7))
|
||||
source = [pixel if mask[index] else [0, 0, 0] for index, pixel in enumerate(source)]
|
||||
function = "static"
|
||||
label = "one pixel" if name == "one" else f"static {name}"
|
||||
if dynamic is not None:
|
||||
dynamic_name = _DYNAMIC[dynamic[0]]
|
||||
speed = round(0.4 + dynamic[1] * 6.0, 2)
|
||||
function = "dynamic"
|
||||
label = _DYNAMIC_LABELS[dynamic_name]
|
||||
|
||||
tinted = [list(apply_cto(pixel[0], pixel[1], pixel[2], cto)) for pixel in source]
|
||||
red, green, blue = _beam_color(tinted)
|
||||
rate, strobe_mode = _mover_strobe(strobe)
|
||||
reset = _value(channels, names, "Reset")
|
||||
pan_speed = _value(channels, names, "Pan/Tilt Speed")
|
||||
pan_deg = (pan - 32768) / 65536.0 * PAN_DEGREES
|
||||
zoom_deg = ZOOM_MIN + (zoom / 255.0) * (ZOOM_MAX - ZOOM_MIN)
|
||||
# Long enough to read on the plan at tilt zero. Tilt stretches the throw.
|
||||
beam_m = 2.2 + (tilt / 65535.0) * 2.5
|
||||
return {
|
||||
"r": red,
|
||||
"g": green,
|
||||
"b": blue,
|
||||
"dimmer": dimmer,
|
||||
"strobe_hz": rate,
|
||||
"strobe_mode": strobe_mode,
|
||||
"effect": function != "pixels",
|
||||
"function": function,
|
||||
"function_label": label,
|
||||
"speed_hz": speed,
|
||||
"dynamic": dynamic_name,
|
||||
"pan_deg": round(pan_deg, 2),
|
||||
"zoom_deg": round(zoom_deg, 2),
|
||||
"beam_m": round(beam_m, 3),
|
||||
"pixels": tinted,
|
||||
"spin_dps": lens_spin(rotate),
|
||||
"lens_deg": lens_angle(rotate),
|
||||
"focus": round(_value(channels, names, "Focus") / 255.0, 3),
|
||||
"move": round(1 - pan_speed / 255.0, 3),
|
||||
"cto": cto,
|
||||
"reset": 200 <= reset <= 205,
|
||||
"channels": channels,
|
||||
}
|
||||
|
||||
|
||||
def decode_mover(channels: list[int]) -> dict:
|
||||
return _decode_mover_named(channels, MOVER_43)
|
||||
|
||||
|
||||
def view_fixture(fixture: Fixture, universes: dict[int, bytes]) -> dict:
|
||||
if fixture.address is None or fixture.universe is None:
|
||||
return {"patched": False, "r": 0, "g": 0, "b": 0, "dimmer": 0, "strobe_hz": 0, "channels": []}
|
||||
count = len(fixture.channel_names) or fixture.channels or (43 if fixture.kind == "mover" else 8)
|
||||
frame = universes.get(fixture.universe, bytes(512))
|
||||
channels = slots_at(frame, fixture.address, count)
|
||||
if fixture.channel_names:
|
||||
viewed = decode_named(channels, fixture.channel_names, kind=fixture.kind)
|
||||
elif fixture.kind == "mover":
|
||||
viewed = decode_mover(channels)
|
||||
else:
|
||||
viewed = decode_can(channels)
|
||||
viewed["patched"] = True
|
||||
return viewed
|
||||
|
||||
|
||||
def view_stage(stage: Stage, universes: dict[int, bytes]) -> dict[str, dict]:
|
||||
return {fixture.id: view_fixture(fixture, universes) for fixture in stage.fixtures}
|
||||
@@ -0,0 +1,106 @@
|
||||
"""HTTP view of the stage. The page polls /api/state."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from pathlib import Path
|
||||
from urllib.parse import urlparse
|
||||
|
||||
from simulator.artnet import ArtNetNode
|
||||
from simulator.decode import view_stage
|
||||
from simulator.stage import Stage, set_heading
|
||||
|
||||
STATIC = Path(__file__).resolve().parent / "static"
|
||||
|
||||
CONTENT_TYPES = {
|
||||
".html": "text/html; charset=utf-8",
|
||||
".js": "text/javascript; charset=utf-8",
|
||||
".css": "text/css; charset=utf-8",
|
||||
}
|
||||
|
||||
|
||||
class Simulator:
|
||||
def __init__(self, stage: Stage, node: ArtNetNode):
|
||||
self.stage = stage
|
||||
self.node = node
|
||||
|
||||
def state(self) -> dict:
|
||||
stats = self.node.stats()
|
||||
stats["fixtures"] = view_stage(self.stage, self.node.snapshot())
|
||||
return stats
|
||||
|
||||
|
||||
def make_handler(sim: Simulator):
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
simulator = sim
|
||||
|
||||
def log_message(self, fmt: str, *args) -> None:
|
||||
return
|
||||
|
||||
def do_POST(self) -> None:
|
||||
path = urlparse(self.path).path
|
||||
if path != "/api/heading":
|
||||
self.send_error(404)
|
||||
return
|
||||
length = int(self.headers.get("Content-Length") or 0)
|
||||
if length <= 0 or length > 4096:
|
||||
self._json({"error": "bad heading"}, 400)
|
||||
return
|
||||
try:
|
||||
payload = json.loads(self.rfile.read(length))
|
||||
fixture = set_heading(
|
||||
self.simulator.stage,
|
||||
str(payload["id"]),
|
||||
direction=payload.get("direction"),
|
||||
zero=payload.get("zero"),
|
||||
)
|
||||
except (KeyError, TypeError, ValueError, json.JSONDecodeError):
|
||||
self._json({"error": "bad heading"}, 400)
|
||||
return
|
||||
self._json({"id": fixture.id, "direction": fixture.direction, "zero": fixture.zero})
|
||||
|
||||
def do_GET(self) -> None:
|
||||
path = urlparse(self.path).path
|
||||
if path == "/api/state":
|
||||
self._json(self.simulator.state())
|
||||
return
|
||||
if path == "/api/stage":
|
||||
self._json(self.simulator.stage.to_json())
|
||||
return
|
||||
if path in ("/", "/index.html"):
|
||||
self._file(STATIC / "index.html")
|
||||
return
|
||||
if path.startswith("/static/"):
|
||||
target = (STATIC / path.removeprefix("/static/")).resolve()
|
||||
if STATIC.resolve() in target.parents or target == STATIC.resolve():
|
||||
self._file(target)
|
||||
return
|
||||
self.send_error(404)
|
||||
|
||||
def _json(self, payload: dict, status: int = 200) -> None:
|
||||
body = json.dumps(payload).encode()
|
||||
self.send_response(status)
|
||||
self.send_header("Content-Type", "application/json")
|
||||
self.send_header("Cache-Control", "no-store")
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
self.end_headers()
|
||||
self.wfile.write(body)
|
||||
|
||||
def _file(self, path: Path) -> None:
|
||||
if not path.is_file():
|
||||
self.send_error(404)
|
||||
return
|
||||
body = path.read_bytes()
|
||||
self.send_response(200)
|
||||
self.send_header("Content-Type", CONTENT_TYPES.get(path.suffix, "application/octet-stream"))
|
||||
self.send_header("Cache-Control", "no-store")
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
self.end_headers()
|
||||
self.wfile.write(body)
|
||||
|
||||
return Handler
|
||||
|
||||
|
||||
def make_server(sim: Simulator, host: str, port: int) -> ThreadingHTTPServer:
|
||||
return ThreadingHTTPServer((host, port), make_handler(sim))
|
||||
@@ -0,0 +1,283 @@
|
||||
"""Load a stage map and patch it from a QLC+ workspace."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import xml.etree.ElementTree as ET
|
||||
from dataclasses import dataclass, field
|
||||
from pathlib import Path
|
||||
|
||||
_NUMBER = re.compile(r"#\s*0*(\d+)")
|
||||
|
||||
|
||||
@dataclass
|
||||
class FixtureDef:
|
||||
name: str
|
||||
manufacturer: str
|
||||
model: str
|
||||
mode: str
|
||||
channels: list[str]
|
||||
|
||||
|
||||
@dataclass
|
||||
class Fixture:
|
||||
id: str
|
||||
label: str
|
||||
kind: str
|
||||
x: float
|
||||
y: float
|
||||
universe: int | None = None
|
||||
address: int | None = None # 0-based, same as the QLC+ workspace file
|
||||
channels: int = 0
|
||||
mode: str = ""
|
||||
name: str = ""
|
||||
definition: str = ""
|
||||
channel_names: list[str] = field(default_factory=list)
|
||||
direction: float = 0.0 # cans: beam heading, degrees clockwise from +Y
|
||||
zero: float = 0.0 # movers: heading at pan centre, same degrees
|
||||
|
||||
@property
|
||||
def dmx(self) -> int | None:
|
||||
"""1-based DMX start address."""
|
||||
if self.address is None:
|
||||
return None
|
||||
return self.address + 1
|
||||
|
||||
def to_json(self) -> dict:
|
||||
return {
|
||||
"id": self.id,
|
||||
"label": self.label,
|
||||
"kind": self.kind,
|
||||
"x": self.x,
|
||||
"y": self.y,
|
||||
"universe": self.universe,
|
||||
"address": self.address,
|
||||
"dmx": self.dmx,
|
||||
"channels": self.channels,
|
||||
"mode": self.mode,
|
||||
"name": self.name or self.label,
|
||||
"def": self.definition,
|
||||
"channel_names": self.channel_names,
|
||||
"direction": self.direction,
|
||||
"zero": self.zero,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class Stage:
|
||||
building_width: float
|
||||
origin: str
|
||||
fixtures: list[Fixture]
|
||||
name: str = "xchc"
|
||||
show: str | None = None
|
||||
output_ip: str | None = None
|
||||
path: Path | None = None
|
||||
warnings: list[str] = field(default_factory=list)
|
||||
|
||||
def to_json(self) -> dict:
|
||||
return {
|
||||
"name": self.name,
|
||||
"building_width": self.building_width,
|
||||
"origin": self.origin,
|
||||
"show": self.show,
|
||||
"output_ip": self.output_ip,
|
||||
"fixtures": [fixture.to_json() for fixture in self.fixtures],
|
||||
"warnings": self.warnings,
|
||||
}
|
||||
|
||||
|
||||
def _local(tag: str) -> str:
|
||||
return tag.rsplit("}", 1)[-1]
|
||||
|
||||
|
||||
def _text(element: ET.Element, name: str, default: str = "") -> str:
|
||||
for child in element:
|
||||
if _local(child.tag) == name and child.text:
|
||||
return child.text.strip()
|
||||
return default
|
||||
|
||||
|
||||
def _definitions(data: dict) -> dict[str, FixtureDef]:
|
||||
found: dict[str, FixtureDef] = {}
|
||||
for name, raw in data.get("definitions", {}).items():
|
||||
found[str(name)] = FixtureDef(
|
||||
name=str(name),
|
||||
manufacturer=str(raw.get("manufacturer") or ""),
|
||||
model=str(raw.get("model") or ""),
|
||||
mode=str(raw.get("mode") or ""),
|
||||
channels=[str(channel) for channel in raw.get("channels") or []],
|
||||
)
|
||||
return found
|
||||
|
||||
|
||||
def load_stage(path: Path) -> Stage:
|
||||
data = json.loads(path.read_text())
|
||||
definitions = _definitions(data)
|
||||
fixtures: list[Fixture] = []
|
||||
for key, raw in data.get("fixtures", {}).items():
|
||||
kind = raw.get("kind", "can")
|
||||
if raw.get("address") is not None:
|
||||
address = int(raw["address"])
|
||||
elif raw.get("dmx") is not None:
|
||||
address = int(raw["dmx"]) - 1
|
||||
else:
|
||||
address = None
|
||||
definition = definitions.get(str(raw.get("def") or ""))
|
||||
channel_names = list(definition.channels) if definition else []
|
||||
channels = int(raw.get("channels") or 0) or len(channel_names)
|
||||
if address is not None and channels == 0:
|
||||
channels = 43 if kind == "mover" else 8
|
||||
fixtures.append(
|
||||
Fixture(
|
||||
id=str(key),
|
||||
label=str(raw.get("label", key)),
|
||||
kind=kind,
|
||||
x=float(raw["x"]),
|
||||
y=float(raw["y"]),
|
||||
universe=None if raw.get("universe") is None else int(raw["universe"]),
|
||||
address=None if address is None else int(address),
|
||||
channels=channels,
|
||||
mode=str(raw.get("mode") or (definition.mode if definition else "")),
|
||||
name=str(raw.get("name") or raw.get("label", key)),
|
||||
definition=definition.name if definition else str(raw.get("def") or ""),
|
||||
channel_names=channel_names,
|
||||
direction=float(raw.get("direction") or 0),
|
||||
zero=float(raw.get("zero") or 0),
|
||||
)
|
||||
)
|
||||
return Stage(
|
||||
building_width=float(data.get("building_width", 7.0)),
|
||||
origin=str(data.get("origin", "")),
|
||||
fixtures=fixtures,
|
||||
name=str(data.get("name") or "xchc"),
|
||||
path=Path(path),
|
||||
)
|
||||
|
||||
|
||||
def wrap_degrees(degrees: float) -> int:
|
||||
"""Nearest degree in -179..180. 0 points toward +Y."""
|
||||
return (round(float(degrees)) + 180) % 360 - 180
|
||||
|
||||
|
||||
def set_heading(stage: Stage, fixture_id: str, *, direction: float | None = None, zero: float | None = None) -> Fixture:
|
||||
"""Point a can's direction, or a mover's zero, and store it in the stage file."""
|
||||
fixture = next((item for item in stage.fixtures if item.id == fixture_id), None)
|
||||
if fixture is None:
|
||||
raise KeyError(fixture_id)
|
||||
if fixture.kind == "can":
|
||||
if direction is None:
|
||||
raise ValueError("direction required")
|
||||
fixture.direction = wrap_degrees(direction)
|
||||
_write_number(stage, fixture_id, "direction", fixture.direction)
|
||||
else:
|
||||
if zero is None:
|
||||
raise ValueError("zero required")
|
||||
fixture.zero = wrap_degrees(zero)
|
||||
_write_number(stage, fixture_id, "zero", fixture.zero)
|
||||
return fixture
|
||||
|
||||
|
||||
def _write_number(stage: Stage, fixture_id: str, field_name: str, value: int) -> None:
|
||||
if stage.path is None or not stage.path.is_file():
|
||||
return
|
||||
text = stage.path.read_text()
|
||||
marker = f'"{fixture_id}": {{'
|
||||
start = text.find(marker)
|
||||
if start < 0:
|
||||
return
|
||||
end = text.find("\n }", start)
|
||||
if end < 0:
|
||||
return
|
||||
block = text[start:end]
|
||||
updated, count = re.subn(
|
||||
rf'("{re.escape(field_name)}":\s*)-?\d+(?:\.\d+)?',
|
||||
rf"\g<1>{value}",
|
||||
block,
|
||||
count=1,
|
||||
)
|
||||
if count == 0:
|
||||
updated = block.rstrip() + f',\n "{field_name}": {value}'
|
||||
stage.path.write_text(text[:start] + updated + text[end:])
|
||||
|
||||
|
||||
def _qxw_fixtures(path: Path) -> tuple[list[dict], str | None]:
|
||||
root = ET.parse(path).getroot()
|
||||
output_ip = None
|
||||
fixtures: list[dict] = []
|
||||
for element in root.iter():
|
||||
name = _local(element.tag)
|
||||
if name == "PluginParameters" and output_ip is None:
|
||||
output_ip = element.attrib.get("outputIP") or None
|
||||
if name != "Engine":
|
||||
continue
|
||||
for child in element:
|
||||
if _local(child.tag) != "Fixture":
|
||||
continue
|
||||
fixtures.append(
|
||||
{
|
||||
"name": _text(child, "Name"),
|
||||
"mode": _text(child, "Mode"),
|
||||
"model": _text(child, "Model"),
|
||||
"manufacturer": _text(child, "Manufacturer"),
|
||||
"universe": int(_text(child, "Universe", "0")),
|
||||
"address": int(_text(child, "Address", "0")),
|
||||
"channels": int(_text(child, "Channels", "0")),
|
||||
}
|
||||
)
|
||||
return fixtures, output_ip
|
||||
|
||||
|
||||
def _stage_id_for(patched: dict, stage_ids: set[str]) -> str | None:
|
||||
name = patched["name"]
|
||||
if name in stage_ids:
|
||||
return name
|
||||
match = _NUMBER.search(name)
|
||||
number = int(match.group(1)) if match else None
|
||||
blob = f"{patched['manufacturer']} {patched['model']} {name}".lower()
|
||||
mover = "mover" in blob or "small eye" in blob
|
||||
can = "bcc145" in blob or blob.strip().endswith("can")
|
||||
if number is None:
|
||||
lowered = name.lower()
|
||||
if "front left" in lowered and "M1" in stage_ids:
|
||||
return "M1"
|
||||
if "front right" in lowered and "M2" in stage_ids:
|
||||
return "M2"
|
||||
if "back left" in lowered and "M3" in stage_ids:
|
||||
return "M3"
|
||||
if "back right" in lowered and "M4" in stage_ids:
|
||||
return "M4"
|
||||
return None
|
||||
if mover:
|
||||
key = f"M{number}"
|
||||
if key in stage_ids:
|
||||
return key
|
||||
if can:
|
||||
key = f"#{number}"
|
||||
if key in stage_ids:
|
||||
return key
|
||||
return None
|
||||
|
||||
|
||||
def apply_show(stage: Stage, show_path: Path) -> None:
|
||||
"""Fill missing DMX addresses from a QLC+ workspace."""
|
||||
patched, output_ip = _qxw_fixtures(show_path)
|
||||
stage.show = show_path.name
|
||||
stage.output_ip = output_ip
|
||||
by_id = {fixture.id: fixture for fixture in stage.fixtures}
|
||||
used: set[str] = set()
|
||||
for item in patched:
|
||||
key = _stage_id_for(item, set(by_id))
|
||||
if key is None or key in used:
|
||||
continue
|
||||
fixture = by_id[key]
|
||||
if fixture.address is None:
|
||||
fixture.universe = item["universe"]
|
||||
fixture.address = item["address"]
|
||||
fixture.channels = item["channels"] or fixture.channels
|
||||
fixture.mode = item["mode"]
|
||||
fixture.name = item["name"]
|
||||
used.add(key)
|
||||
for fixture in stage.fixtures:
|
||||
if fixture.address is None:
|
||||
stage.warnings.append(f"{fixture.label} has no DMX address")
|
||||
@@ -0,0 +1,612 @@
|
||||
const canvas = document.getElementById("stage");
|
||||
const ctx = canvas.getContext("2d");
|
||||
const statusEl = document.getElementById("status");
|
||||
const originEl = document.getElementById("origin");
|
||||
const nameEl = document.getElementById("stage-name");
|
||||
const patchEl = document.getElementById("patch");
|
||||
const listEl = document.getElementById("fixtures");
|
||||
const detailEl = document.getElementById("detail");
|
||||
const detailTitle = document.getElementById("detail-title");
|
||||
const detailMeta = document.getElementById("detail-meta");
|
||||
const channelsEl = document.getElementById("channels");
|
||||
|
||||
let stage = null;
|
||||
let state = { fixtures: {}, age: null, rate: 0, universe: null, packets: 0 };
|
||||
let selected = null;
|
||||
let drag = null;
|
||||
const rows = new Map();
|
||||
|
||||
function luma(r, g, b) {
|
||||
return 0.2126 * r + 0.7152 * g + 0.0722 * b;
|
||||
}
|
||||
|
||||
function hsv(hue, value) {
|
||||
const h = ((hue % 1) + 1) % 1;
|
||||
const i = Math.floor(h * 6);
|
||||
const f = h * 6 - i;
|
||||
const q = value * (1 - f);
|
||||
const t = value * f;
|
||||
const map = [
|
||||
[value, t, 0],
|
||||
[q, value, 0],
|
||||
[0, value, t],
|
||||
[0, q, value],
|
||||
[t, 0, value],
|
||||
[value, 0, q],
|
||||
];
|
||||
const [r, g, b] = map[i % 6];
|
||||
return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
|
||||
}
|
||||
|
||||
const PAR_PALETTE = [
|
||||
[255, 0, 0],
|
||||
[255, 96, 0],
|
||||
[255, 200, 0],
|
||||
[255, 255, 0],
|
||||
[0, 255, 0],
|
||||
[0, 255, 160],
|
||||
[0, 64, 255],
|
||||
[140, 0, 255],
|
||||
[255, 0, 160],
|
||||
[255, 255, 255],
|
||||
];
|
||||
|
||||
const aims = new Map();
|
||||
|
||||
function scaleColour(colour, dimmer) {
|
||||
const level = (dimmer || 0) / 255;
|
||||
return colour.map((channel) => Math.round(channel * level));
|
||||
}
|
||||
|
||||
function paletteColour(live, gradient) {
|
||||
const palette = live.palette && live.palette.length ? live.palette : PAR_PALETTE;
|
||||
const speed = live.speed_hz || 0.35;
|
||||
const phase = performance.now() / 1000 * speed;
|
||||
const index = Math.floor(phase) % palette.length;
|
||||
if (!gradient) return palette[index];
|
||||
const next = palette[(index + 1) % palette.length];
|
||||
const blend = phase - Math.floor(phase);
|
||||
return palette[index].map((channel, slot) => Math.round(channel + (next[slot] - channel) * blend));
|
||||
}
|
||||
|
||||
function canColour(live) {
|
||||
const mode = live.function || "mix";
|
||||
const dimmer = live.dimmer || 0;
|
||||
if (mode === "jump" || mode === "gradient") return scaleColour(paletteColour(live, mode === "gradient"), dimmer);
|
||||
if (mode === "pulse") {
|
||||
const speed = live.speed_hz || 0.4;
|
||||
const wave = 0.5 - 0.5 * Math.cos((performance.now() / 1000) * speed * Math.PI * 2);
|
||||
const depth = 0.05 + 0.95 * wave;
|
||||
return [live.r || 0, live.g || 0, live.b || 0].map((channel) => Math.round(channel * depth));
|
||||
}
|
||||
if (mode === "sound") {
|
||||
const speed = live.speed_hz || 1;
|
||||
const variant = live.sound === 2 ? 2 : 1;
|
||||
const bpm = (variant === 2 ? 156 : 104) * (0.55 + Math.min(speed, 8) / 10);
|
||||
const beat = ((performance.now() / 1000) * bpm / 60) % 1;
|
||||
let hit = beat < 0.08 ? 1 : 0.04;
|
||||
if (variant === 2 && beat > 0.5 && beat < 0.58) hit = 1;
|
||||
const colour = (live.palette && live.palette[variant === 2 ? 4 : 0]) || PAR_PALETTE[variant === 2 ? 4 : 0];
|
||||
return scaleColour(colour, dimmer).map((channel) => Math.round(channel * hit));
|
||||
}
|
||||
return [live.r || 0, live.g || 0, live.b || 0];
|
||||
}
|
||||
|
||||
function effectPixels(live) {
|
||||
const source = (live.pixels || []).map((pixel) => pixel.slice());
|
||||
if (!live.dynamic || !source.length) return source;
|
||||
const count = source.length;
|
||||
const lit = source.find((pixel) => pixel[0] + pixel[1] + pixel[2] > 0);
|
||||
const fallback = lit || scaleColour([255, 255, 255], live.dimmer || 0);
|
||||
const speed = live.speed_hz || 1;
|
||||
const t = (performance.now() / 1000) * speed;
|
||||
return source.map((pixel, index) => {
|
||||
const colour = pixel[0] + pixel[1] + pixel[2] > 0 ? pixel : fallback;
|
||||
if (live.dynamic === "rainbow") {
|
||||
return hsv((t * 0.2 + index / count) % 1, (live.dimmer || 0) / 255);
|
||||
}
|
||||
let level = 1;
|
||||
if (live.dynamic === "chase") level = Math.floor(t) % count === index ? 1 : 0.08;
|
||||
else if (live.dynamic === "reverse") level = Math.floor(t) % count === (count - 1 - index) ? 1 : 0.08;
|
||||
else if (live.dynamic === "bounce") {
|
||||
const span = Math.max(1, count - 1);
|
||||
const tri = Math.abs((t % (2 * span)) - span);
|
||||
level = Math.round(tri) === index ? 1 : 0.08;
|
||||
} else if (live.dynamic === "pulse") level = 0.15 + 0.85 * (0.5 + 0.5 * Math.sin(t * Math.PI * 2));
|
||||
else if (live.dynamic === "pairs") level = Math.floor(t) % 2 === index % 2 ? 1 : 0.08;
|
||||
return colour.map((channel) => Math.round(channel * level));
|
||||
});
|
||||
}
|
||||
|
||||
function mixPixels(pixels) {
|
||||
let red = 0;
|
||||
let green = 0;
|
||||
let blue = 0;
|
||||
let weight = 0;
|
||||
for (const pixel of pixels) {
|
||||
const w = pixel[0] + pixel[1] + pixel[2];
|
||||
red += pixel[0] * w;
|
||||
green += pixel[1] * w;
|
||||
blue += pixel[2] * w;
|
||||
weight += w;
|
||||
}
|
||||
if (weight <= 0) return [0, 0, 0];
|
||||
return [Math.round(red / weight), Math.round(green / weight), Math.round(blue / weight)];
|
||||
}
|
||||
|
||||
function shutter(live) {
|
||||
if (!live.strobe_hz) return 1;
|
||||
const t = performance.now() / 1000;
|
||||
if (live.strobe_mode === "random") {
|
||||
const bucket = Math.floor(t * live.strobe_hz);
|
||||
const noise = Math.abs(Math.sin(bucket * 12.9898) * 43758.5453) % 1;
|
||||
return noise > 0.55 ? 1 : 0;
|
||||
}
|
||||
const period = 1 / live.strobe_hz;
|
||||
return t % period < period * 0.42 ? 1 : 0;
|
||||
}
|
||||
|
||||
function aimed(id, live, zero) {
|
||||
const targetPan = (zero || 0) + (live.pan_deg || 0);
|
||||
const targetBeam = live.beam_m || 0;
|
||||
const now = performance.now() / 1000;
|
||||
let state = aims.get(id);
|
||||
if (!state) {
|
||||
state = { pan: targetPan, beam: targetBeam, t: now };
|
||||
aims.set(id, state);
|
||||
return state;
|
||||
}
|
||||
const dt = Math.min(0.05, Math.max(0, now - state.t));
|
||||
state.t = now;
|
||||
const fast = live.move == null ? 1 : live.move;
|
||||
if (fast > 0.97) {
|
||||
state.pan = targetPan;
|
||||
state.beam = targetBeam;
|
||||
return state;
|
||||
}
|
||||
const tau = 0.05 + (1 - fast) * 1.8;
|
||||
const k = 1 - Math.exp(-dt / tau);
|
||||
state.pan += (targetPan - state.pan) * k;
|
||||
state.beam += (targetBeam - state.beam) * k;
|
||||
return state;
|
||||
}
|
||||
|
||||
function appearance(fixture, live) {
|
||||
const pixels = fixture.kind === "mover" ? effectPixels(live) : null;
|
||||
let [r, g, b] = fixture.kind === "can" ? canColour(live) : pixels && live.dynamic ? mixPixels(pixels) : [live.r || 0, live.g || 0, live.b || 0];
|
||||
const gate = shutter(live);
|
||||
return {
|
||||
r: Math.round(r * gate),
|
||||
g: Math.round(g * gate),
|
||||
b: Math.round(b * gate),
|
||||
dimmer: live.dimmer || 0,
|
||||
pixels: pixels && pixels.map((pixel) => pixel.map((channel) => Math.round(channel * gate))),
|
||||
};
|
||||
}
|
||||
|
||||
function layout(width, height) {
|
||||
const ys = stage.fixtures.map((fixture) => fixture.y);
|
||||
const backY = Math.min(0, ...ys);
|
||||
const depth = Math.max(2.4, ...ys);
|
||||
const padX = 0.85;
|
||||
const padY = 0.7;
|
||||
const x0 = -stage.building_width / 2 - padX;
|
||||
const x1 = stage.building_width / 2 + padX;
|
||||
const y0 = backY - padY;
|
||||
const y1 = depth + padY;
|
||||
const worldW = x1 - x0;
|
||||
const worldH = y1 - y0;
|
||||
const scale = Math.min(width / worldW, height / worldH);
|
||||
const ox = (width - worldW * scale) / 2;
|
||||
const oy = (height - worldH * scale) / 2;
|
||||
return {
|
||||
depth,
|
||||
backY,
|
||||
sx: (x) => ox + (x - x0) * scale,
|
||||
sy: (y) => oy + (y1 - y) * scale,
|
||||
mx: (px) => x0 + (px - ox) / scale,
|
||||
my: (py) => y1 - (py - oy) / scale,
|
||||
};
|
||||
}
|
||||
|
||||
function draw() {
|
||||
if (!stage) return;
|
||||
const dpr = window.devicePixelRatio || 1;
|
||||
const width = canvas.width;
|
||||
const height = canvas.height;
|
||||
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
|
||||
const cssW = width / dpr;
|
||||
const cssH = height / dpr;
|
||||
const view = layout(cssW, cssH);
|
||||
const { sx, sy, depth, backY } = view;
|
||||
|
||||
ctx.clearRect(0, 0, cssW, cssH);
|
||||
ctx.fillStyle = "#121216";
|
||||
ctx.fillRect(0, 0, cssW, cssH);
|
||||
|
||||
const left = sx(-stage.building_width / 2);
|
||||
const right = sx(stage.building_width / 2);
|
||||
const front = sy(depth);
|
||||
const back = sy(backY);
|
||||
ctx.strokeStyle = "#5c5c66";
|
||||
ctx.lineWidth = 2;
|
||||
ctx.strokeRect(left, front, right - left, back - front);
|
||||
|
||||
ctx.strokeStyle = "#3a3a44";
|
||||
ctx.lineWidth = 1;
|
||||
ctx.setLineDash([4, 6]);
|
||||
ctx.beginPath();
|
||||
ctx.moveTo(sx(0), sy(backY - 0.2));
|
||||
ctx.lineTo(sx(0), sy(depth + 0.25));
|
||||
ctx.stroke();
|
||||
ctx.setLineDash([]);
|
||||
|
||||
ctx.fillStyle = "#9a9aa4";
|
||||
ctx.font = "600 13px system-ui, sans-serif";
|
||||
ctx.textAlign = "center";
|
||||
ctx.fillText("AUDIENCE", sx(0), sy(depth + 0.38));
|
||||
ctx.font = "12px system-ui, sans-serif";
|
||||
ctx.fillStyle = "#8d8d96";
|
||||
ctx.fillText("row of 4", sx(0), sy(-0.28));
|
||||
ctx.font = "11px system-ui, sans-serif";
|
||||
ctx.fillText(`${stage.building_width.toFixed(1)} m`, sx(0), front - 8);
|
||||
|
||||
ctx.globalCompositeOperation = "lighter";
|
||||
for (const fixture of stage.fixtures) {
|
||||
const live = state.fixtures[fixture.id] || {};
|
||||
const color = appearance(fixture, live);
|
||||
const dragging = drag && drag.moved && drag.id === fixture.id;
|
||||
const beamColor = dragging && color.r + color.g + color.b < 8 ? { ...color, r: 190, g: 190, b: 200 } : color;
|
||||
if (fixture.kind === "mover") {
|
||||
const fixed = dragging
|
||||
? { pan: (fixture.zero || 0) + (live.pan_deg || 0), beam: Math.max(live.beam_m || 0, 1.6), zoom: live.zoom_deg || 18, focus: 1 - (live.focus || 0) }
|
||||
: null;
|
||||
drawBeam(sx, sy, fixture, live, beamColor, fixed);
|
||||
} else {
|
||||
drawBeam(sx, sy, fixture, live, beamColor, { pan: fixture.direction || 0, beam: 2.2, zoom: 25, focus: 0.35 });
|
||||
}
|
||||
drawGlow(sx, sy, fixture, color);
|
||||
}
|
||||
ctx.globalCompositeOperation = "source-over";
|
||||
|
||||
for (const fixture of stage.fixtures) {
|
||||
const live = state.fixtures[fixture.id] || {};
|
||||
drawBody(sx, sy, fixture, live, appearance(fixture, live));
|
||||
}
|
||||
}
|
||||
|
||||
function drawGlow(sx, sy, fixture, color) {
|
||||
const level = (color.r + color.g + color.b) / (255 * 3);
|
||||
if (level <= 0.01) return;
|
||||
const x = sx(fixture.x);
|
||||
const y = sy(fixture.y);
|
||||
const radius = (fixture.kind === "mover" ? 70 : 54) * (0.45 + level);
|
||||
const gradient = ctx.createRadialGradient(x, y, 2, x, y, radius);
|
||||
gradient.addColorStop(0, `rgba(${color.r},${color.g},${color.b},${0.55 * level + 0.15})`);
|
||||
gradient.addColorStop(1, `rgba(${color.r},${color.g},${color.b},0)`);
|
||||
ctx.fillStyle = gradient;
|
||||
ctx.beginPath();
|
||||
ctx.arc(x, y, radius, 0, Math.PI * 2);
|
||||
ctx.fill();
|
||||
}
|
||||
|
||||
function drawBeam(sx, sy, fixture, live, color, fixed) {
|
||||
const level = (color.r + color.g + color.b) / 255;
|
||||
const length = fixed ? fixed.beam : Math.max(live.beam_m || 0, fixture.kind === "mover" ? 2.2 : 0);
|
||||
if (live.patched === false || level <= 0.02 || !length) return;
|
||||
const aim = fixed || aimed(fixture.id, live, fixture.zero);
|
||||
// DMX focus 0 is a wide wash. Focus 255 holds the zoom angle.
|
||||
// Fixed beams pass spread directly, 0 tight and 1 wide.
|
||||
const spread = fixed ? fixed.focus : 1 - (live.focus || 0);
|
||||
const zoom = fixed ? fixed.zoom : live.zoom_deg || 8;
|
||||
const tight = zoom / 2;
|
||||
const wide = Math.max(tight, 40);
|
||||
const rad = aim.pan * Math.PI / 180;
|
||||
const half = (tight + (wide - tight) * spread) * Math.PI / 180;
|
||||
const tip = [fixture.x + Math.sin(rad) * length, fixture.y + Math.cos(rad) * length];
|
||||
const left = [fixture.x + Math.sin(rad - half) * length, fixture.y + Math.cos(rad - half) * length];
|
||||
const right = [fixture.x + Math.sin(rad + half) * length, fixture.y + Math.cos(rad + half) * length];
|
||||
ctx.beginPath();
|
||||
ctx.moveTo(sx(fixture.x), sy(fixture.y));
|
||||
ctx.lineTo(sx(left[0]), sy(left[1]));
|
||||
ctx.lineTo(sx(right[0]), sy(right[1]));
|
||||
ctx.closePath();
|
||||
const gradient = ctx.createLinearGradient(sx(fixture.x), sy(fixture.y), sx(tip[0]), sy(tip[1]));
|
||||
const alpha = 0.85 * (1 - spread * 0.35);
|
||||
gradient.addColorStop(0, `rgba(${color.r},${color.g},${color.b},${alpha})`);
|
||||
gradient.addColorStop(1, `rgba(${color.r},${color.g},${color.b},0)`);
|
||||
ctx.fillStyle = gradient;
|
||||
ctx.fill();
|
||||
}
|
||||
|
||||
function lensRotation(live) {
|
||||
if (live.spin_dps) return ((performance.now() / 1000) * live.spin_dps * Math.PI) / 180;
|
||||
return ((live.lens_deg || 0) * Math.PI) / 180;
|
||||
}
|
||||
|
||||
function drawBody(sx, sy, fixture, live, color) {
|
||||
const x = sx(fixture.x);
|
||||
const y = sy(fixture.y);
|
||||
const pixels = color.pixels || [];
|
||||
const head = fixture.kind === "mover" && pixels.length ? pixels[0] : [color.r, color.g, color.b];
|
||||
const lit = head[0] + head[1] + head[2] > 8;
|
||||
const size = fixture.kind === "mover" ? 15 : 13;
|
||||
ctx.beginPath();
|
||||
if (fixture.kind === "mover") {
|
||||
ctx.rect(x - size, y - size, size * 2, size * 2);
|
||||
} else {
|
||||
ctx.arc(x, y, size, 0, Math.PI * 2);
|
||||
}
|
||||
ctx.fillStyle = lit ? `rgb(${head[0]},${head[1]},${head[2]})` : "#2a2a30";
|
||||
ctx.fill();
|
||||
ctx.lineWidth = fixture.id === selected ? 2.5 : 1.5;
|
||||
ctx.strokeStyle = fixture.id === selected ? "#fff" : "#c8c8d0";
|
||||
ctx.stroke();
|
||||
|
||||
if (fixture.kind === "mover" && pixels.length > 1) {
|
||||
const ring = pixels.slice(1);
|
||||
const spin = lensRotation(live);
|
||||
ring.forEach((pixel, index) => {
|
||||
const angle = spin + (index / ring.length) * Math.PI * 2 - Math.PI / 2;
|
||||
const px = x + Math.cos(angle) * (size + 7);
|
||||
const py = y + Math.sin(angle) * (size + 7);
|
||||
ctx.beginPath();
|
||||
ctx.arc(px, py, 3.5, 0, Math.PI * 2);
|
||||
const on = pixel[0] + pixel[1] + pixel[2] > 0;
|
||||
ctx.fillStyle = on ? `rgb(${pixel[0]},${pixel[1]},${pixel[2]})` : "#333";
|
||||
ctx.fill();
|
||||
});
|
||||
}
|
||||
|
||||
ctx.fillStyle = lit && luma(head[0], head[1], head[2]) > 140 ? "#16161a" : "#f2f2f4";
|
||||
ctx.font = "600 11px system-ui, sans-serif";
|
||||
ctx.textAlign = "center";
|
||||
ctx.textBaseline = "middle";
|
||||
ctx.fillText(fixture.label, x, y);
|
||||
ctx.textBaseline = "alphabetic";
|
||||
}
|
||||
|
||||
function resize() {
|
||||
const rect = canvas.getBoundingClientRect();
|
||||
const dpr = window.devicePixelRatio || 1;
|
||||
canvas.width = Math.max(1, Math.floor(rect.width * dpr));
|
||||
canvas.height = Math.max(1, Math.floor(rect.height * dpr));
|
||||
draw();
|
||||
}
|
||||
|
||||
function swatchColor(fixture, live) {
|
||||
const color = appearance(fixture, live || {});
|
||||
const head = fixture.kind === "mover" && color.pixels && color.pixels[0] ? color.pixels[0] : [color.r, color.g, color.b];
|
||||
if (head[0] + head[1] + head[2] < 8) return "#2a2a30";
|
||||
return `rgb(${head[0]},${head[1]},${head[2]})`;
|
||||
}
|
||||
|
||||
function buildList() {
|
||||
listEl.replaceChildren();
|
||||
rows.clear();
|
||||
for (const fixture of stage.fixtures) {
|
||||
const li = document.createElement("li");
|
||||
li.id = `fx-${fixture.id}`;
|
||||
li.className = fixture.kind;
|
||||
li.dataset.id = fixture.id;
|
||||
const swatch = document.createElement("span");
|
||||
swatch.className = "swatch";
|
||||
const name = document.createElement("span");
|
||||
name.className = "name";
|
||||
name.textContent = fixture.label;
|
||||
const addr = document.createElement("span");
|
||||
addr.className = "addr";
|
||||
addr.textContent = fixture.dmx == null ? "no address" : `DMX ${fixture.dmx}`;
|
||||
li.append(swatch, name, addr);
|
||||
li.addEventListener("click", () => {
|
||||
selected = fixture.id;
|
||||
updateDetail();
|
||||
draw();
|
||||
});
|
||||
listEl.append(li);
|
||||
rows.set(fixture.id, { li, swatch, addr });
|
||||
}
|
||||
}
|
||||
|
||||
function updateList() {
|
||||
for (const fixture of stage.fixtures) {
|
||||
const row = rows.get(fixture.id);
|
||||
const live = state.fixtures[fixture.id] || {};
|
||||
row.swatch.style.background = swatchColor(fixture, live);
|
||||
row.li.classList.toggle("selected", fixture.id === selected);
|
||||
if (!live.patched) row.addr.textContent = "no address";
|
||||
else if (live.function && live.function !== "mix" && live.function !== "pixels") {
|
||||
row.addr.textContent = `DMX ${fixture.dmx} · ${live.function_label || live.function}`;
|
||||
} else row.addr.textContent = `DMX ${fixture.dmx}`;
|
||||
}
|
||||
}
|
||||
|
||||
function updateDetail() {
|
||||
const fixture = stage.fixtures.find((item) => item.id === selected);
|
||||
if (!fixture) {
|
||||
detailEl.hidden = true;
|
||||
return;
|
||||
}
|
||||
const live = state.fixtures[fixture.id] || {};
|
||||
detailEl.hidden = false;
|
||||
detailTitle.textContent = fixture.name || fixture.label;
|
||||
const bits = [];
|
||||
if (fixture.dmx != null) bits.push(`DMX ${fixture.dmx}`);
|
||||
if (fixture.def) bits.push(fixture.def);
|
||||
else if (fixture.mode) bits.push(fixture.mode);
|
||||
if (fixture.kind === "can") bits.push(`direction ${fixture.direction || 0}°`);
|
||||
if (fixture.kind === "mover") bits.push(`zero ${fixture.zero || 0}°`);
|
||||
if (live.function_label && live.function !== "mix" && live.function !== "pixels") bits.push(live.function_label);
|
||||
if (live.speed_hz) bits.push(`${live.speed_hz.toFixed(1)} Hz`);
|
||||
if (live.reset) bits.push("reset");
|
||||
if (fixture.kind === "mover" && live.pan_deg != null) {
|
||||
bits.push(`pan ${live.pan_deg.toFixed(0)}°`);
|
||||
bits.push(`zoom ${(live.zoom_deg || 0).toFixed(0)}°`);
|
||||
if (live.spin_dps) bits.push(`lens ${live.spin_dps > 0 ? "CW" : "CCW"}`);
|
||||
else if (live.lens_deg) bits.push(`lens ${live.lens_deg.toFixed(0)}°`);
|
||||
}
|
||||
detailMeta.textContent = bits.join(" · ");
|
||||
const channels = live.channels || [];
|
||||
channelsEl.replaceChildren();
|
||||
channels.forEach((value, index) => {
|
||||
const row = document.createElement("div");
|
||||
row.className = "channel";
|
||||
const label = document.createElement("span");
|
||||
label.textContent = String(index + 1);
|
||||
const title = document.createElement("span");
|
||||
title.className = "ch-name";
|
||||
title.textContent = (fixture.channel_names && fixture.channel_names[index]) || "";
|
||||
const bar = document.createElement("div");
|
||||
bar.className = "bar";
|
||||
const fill = document.createElement("span");
|
||||
fill.style.width = `${(value / 255) * 100}%`;
|
||||
bar.append(fill);
|
||||
const num = document.createElement("span");
|
||||
num.textContent = String(value);
|
||||
row.append(label, title, bar, num);
|
||||
channelsEl.append(row);
|
||||
});
|
||||
}
|
||||
|
||||
function updateStatus() {
|
||||
const age = state.age;
|
||||
const live = age != null && age < 1.5;
|
||||
statusEl.classList.toggle("live", live);
|
||||
if (!live) {
|
||||
statusEl.textContent = state.packets ? "Art-Net idle" : "waiting for Art-Net";
|
||||
return;
|
||||
}
|
||||
const universe = state.universe == null ? "" : ` · universe ${state.universe}`;
|
||||
statusEl.textContent = `Art-Net ${state.rate} fps${universe}`;
|
||||
}
|
||||
|
||||
async function poll() {
|
||||
try {
|
||||
state = await fetch("/api/state").then((response) => response.json());
|
||||
updateStatus();
|
||||
updateList();
|
||||
if (selected) updateDetail();
|
||||
} catch {
|
||||
statusEl.classList.remove("live");
|
||||
statusEl.textContent = "view disconnected";
|
||||
}
|
||||
}
|
||||
|
||||
function frame() {
|
||||
draw();
|
||||
if (stage) updateList();
|
||||
requestAnimationFrame(frame);
|
||||
}
|
||||
|
||||
function pointerMetres(event) {
|
||||
const rect = canvas.getBoundingClientRect();
|
||||
const view = layout(rect.width, rect.height);
|
||||
return {
|
||||
x: view.mx(event.clientX - rect.left),
|
||||
y: view.my(event.clientY - rect.top),
|
||||
};
|
||||
}
|
||||
|
||||
function fixtureAt(x, y) {
|
||||
let best = null;
|
||||
let bestDist = 0.55;
|
||||
for (const fixture of stage.fixtures) {
|
||||
const dist = Math.hypot(fixture.x - x, fixture.y - y);
|
||||
if (dist < bestDist) {
|
||||
best = fixture;
|
||||
bestDist = dist;
|
||||
}
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
function wrapDegrees(degrees) {
|
||||
return ((Math.round(degrees) + 180) % 360 + 360) % 360 - 180;
|
||||
}
|
||||
|
||||
function aimDegrees(fixture, x, y) {
|
||||
return wrapDegrees(Math.atan2(x - fixture.x, y - fixture.y) * 180 / Math.PI);
|
||||
}
|
||||
|
||||
function saveHeading(fixture) {
|
||||
const body = fixture.kind === "can"
|
||||
? { id: fixture.id, direction: fixture.direction }
|
||||
: { id: fixture.id, zero: fixture.zero };
|
||||
fetch("/api/heading", {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify(body),
|
||||
}).catch(() => {});
|
||||
}
|
||||
|
||||
canvas.addEventListener("pointerdown", (event) => {
|
||||
if (!stage || event.button !== 0) return;
|
||||
const { x, y } = pointerMetres(event);
|
||||
const fixture = fixtureAt(x, y);
|
||||
selected = fixture ? fixture.id : null;
|
||||
drag = fixture ? { id: fixture.id, moved: false } : null;
|
||||
if (drag) canvas.setPointerCapture(event.pointerId);
|
||||
canvas.style.cursor = fixture ? "grabbing" : "default";
|
||||
updateList();
|
||||
updateDetail();
|
||||
});
|
||||
|
||||
canvas.addEventListener("pointermove", (event) => {
|
||||
if (!stage) return;
|
||||
const { x, y } = pointerMetres(event);
|
||||
if (!drag) {
|
||||
canvas.style.cursor = fixtureAt(x, y) ? "grab" : "default";
|
||||
return;
|
||||
}
|
||||
const fixture = stage.fixtures.find((item) => item.id === drag.id);
|
||||
if (!fixture) return;
|
||||
if (!drag.moved && Math.hypot(x - fixture.x, y - fixture.y) < 0.2) return;
|
||||
drag.moved = true;
|
||||
const heading = aimDegrees(fixture, x, y);
|
||||
if (fixture.kind === "can") fixture.direction = heading;
|
||||
else {
|
||||
const live = state.fixtures[fixture.id] || {};
|
||||
fixture.zero = wrapDegrees(heading - (live.pan_deg || 0));
|
||||
}
|
||||
updateDetail();
|
||||
});
|
||||
|
||||
canvas.addEventListener("pointerup", () => {
|
||||
if (!drag) return;
|
||||
const fixture = stage.fixtures.find((item) => item.id === drag.id);
|
||||
const moved = drag.moved;
|
||||
drag = null;
|
||||
canvas.style.cursor = "grab";
|
||||
if (fixture && moved) {
|
||||
aims.delete(fixture.id);
|
||||
saveHeading(fixture);
|
||||
}
|
||||
updateDetail();
|
||||
});
|
||||
|
||||
canvas.addEventListener("pointercancel", () => {
|
||||
drag = null;
|
||||
canvas.style.cursor = "default";
|
||||
});
|
||||
|
||||
window.addEventListener("resize", resize);
|
||||
|
||||
fetch("/api/stage")
|
||||
.then((response) => response.json())
|
||||
.then((loaded) => {
|
||||
stage = loaded;
|
||||
nameEl.textContent = stage.name || "xchc";
|
||||
document.title = stage.name || "xchc";
|
||||
originEl.textContent = stage.origin || "";
|
||||
const show = stage.show ? stage.show : "stage file";
|
||||
const target = stage.output_ip ? ` · QLC+ output ${stage.output_ip}` : "";
|
||||
patchEl.textContent = `${show}${target}`;
|
||||
buildList();
|
||||
resize();
|
||||
poll();
|
||||
setInterval(poll, 50);
|
||||
requestAnimationFrame(frame);
|
||||
})
|
||||
.catch(() => {
|
||||
statusEl.textContent = "could not load the stage";
|
||||
});
|
||||
@@ -0,0 +1,31 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>xchc</title>
|
||||
<link rel="stylesheet" href="/static/style.css">
|
||||
</head>
|
||||
<body>
|
||||
<header>
|
||||
<div class="titles">
|
||||
<h1 id="stage-name">xchc</h1>
|
||||
<p id="origin"></p>
|
||||
</div>
|
||||
<p id="status" class="pill">waiting for Art-Net</p>
|
||||
</header>
|
||||
<main>
|
||||
<canvas id="stage" aria-label="Stage plan"></canvas>
|
||||
<aside>
|
||||
<p id="patch" class="meta"></p>
|
||||
<ul id="fixtures"></ul>
|
||||
<section id="detail" hidden>
|
||||
<h2 id="detail-title"></h2>
|
||||
<p id="detail-meta" class="meta"></p>
|
||||
<div id="channels"></div>
|
||||
</section>
|
||||
</aside>
|
||||
</main>
|
||||
<script src="/static/app.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,158 @@
|
||||
:root {
|
||||
color-scheme: dark;
|
||||
--bg: #0e0e10;
|
||||
--panel: #141418;
|
||||
--line: #2c2c34;
|
||||
--text: #eee;
|
||||
--muted: #8d8d96;
|
||||
--live: #3dd68c;
|
||||
--idle: #d7a13a;
|
||||
}
|
||||
|
||||
* { box-sizing: border-box; }
|
||||
|
||||
html, body {
|
||||
margin: 0;
|
||||
height: 100%;
|
||||
background: var(--bg);
|
||||
color: var(--text);
|
||||
font-family: system-ui, sans-serif;
|
||||
}
|
||||
|
||||
body {
|
||||
display: grid;
|
||||
grid-template-rows: auto 1fr;
|
||||
min-height: 100%;
|
||||
}
|
||||
|
||||
header {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: space-between;
|
||||
gap: 16px;
|
||||
padding: 12px 16px;
|
||||
border-bottom: 1px solid var(--line);
|
||||
}
|
||||
|
||||
h1, h2 {
|
||||
margin: 0;
|
||||
font-size: 16px;
|
||||
font-weight: 600;
|
||||
}
|
||||
|
||||
h2 { font-size: 14px; }
|
||||
|
||||
.titles p, .meta {
|
||||
margin: 2px 0 0;
|
||||
color: var(--muted);
|
||||
font-size: 12px;
|
||||
}
|
||||
|
||||
.pill {
|
||||
margin: 0;
|
||||
padding: 4px 10px;
|
||||
border-radius: 999px;
|
||||
background: #2a2418;
|
||||
color: var(--idle);
|
||||
font-size: 12px;
|
||||
font-variant-numeric: tabular-nums;
|
||||
}
|
||||
|
||||
.pill.live {
|
||||
background: #14281e;
|
||||
color: var(--live);
|
||||
}
|
||||
|
||||
main {
|
||||
display: grid;
|
||||
grid-template-columns: 1fr 300px;
|
||||
min-height: 0;
|
||||
}
|
||||
|
||||
canvas {
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
display: block;
|
||||
background: #121216;
|
||||
touch-action: none;
|
||||
}
|
||||
|
||||
aside {
|
||||
border-left: 1px solid var(--line);
|
||||
background: var(--panel);
|
||||
overflow: auto;
|
||||
padding: 12px 14px 24px;
|
||||
}
|
||||
|
||||
ul {
|
||||
list-style: none;
|
||||
margin: 10px 0 0;
|
||||
padding: 0;
|
||||
}
|
||||
|
||||
li {
|
||||
display: grid;
|
||||
grid-template-columns: 18px 1fr auto;
|
||||
gap: 8px;
|
||||
align-items: center;
|
||||
padding: 7px 6px;
|
||||
border-radius: 6px;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
li:hover, li.selected { background: #22222a; }
|
||||
|
||||
.swatch {
|
||||
width: 18px;
|
||||
height: 18px;
|
||||
border-radius: 50%;
|
||||
border: 1px solid #555;
|
||||
background: #222;
|
||||
}
|
||||
|
||||
li.mover .swatch { border-radius: 3px; }
|
||||
|
||||
.name { font-size: 13px; font-weight: 600; }
|
||||
.addr { color: var(--muted); font-size: 11px; }
|
||||
|
||||
#detail { margin-top: 16px; }
|
||||
|
||||
#channels {
|
||||
display: grid;
|
||||
gap: 3px;
|
||||
margin-top: 8px;
|
||||
}
|
||||
|
||||
.channel {
|
||||
display: grid;
|
||||
grid-template-columns: 22px minmax(72px, 1.2fr) 1fr 28px;
|
||||
gap: 6px;
|
||||
align-items: center;
|
||||
font-size: 11px;
|
||||
color: var(--muted);
|
||||
font-variant-numeric: tabular-nums;
|
||||
}
|
||||
|
||||
.ch-name {
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.bar {
|
||||
height: 6px;
|
||||
background: #2a2a32;
|
||||
border-radius: 99px;
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
.bar span {
|
||||
display: block;
|
||||
height: 100%;
|
||||
background: #d0d0d8;
|
||||
}
|
||||
|
||||
@media (max-width: 800px) {
|
||||
main { grid-template-columns: 1fr; grid-template-rows: minmax(280px, 1fr) auto; }
|
||||
aside { border-left: 0; border-top: 1px solid var(--line); max-height: 42vh; }
|
||||
}
|
||||
@@ -0,0 +1,230 @@
|
||||
"""Stage simulator: Art-Net decode and the XCHC patch."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import threading
|
||||
from pathlib import Path
|
||||
from urllib.request import urlopen
|
||||
|
||||
from simulator.artnet import ArtNetNode, build_artdmx, parse_artdmx, parse_opcode
|
||||
from simulator.decode import apply_cto, decode_can, decode_mover, lens_angle, lens_spin, mix_rgbw, view_stage
|
||||
from simulator.server import Simulator, make_server
|
||||
from simulator.stage import apply_show, load_stage, set_heading, wrap_degrees
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
def test_artdmx_roundtrip():
|
||||
frame = bytearray(512)
|
||||
frame[87] = 255
|
||||
frame[89] = 200
|
||||
packet = build_artdmx(frame, universe=0, sequence=3)
|
||||
parsed = parse_artdmx(packet)
|
||||
assert parsed is not None
|
||||
universe, data = parsed
|
||||
assert universe == 0
|
||||
assert data[87] == 255
|
||||
assert data[89] == 200
|
||||
assert parse_opcode(packet) == 0x5000
|
||||
|
||||
|
||||
def test_poll_is_not_dmx():
|
||||
packet = b"Art-Net\x00" + bytes([0x00, 0x20]) + bytes(10)
|
||||
assert parse_opcode(packet) == 0x2000
|
||||
assert parse_artdmx(packet) is None
|
||||
|
||||
|
||||
def test_xchc_patch_matches_the_stage_map():
|
||||
stage = load_stage(ROOT / "stage" / "map.json")
|
||||
apply_show(stage, ROOT / "shows" / "xchc.qxw")
|
||||
by_id = {fixture.id: fixture for fixture in stage.fixtures}
|
||||
assert by_id["#1"].address == 87
|
||||
assert by_id["#1"].dmx == 88
|
||||
assert by_id["#8"].address == 143
|
||||
assert by_id["M1"].address == 0
|
||||
assert by_id["M1"].dmx == 1
|
||||
assert by_id["M2"].address == 44
|
||||
assert by_id["M1"].channels == 43
|
||||
assert by_id["#3"].kind == "can"
|
||||
assert stage.output_ip == "192.168.1.228"
|
||||
assert stage.name == "xchc"
|
||||
assert by_id["#9"].x == -3.5 and by_id["#9"].y == -0.8
|
||||
assert by_id["#11"].y == -6.8 and by_id["#12"].x == 3.5
|
||||
assert by_id["#13"].x == -3.5 and by_id["#15"].x == 3.5
|
||||
assert by_id["#14"].x == 0.0 and by_id["#14"].y == -7.65
|
||||
assert by_id["#1"].address == 87 and by_id["#9"].address == 151
|
||||
assert by_id["#15"].address == 199 and by_id["M1"].address == 0
|
||||
assert by_id["M2"].address == 44 and by_id["#15"].channels == 8
|
||||
assert by_id["M3"].address == 257 and by_id["M3"].channels == 43
|
||||
assert by_id["M3"].x == -1.75 and by_id["M3"].y == -7.65
|
||||
assert by_id["M4"].address == 300 and by_id["M4"].x == 1.75
|
||||
assert by_id["#1"].direction == 90 and by_id["#8"].direction == -90
|
||||
assert by_id["#3"].direction == 0 and by_id["#14"].direction == 0
|
||||
assert by_id["M1"].zero == 0 and by_id["M4"].zero == 0
|
||||
assert stage.warnings == []
|
||||
|
||||
|
||||
def test_can_red_and_white():
|
||||
assert mix_rgbw(0, 0, 0, 255, 255) == (255, 255, 255)
|
||||
viewed = decode_can([255, 0, 255, 0, 0, 0, 0, 0])
|
||||
assert (viewed["r"], viewed["g"], viewed["b"]) == (255, 0, 0)
|
||||
assert viewed["function"] == "mix"
|
||||
assert viewed["strobe_hz"] == 0
|
||||
assert decode_can([255, 255, 255, 0, 0, 0, 0, 0])["strobe_hz"] > 0
|
||||
assert decode_can([128, 0, 0, 0, 0, 0, 120, 0])["effect"] is True
|
||||
|
||||
|
||||
def test_can_macro_functions():
|
||||
assert decode_can([255, 0, 0, 0, 0, 0, 51, 0])["function"] == "fixed"
|
||||
assert decode_can([255, 0, 0, 0, 0, 0, 51, 0])["r"] == 255
|
||||
assert decode_can([0, 0, 0, 0, 0, 0, 80, 0])["r"] == 0
|
||||
jump = decode_can([255, 0, 0, 0, 0, 0, 120, 200])
|
||||
assert jump["function"] == "jump"
|
||||
assert jump["speed_hz"] > 1
|
||||
assert jump["palette"][0] == [255, 0, 0]
|
||||
pulse = decode_can([255, 0, 255, 80, 0, 0, 170, 0])
|
||||
assert pulse["function"] == "pulse"
|
||||
assert pulse["r"] == 255 and pulse["g"] == 80
|
||||
assert decode_can([255, 0, 0, 0, 0, 0, 220, 0])["function"] == "gradient"
|
||||
sound = decode_can([255, 0, 0, 0, 0, 0, 255, 0])
|
||||
assert sound["function"] == "sound" and sound["sound"] == 2
|
||||
|
||||
|
||||
def test_mover_home_points_at_the_audience():
|
||||
channels = [0] * 43
|
||||
channels[0] = 128 # pan coarse, fine 0 → 32768, the centre of 540°
|
||||
channels[2] = 160
|
||||
channels[8] = 255
|
||||
channels[10] = 255 # red on the first pixel
|
||||
viewed = decode_mover(channels)
|
||||
assert viewed["pan_deg"] == 0
|
||||
assert viewed["r"] == 255
|
||||
assert viewed["beam_m"] > 2
|
||||
parked = [0] * 43
|
||||
parked[8] = 255
|
||||
assert decode_mover(parked)["beam_m"] >= 2.2
|
||||
assert lens_spin(0) == 0
|
||||
assert lens_spin(160) < 0
|
||||
assert lens_spin(230) > 0
|
||||
assert lens_angle(0) == 0
|
||||
assert 25 < lens_angle(64) < 35
|
||||
|
||||
|
||||
def test_mover_functions():
|
||||
channels = [0] * 43
|
||||
channels[5] = 230
|
||||
channels[6] = 255
|
||||
channels[8] = 255
|
||||
channels[39] = 20
|
||||
macro = decode_mover(channels)
|
||||
assert macro["function"] == "macro"
|
||||
assert macro["r"] == 255 and macro["b"] == 0
|
||||
assert macro["zoom_deg"] == 45
|
||||
assert macro["spin_dps"] > 0
|
||||
|
||||
channels[40] = 103
|
||||
static = decode_mover(channels)
|
||||
assert static["function"] == "static"
|
||||
assert static["pixels"][3][0] == 255
|
||||
assert static["pixels"][0] == [0, 0, 0]
|
||||
|
||||
channels[41] = 30
|
||||
dynamic = decode_mover(channels)
|
||||
assert dynamic["function"] == "dynamic"
|
||||
assert dynamic["dynamic"] == "chase"
|
||||
assert dynamic["pixels"][0][0] == 255
|
||||
assert dynamic["speed_hz"] > 0
|
||||
|
||||
warm = [0] * 43
|
||||
warm[8] = 255
|
||||
warm[10] = warm[11] = warm[12] = 255
|
||||
warm[38] = 255
|
||||
tinted = decode_mover(warm)
|
||||
assert tinted["r"] == 255
|
||||
assert tinted["b"] < apply_cto(255, 255, 255, 0)[2]
|
||||
assert tinted["b"] < 100
|
||||
|
||||
strobe = [0] * 43
|
||||
strobe[9] = 240
|
||||
assert decode_mover(strobe)["strobe_mode"] == "random"
|
||||
assert decode_mover([0] * 43)["strobe_mode"] == "open"
|
||||
|
||||
|
||||
def test_map_definition_selects_the_channels():
|
||||
stage = load_stage(ROOT / "stage" / "map.json")
|
||||
mover = next(fixture for fixture in stage.fixtures if fixture.id == "M1")
|
||||
can = next(fixture for fixture in stage.fixtures if fixture.id == "#1")
|
||||
assert can.channel_names[:3] == ["Dimmer", "Strobe", "Red"]
|
||||
assert mover.channel_names[5] == "Lens Rotate"
|
||||
assert mover.channel_names[6] == "Zoom"
|
||||
assert mover.mode == "43 Channel"
|
||||
|
||||
frame = bytearray(512)
|
||||
frame[mover.address + mover.channel_names.index("Pan")] = 128
|
||||
frame[mover.address + mover.channel_names.index("Zoom")] = 255
|
||||
frame[mover.address + mover.channel_names.index("Center Brightness")] = 255
|
||||
frame[mover.address + mover.channel_names.index("Red 1")] = 255
|
||||
frame[mover.address + mover.channel_names.index("Lens Rotate")] = 230
|
||||
live = view_stage(stage, {0: bytes(frame)})["M1"]
|
||||
assert live["zoom_deg"] == 45
|
||||
assert live["spin_dps"] > 0
|
||||
assert live["r"] == 255
|
||||
assert live["pan_deg"] == 0
|
||||
|
||||
|
||||
def test_view_reads_universe_bytes():
|
||||
stage = load_stage(ROOT / "stage" / "map.json")
|
||||
apply_show(stage, ROOT / "shows" / "xchc.qxw")
|
||||
frame = bytearray(512)
|
||||
frame[87] = 255
|
||||
frame[89] = 0
|
||||
frame[90] = 255
|
||||
live = view_stage(stage, {0: bytes(frame)})
|
||||
assert (live["#1"]["r"], live["#1"]["g"], live["#1"]["b"]) == (0, 255, 0)
|
||||
assert live["#2"]["dimmer"] == 0
|
||||
|
||||
|
||||
def test_http_state_follows_artnet():
|
||||
stage = load_stage(ROOT / "stage" / "map.json")
|
||||
apply_show(stage, ROOT / "shows" / "xchc.qxw")
|
||||
node = ArtNetNode("127.0.0.1", 0)
|
||||
node.start()
|
||||
server = make_server(Simulator(stage, node), "127.0.0.1", 0)
|
||||
thread = threading.Thread(target=server.serve_forever, daemon=True)
|
||||
thread.start()
|
||||
try:
|
||||
frame = bytearray(512)
|
||||
frame[0] = 128
|
||||
frame[8] = 255
|
||||
frame[10] = 255
|
||||
node.write(0, frame)
|
||||
port = server.server_address[1]
|
||||
with urlopen(f"http://127.0.0.1:{port}/api/state") as response:
|
||||
payload = json.load(response)
|
||||
assert payload["packets"] == 1
|
||||
assert payload["fixtures"]["M1"]["r"] == 255
|
||||
with urlopen(f"http://127.0.0.1:{port}/api/stage") as response:
|
||||
described = json.load(response)
|
||||
assert described["fixtures"][0]["x"] == -3.5
|
||||
finally:
|
||||
server.shutdown()
|
||||
node.close()
|
||||
|
||||
|
||||
def test_heading_is_stored_in_the_map(tmp_path):
|
||||
target = tmp_path / "map.json"
|
||||
target.write_text((ROOT / "stage" / "map.json").read_text())
|
||||
stage = load_stage(target)
|
||||
assert wrap_degrees(270) == -90
|
||||
set_heading(stage, "#1", direction=45)
|
||||
set_heading(stage, "M1", zero=-30)
|
||||
saved = json.loads(target.read_text())
|
||||
assert saved["fixtures"]["#1"]["direction"] == 45
|
||||
assert saved["fixtures"]["#2"]["direction"] == 90
|
||||
assert saved["fixtures"]["M1"]["zero"] == -30
|
||||
assert saved["fixtures"]["M2"]["zero"] == 0
|
||||
again = load_stage(target)
|
||||
by_id = {fixture.id: fixture for fixture in again.fixtures}
|
||||
assert by_id["#1"].direction == 45
|
||||
assert by_id["M1"].zero == -30
|
||||
Reference in new issue
Block a user