Files
qlcplus/scripts/make_cabaret_vc.py
T

1693 lines
50 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""Generate shows/cabaret.qxw — grouped can RGB + per-mover position and RGB."""
from __future__ import annotations
import math
import socket
import subprocess
import time
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
OUT = ROOT / "shows" / "cabaret.qxw"
ARTNET_NODE_FALLBACK = "192.168.1.227"
ARTNET_PORT = 6454
def local_ipv4s() -> list[str]:
"""IPv4 addresses QLC+ will enumerate as Art-Net lines (string-sorted)."""
addrs: set[str] = set()
try:
out = subprocess.check_output(
["ip", "-4", "-o", "addr", "show"], text=True
)
except (OSError, subprocess.CalledProcessError):
out = ""
for line in out.splitlines():
parts = line.split()
if "inet" in parts:
addrs.add(parts[parts.index("inet") + 1].split("/")[0])
if not addrs:
addrs.add("127.0.0.1")
return sorted(addrs)
def artnet_bind_uid_line() -> tuple[str, int]:
addrs = local_ipv4s()
lan = [a for a in addrs if a.startswith("192.168.1.")]
uid = lan[0] if lan else next(
(a for a in addrs if not a.startswith("127.")), addrs[0]
)
return uid, addrs.index(uid)
def discover_artnet_node(local_ip: str, fallback: str = ARTNET_NODE_FALLBACK) -> str:
"""ArtPoll for a dmx-gateway; keep the last known node if none reply."""
poll = bytearray(14)
poll[0:8] = b"Art-Net\x00"
poll[8:10] = bytes((0x00, 0x20))
poll[11] = 14
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.settimeout(0.25)
try:
sock.bind(("", 0))
for dest in ("192.168.1.255", fallback):
try:
sock.sendto(poll, (dest, ARTNET_PORT))
except OSError:
pass
found: list[tuple[str, str]] = []
deadline = time.monotonic() + 1.2
while time.monotonic() < deadline:
try:
data, addr = sock.recvfrom(1024)
except TimeoutError:
continue
except socket.timeout:
continue
if not data.startswith(b"Art-Net") or len(data) < 45:
continue
opcode = data[8] | (data[9] << 8)
if opcode != 0x2100:
continue
ip = addr[0]
if ip in {local_ip, "127.0.0.1"}:
continue
name = data[26:44].split(b"\x00", 1)[0].decode("latin1", "replace")
found.append((ip, name))
for ip, name in found:
if "gateway" in name.lower() or "dmx" in name.lower():
return ip
if found:
return found[0][0]
except OSError:
pass
finally:
sock.close()
return fallback
M1, M2 = 8, 9
# Can groups: 1-2 | 3-4-5-6 | 7-8
GROUP_L = [0, 1]
GROUP_C = [2, 3, 4, 5]
GROUP_R = [6, 7]
# Can 8ch: Dim=0, Strobe=1, R=2, G=3, B=4
# Mover 43ch: Pan/Tilt Speed=4, Focus=7, Center Bright=8, Center Strobe=9; RGB heads 1–7
MOVER_SPEED = 4
MOVER_FOCUS = 7
MOVER_DIM = 8
MOVER_R = [10, 14, 18, 22, 26, 30, 34]
MOVER_G = [11, 15, 19, 23, 27, 31, 35]
MOVER_B = [12, 16, 20, 24, 28, 32, 36]
FOCUS_DEFAULT = 70
CANS = list(range(8))
PALETTE: dict[str, tuple[int, int, int]] = {
"Amber": (255, 90, 0),
"Pink": (255, 50, 160),
"HotBlue": (round(0.30 * 255), 0, 255), # 30% red, 100% blue
"Red": (255, 0, 0),
"Green": (0, 255, 0),
"Blue": (0, 0, 255),
"Orange": (255, 127, 0),
"Yellow": (255, 255, 0),
"Purple": (127, 0, 255),
}
CAN_ODD = [0, 2, 4, 6] # #1,3,5,7
CAN_EVEN = [1, 3, 5, 7] # #2,4,6,8
MOVER_SOLIDS = [
"Amber",
"Pink",
"Red",
"Green",
"Blue",
"Orange",
"Yellow",
"Purple",
]
POSITION_FADE_MS = 2000
# name, M1 (pan, tilt), M2 (pan, tilt), button colour
# Same DMX pan = split (180° hang). Cross left was mirrored (108) = 180° out.
# Down = floor aim (M2 hung 180°: pad 181/145 → DMX 74/145, M1 80/161).
POSITIONS: list[tuple[str, tuple[int, int], tuple[int, int], str]] = [
("Down", (80, 161), (74, 145), "4278236360"),
("Roof", (179, 0), (179, 0), "4282664004"),
("Wall", (179, 36), (179, 36), "4284900966"),
("Mid", (164, 18), (164, 18), "4286611584"),
("Cross", (140, 26), (140, 26), "4281545523"),
("Out", (200, 22), (200, 22), "4279900698"),
]
POSITION_FUNC0 = 100
FIGURE8_MS = 3000
# Absolute EFX per Position (QLC+ 4.12 relative does not hold the look
# when Move is a separate VC button). Collections 140–157, EFX 300+.
MOVE_COL0 = 140
MOVE_EFX0 = 300
MOVE_EIGHT_BG = "4282664004"
MOVE_ZIGZAG_BG = "4281545523"
MOVE_SWIRL_BG = "4286611584"
MOVE_PATTERNS: list[tuple[str, str, int, int, str, dict]] = [
("Figure 8", "Eight", 56, 56, MOVE_EIGHT_BG, {}),
("Zigzag", "Lissajous", 80, 40, MOVE_ZIGZAG_BG, {"x_freq": 3, "cross": True}),
("Swirl", "Circle", 50, 50, MOVE_SWIRL_BG, {}),
]
# Wander is a four-corner pan/tilt chase, not an EFX. M2's pan offsets are
# mirrored so the 180° hang walks the same box on the opposite corner.
WANDER_BG = "4278236360"
WANDER_FUNC0 = 800
WANDER_STEPS: tuple[tuple[tuple[int, int], tuple[int, int]], ...] = (
((10, -8), (-10, 8)),
((10, 8), (-10, -8)),
((-10, 8), (10, -8)),
((-10, -8), (10, 8)),
)
PATTERN_SPEED_MS = 500 # one can-chase step
MOVER_PATTERN_MS = FIGURE8_MS # one mover EFX loop
TAP_MS = 500 # 120 BPM default
SPEED_DURATION_ONE = 6
# Speed Dial visibility: PlusMinus=1 Dial=2 Tap=4 Hours=8 Minutes=16 Seconds=32 Milliseconds=64
SPEED_VIS_FADER = 2 | 32 | 64 # rotary + sec/ms, sized like a slider
SPEED_VIS_TAP = 4 | 32 | 64 # tap button + sec/ms
# Spatial can patterns from shows/xchc.qxw (RGB only; dimmer stays on C Bright).
# Solids 190–198; spatial chasers from 200. Colour is a separate SoloFrame so
# Scanner/Fill/… can run on top (they only black out idle cans).
PATTERN_COLOR_FUNC0 = 190
PATTERN_COLOR_NAMES = [
"Amber",
"Pink",
"Red",
"Green",
"Blue",
"Orange",
"Yellow",
"Purple",
"White",
]
PATTERN_FUNC0 = 200
# Moods: slow colour chases from 400, one palette for cans and one for the
# mover heads (colour only, no pan/tilt). Fade fills the whole step and every
# fixture stays at or above MOOD_FLOOR, so the stage never drops to black.
MOOD_FUNC0 = 400
MOOD_STEP_MS = 6000
MOOD_FLOOR = 0.35
MOOD_PAIRS: list[tuple[str, str, str]] = [
("Citrus", "Orange", "Green"),
("Harbour", "Orange", "Blue"),
("Absinthe", "Green", "Purple"),
("Flamingo", "Pink", "Orange"),
("Velvet", "Purple", "Orange"),
]
# Move Lab: trial mover movements from 700, aimed along the line from Down
# (t=0) toward Wall (t=1). Chasers fade between pan/tilt scenes; EFX loops
# take MOVE_LAB_EFX_MULT steps.
MOVE_LAB_FUNC0 = 700
MOVE_LAB_STEP_MS = 3000
MOVE_LAB_EFX_MULT = 8 # Speed Dial "4" multiplier: one EFX loop = 4 steps
MOVE_LAB_SPOTS: list[tuple[str, float]] = [
("Down", 0.0),
("15%", 0.15),
("30%", 0.3),
("45%", 0.45),
("60%", 0.6),
]
# caption, button colour, kind, args
MOVE_LAB_STYLES: list[tuple[str, str, str, dict]] = [
("Circle", "4282664004", "efx", {"algo": "Circle", "w": 22, "h": 22}),
("Eight", "4281545523", "efx", {"algo": "Eight", "w": 36, "h": 20}),
("Sway", "4286611584", "chase", {"m1": [(14, 0), (-14, 0)], "m2": [(14, 0), (-14, 0)]}),
("Cross Sway", "4284900966", "chase", {"m1": [(14, 0), (-14, 0)], "m2": [(-14, 0), (14, 0)]}),
("Nod", "4279900698", "chase", {"m1": [(0, -12), (0, 12)], "m2": [(0, -12), (0, 12)]}),
(
"Wander",
"4278236360",
"chase",
{
"m1": [(10, -8), (10, 8), (-10, 8), (-10, -8)],
"m2": [(-10, 8), (-10, -8), (10, -8), (10, 8)],
},
),
]
MOVER_STROBE = 9 # Center Strobe: 0–3 open, 4–200 slow→fast, 201+ random
CAN_STROBE = 1 # 0–7 off, 8–255 slow→fast
U_WALK = list(range(8)) # #1 → #2 → row of 4 L→R → #7 → #8
LEFT_CANS = {0, 1, 2, 3}
RIGHT_CANS = {4, 5, 6, 7}
PAIR_SETS = [{0, 7}, {1, 6}, {2, 5}, {3, 4}]
CENTER_RINGS = [{3, 4}, {2, 3, 4, 5}, set(range(8))]
RAINBOW_RGB = [
(255, 0, 0),
(255, 127, 0),
(255, 255, 0),
(0, 255, 0),
(0, 255, 255),
(0, 0, 255),
(127, 0, 255),
(255, 0, 255),
]
LOOK_PAIRS: list[tuple[str, str | None]] = [
("Amber", None),
("Pink", "Amber"),
("Pink", "HotBlue"),
("Red", "Green"),
("Blue", "Green"),
("Blue", "Red"),
("Orange", "Blue"),
("Yellow", "Purple"),
]
def color_label(name: str) -> str:
return "Blue" if name == "HotBlue" else name
def qlc_color(r: int, g: int, b: int) -> str:
return str((0xFF << 24) | (r << 16) | (g << 8) | b)
def mix_color(
a: tuple[int, int, int], b: tuple[int, int, int]
) -> tuple[int, int, int]:
return ((a[0] + b[0]) // 2, (a[1] + b[1]) // 2, (a[2] + b[2]) // 2)
RGB = [
("R", 2, MOVER_R, "4294901760", "Red"),
("G", 3, MOVER_G, "4278255360", "Green"),
("B", 4, MOVER_B, "4278190335", "Blue"),
]
def appearance(
fg: str = "Default",
bg: str = "Default",
frame: str = "Sunken",
) -> str:
return f""" <Appearance>
<FrameStyle>{frame}</FrameStyle>
<ForegroundColor>{fg}</ForegroundColor>
<BackgroundColor>{bg}</BackgroundColor>
<BackgroundImage>None</BackgroundImage>
<Font>Default</Font>
</Appearance>"""
def slider(
wid: int,
caption: str,
x: int,
y: int,
w: int,
h: int,
channels: list[tuple[int, int]],
*,
value: int = 0,
fg: str = "Default",
cng: str = "None",
inverted: bool = False,
high: int = 255,
) -> str:
ch_xml = "\n".join(
f' <Channel Fixture="{fid}">{ch}</Channel>' for fid, ch in channels
)
inv = "true" if inverted else "false"
return f""" <Slider Caption="{caption}" ID="{wid}" WidgetStyle="Slider" InvertedAppearance="{inv}">
<WindowState Visible="True" X="{x}" Y="{y}" Width="{w}" Height="{h}"/>
{appearance(fg=fg)}
<SliderMode ValueDisplayStyle="Exact" ClickAndGoType="{cng}" Monitor="true">Level</SliderMode>
<Reset/>
<Level LowLimit="0" HighLimit="{high}" Value="{value}">
{ch_xml}
</Level>
<Playback>
<Function>4294967295</Function>
</Playback>
</Slider>"""
def speed_dial(
wid: int,
caption: str,
x: int,
y: int,
w: int,
h: int,
time_ms: int,
functions: list[tuple[int, int, int]],
*,
min_ms: int = 40,
max_ms: int = 2000,
visibility: int = SPEED_VIS_FADER,
) -> str:
"""Speed Dial. functions are (func_id, duration_mult, fade_in_mult); 0 = not sent."""
fn_xml = "\n".join(
f' <Function FadeIn="{fade}" FadeOut="0" Duration="{dur}">{fid}</Function>'
for fid, dur, fade in functions
)
return f""" <SpeedDial Caption="{caption}" ID="{wid}">
<WindowState Visible="True" X="{x}" Y="{y}" Width="{w}" Height="{h}"/>
{appearance()}
<Visibility>{visibility}</Visibility>
<AbsoluteValue Minimum="{min_ms}" Maximum="{max_ms}"/>
<Time>{time_ms}</Time>
{fn_xml}
</SpeedDial>"""
def button(
wid: int,
caption: str,
func_id: int,
x: int,
y: int,
w: int,
h: int,
bg: str,
fg: str = "4294967295",
*,
indent: str = " ",
) -> str:
inner = indent + " "
return f"""{indent}<Button Caption="{caption}" ID="{wid}" Icon="">
{inner}<WindowState Visible="True" X="{x}" Y="{y}" Width="{w}" Height="{h}"/>
{inner}<Appearance>
{inner} <FrameStyle>None</FrameStyle>
{inner} <ForegroundColor>{fg}</ForegroundColor>
{inner} <BackgroundColor>{bg}</BackgroundColor>
{inner} <BackgroundImage>None</BackgroundImage>
{inner} <Font>Default</Font>
{inner}</Appearance>
{inner}<Function ID="{func_id}"/>
{inner}<Action>Toggle</Action>
{inner}<Intensity Adjust="False">100</Intensity>
{indent}</Button>"""
def solo_frame(
wid: int,
caption: str,
x: int,
y: int,
w: int,
h: int,
children: str,
*,
show_header: bool = True,
) -> str:
header = "True" if show_header else "False"
return f""" <SoloFrame Caption="{caption}" ID="{wid}">
<Appearance>
<FrameStyle>Sunken</FrameStyle>
<ForegroundColor>Default</ForegroundColor>
<BackgroundColor>Default</BackgroundColor>
<BackgroundImage>None</BackgroundImage>
<Font>Default</Font>
</Appearance>
<WindowState Visible="True" X="{x}" Y="{y}" Width="{w}" Height="{h}"/>
<AllowChildren>True</AllowChildren>
<AllowResize>True</AllowResize>
<ShowHeader>{header}</ShowHeader>
<ShowEnableButton>False</ShowEnableButton>
<Mixing>False</Mixing>
{children}
</SoloFrame>"""
def can_fixture_val(fid: int, r: int, g: int, b: int) -> str:
# Dimmer is owned by the C Bright slider (HTP).
return (
f' <FixtureVal ID="{fid}">'
f"2,{r},3,{g},4,{b},5,0,6,0,7,0"
f"</FixtureVal>"
)
def mover_fixture_val(fid: int, r: int, g: int, b: int) -> str:
# Dimmer is owned by the Mover Bright slider (HTP).
parts: list[int] = []
for i in range(7):
base = 10 + i * 4
parts.extend([base, r, base + 1, g, base + 2, b, base + 3, 0])
return f' <FixtureVal ID="{fid}">{",".join(str(x) for x in parts)}</FixtureVal>'
def look_scene_xml(
func_id: int,
name: str,
can_colors: dict[int, tuple[int, int, int]] | None = None,
mover_colors: dict[int, tuple[int, int, int]] | None = None,
) -> str:
vals: list[str] = []
if can_colors:
vals += [can_fixture_val(fid, *rgb) for fid, rgb in can_colors.items()]
if mover_colors:
vals += [mover_fixture_val(fid, *rgb) for fid, rgb in mover_colors.items()]
return f""" <Function ID="{func_id}" Type="Scene" Name="{name}">
<Speed FadeIn="0" FadeOut="0" Duration="0"/>
{chr(10).join(vals)}
</Function>"""
def look_caption(kind: str, left_n: str, right_n: str | None) -> str:
ll, rl = color_label(left_n), color_label(right_n or left_n)
if right_n is None:
return ll
if kind == "cans":
return f"1-4 {ll} 5-8 {rl}"
return f"Odd {ll} Even {rl}"
def look_values(
kind: str, left: tuple[int, int, int], right: tuple[int, int, int]
) -> tuple[dict[int, tuple[int, int, int]] | None, dict[int, tuple[int, int, int]] | None]:
if kind == "cans":
return {**{i: left for i in range(4)}, **{i: right for i in range(4, 8)}}, None
if kind == "cans_oe":
return {**{i: left for i in CAN_ODD}, **{i: right for i in CAN_EVEN}}, None
raise ValueError(kind)
def build_looks() -> tuple[str, dict[str, list[tuple[str, int, str]]]]:
specs: dict[str, list[tuple[str, int, str]]] = {
"cans": [],
"movers": [],
"cans_oe": [],
}
scenes: list[str] = []
func_id = 0
for kind in ("cans", "cans_oe"):
for left_n, right_n in LOOK_PAIRS:
if kind == "cans_oe" and right_n is None:
continue
left = PALETTE[left_n]
right = PALETTE[right_n] if right_n else left
cans, movers = look_values(kind, left, right)
if right_n is None:
cans = {fid: left for fid in CANS}
movers = None
ll, rl = color_label(left_n), color_label(right_n or left_n)
name = f"{kind} {ll}" if right_n is None else f"{kind} {ll} {rl}"
scenes.append(look_scene_xml(func_id, name, cans, movers))
bg = qlc_color(*left) if right_n is None else qlc_color(*mix_color(left, right))
specs[kind].append((look_caption(kind, left_n, right_n), func_id, bg))
func_id += 1
for color_n in MOVER_SOLIDS:
rgb = PALETTE[color_n]
label = color_label(color_n)
scenes.append(
look_scene_xml(
func_id,
f"movers {label}",
mover_colors={M1: rgb, M2: rgb},
)
)
specs["movers"].append((label, func_id, qlc_color(*rgb)))
func_id += 1
return "\n".join(scenes), specs
def look_scenes_xml() -> str:
xml, _ = build_looks()
return xml
def position_scene_xml() -> str:
blocks = []
for i, (name, m1, m2, _bg) in enumerate(POSITIONS):
poses = {M1: m1, M2: m2}
vals = []
for fid in (M1, M2):
pan, tilt = poses[fid]
vals.append(
f' <FixtureVal ID="{fid}">0,{pan},1,0,2,{tilt},3,0</FixtureVal>'
)
# Duration 0: keep writing while the button is on so Move EFX
# (absolute, offset to this look) has a live base.
blocks.append(
f""" <Function ID="{POSITION_FUNC0 + i}" Type="Scene" Name="Mover {name}">
<Speed FadeIn="{POSITION_FADE_MS}" FadeOut="0" Duration="0"/>
{chr(10).join(vals)}
</Function>"""
)
return "\n".join(blocks)
def position_button_specs() -> list[tuple[str, int, str]]:
return [
(name, POSITION_FUNC0 + i, bg)
for i, (name, _m1, _m2, bg) in enumerate(POSITIONS)
]
def move_pattern_specs() -> dict[str, list[tuple[str, int, str]]]:
_, specs, _ = build_move_functions()
return specs
def efx_block(
func_id: int,
name: str,
algorithm: str,
width: int,
height: int,
fixtures: list[tuple[int, str, int]],
pan: int,
tilt: int,
*,
rotation: int = 0,
x_freq: int = 1,
y_freq: int = 1,
x_phase: int = 0,
y_phase: int = 0,
duration: int = FIGURE8_MS,
) -> str:
# Absolute, like the working XCHC figure-8: Offset is the Position look.
fixture_xml = "\n".join(
f""" <Fixture>
<ID>{fid}</ID>
<Head>0</Head>
<Mode>0</Mode>
<Direction>{direction}</Direction>
<StartOffset>{offset}</StartOffset>
<Intensity>255</Intensity>
</Fixture>"""
for fid, direction, offset in fixtures
)
return f""" <Function ID="{func_id}" Type="EFX" Name="{name}">
{fixture_xml}
<PropagationMode>Parallel</PropagationMode>
<Speed Duration="{duration}" FadeOut="0" FadeIn="0"/>
<Direction>Forward</Direction>
<RunOrder>Loop</RunOrder>
<Algorithm>{algorithm}</Algorithm>
<Width>{width}</Width>
<Height>{height}</Height>
<Rotation>{rotation}</Rotation>
<StartOffset>0</StartOffset>
<Axis Name="X">
<Offset>{pan}</Offset>
<Frequency>{x_freq}</Frequency>
<Phase>{x_phase}</Phase>
</Axis>
<Axis Name="Y">
<Offset>{tilt}</Offset>
<Frequency>{y_freq}</Frequency>
<Phase>{y_phase}</Phase>
</Axis>
</Function>"""
def collection_xml(func_id: int, name: str, steps: list[int]) -> str:
step_xml = "\n".join(
f" <Step Number=\"{i}\">{sid}</Step>" for i, sid in enumerate(steps)
)
return f""" <Function ID="{func_id}" Type="Collection" Name="{name}">
{step_xml}
</Function>"""
def efx_fit(tilt: int, height: int) -> tuple[int, int]:
"""Keep the Position aim. Shrink height to fit; only nudge off a hard stop."""
height = min(int(height), 127)
if tilt <= 0:
h = min(height, 24)
return h, h
if tilt >= 255:
h = min(height, 24)
return 255 - h, h
h = min(height, tilt, 255 - tilt)
if h < 8:
h = min(height, 16)
return max(h, min(255 - h, tilt)), h
return tilt, h
def build_move_functions() -> tuple[str, dict[str, list[tuple[str, int, str]]], list[int]]:
blocks: list[str] = []
specs: dict[str, list[tuple[str, int, str]]] = {}
all_efx: list[int] = []
efx_id = MOVE_EFX0
col_id = MOVE_COL0
for pname, algo, width, height, bg, kw in MOVE_PATTERNS:
specs[pname] = []
cross = bool(kw.get("cross"))
extra = {k: v for k, v in kw.items() if k != "cross"}
for pos_name, m1, m2, _pbg in POSITIONS:
efx_ids: list[int] = []
if m1 == m2:
fixture_specs = (
((M1, "Forward", 0), (M2, "Backward", 180))
if cross
else ((M1, "Forward", 0), (M2, "Forward", 0))
)
y, h = efx_fit(m1[1], height)
blocks.append(
efx_block(
efx_id,
f"{pname} {pos_name}",
algo,
width,
h,
list(fixture_specs),
m1[0],
y,
**extra,
)
)
efx_ids.append(efx_id)
efx_id += 1
else:
for fid, (pan, tilt) in ((M1, m1), (M2, m2)):
direction, start = (
("Backward", 180) if cross and fid == M2 else ("Forward", 0)
)
y, h = efx_fit(tilt, height)
blocks.append(
efx_block(
efx_id,
f"{pname} {pos_name} M{fid - 7}",
algo,
width,
h,
[(fid, direction, start)],
pan,
y,
**extra,
)
)
efx_ids.append(efx_id)
efx_id += 1
blocks.append(collection_xml(col_id, f"{pname} {pos_name}", efx_ids))
specs[pname].append((pos_name, col_id, bg))
all_efx.extend(efx_ids)
col_id += 1
return "\n".join(blocks), specs, all_efx
def move_efx_xml() -> str:
xml, _, _ = build_move_functions()
return xml
def can_pattern_speed_functions() -> list[tuple[int, int, int]]:
# Colour chases fade across the whole step; a dial that only shortens the
# step would cut their fades off and each step would jump.
_, colour, spatial = build_can_patterns()
return [(fid, SPEED_DURATION_ONE, SPEED_DURATION_ONE) for _c, fid, _b in colour] + [
(fid, SPEED_DURATION_ONE, 0) for _c, fid, _b in spatial
]
def mover_pattern_speed_functions() -> list[tuple[int, int, int]]:
_, _, efx_ids = build_move_functions()
_, _, wander_speed = build_wander_functions()
return [(eid, SPEED_DURATION_ONE, 0) for eid in efx_ids] + wander_speed
def tap_tempo_functions() -> list[tuple[int, int, int]]:
return can_pattern_speed_functions() + mover_pattern_speed_functions()
def chaser_xml(
func_id: int,
name: str,
steps: list[int],
*,
fade_in: int,
hold: int,
fade_out: int = 0,
run_order: str = "Loop",
) -> str:
duration = fade_in + hold + fade_out
step_xml = "\n".join(
f' <Step Number="{i}" FadeIn="{fade_in}" Hold="{hold}" FadeOut="{fade_out}">{sid}</Step>'
for i, sid in enumerate(steps)
)
return f""" <Function ID="{func_id}" Type="Chaser" Name="{name}">
<Speed FadeIn="{fade_in}" FadeOut="{fade_out}" Duration="{duration}"/>
<Direction>Forward</Direction>
<RunOrder>{run_order}</RunOrder>
<SpeedModes FadeIn="Common" FadeOut="Common" Duration="Common"/>
{step_xml}
</Function>"""
def cans_lit_scene(
func_id: int, name: str, lit: dict[int, tuple[int, int, int]]
) -> str:
return look_scene_xml(
func_id, name, can_colors={fid: lit.get(fid, (0, 0, 0)) for fid in CANS}
)
def cans_mask_scene(func_id: int, name: str, lit_ids: set[int]) -> str:
"""Mask blend: 255 keeps Pattern Colour, 0 punches a hole. No LTP fight."""
vals = []
for fid in CANS:
if fid in lit_ids:
vals.append(f' <FixtureVal ID="{fid}">2,255,3,255,4,255</FixtureVal>')
else:
vals.append(can_fixture_val(fid, 0, 0, 0))
return f""" <Function ID="{func_id}" Type="Scene" Name="{name}" BlendMode="Mask">
<Speed FadeIn="0" FadeOut="0" Duration="0"/>
{chr(10).join(vals)}
</Function>"""
def pattern_colour_scenes_xml() -> tuple[str, list[tuple[str, int, str]]]:
blocks: list[str] = []
specs: list[tuple[str, int, str]] = []
for i, name in enumerate(PATTERN_COLOR_NAMES):
rgb = (255, 255, 255) if name == "White" else PALETTE[name]
fid = PATTERN_COLOR_FUNC0 + i
blocks.append(
look_scene_xml(
fid,
f"Can Pattern {name}",
can_colors={cid: rgb for cid in CANS},
)
)
specs.append((color_label(name), fid, qlc_color(*rgb)))
return "\n".join(blocks), specs
def build_can_patterns() -> tuple[str, list[tuple[str, int, str]], list[tuple[str, int, str]]]:
"""Spatial masks vs colour chases — colour lives in Pattern Colour so they don't LTP-fight."""
fid = PATTERN_FUNC0
blocks: list[str] = []
colour_specs: list[tuple[str, int, str]] = []
spatial_specs: list[tuple[str, int, str]] = []
def add_scene(name: str, lit: dict[int, tuple[int, int, int]]) -> int:
nonlocal fid
blocks.append(cans_lit_scene(fid, name, lit))
sid = fid
fid += 1
return sid
def add_chaser(
caption: str,
bg: str,
steps: list[int],
dest: list[tuple[str, int, str]],
*,
fade_in: int,
hold: int,
run_order: str = "Loop",
) -> None:
nonlocal fid
blocks.append(
chaser_xml(
fid,
f"Can {caption}",
steps,
fade_in=fade_in,
hold=hold,
run_order=run_order,
)
)
dest.append((caption, fid, bg))
fid += 1
def add_mask(name: str, lit_ids: set[int]) -> int:
nonlocal fid
blocks.append(cans_mask_scene(fid, name, lit_ids))
sid = fid
fid += 1
return sid
off = add_mask("Can Pattern Off", set())
rainbow_steps = []
for step in range(8):
lit = {can: RAINBOW_RGB[(ci + step) % 8] for ci, can in enumerate(U_WALK)}
rainbow_steps.append(add_scene(f"Can Rainbow {step + 1}", lit))
add_chaser("Rainbow", "4280427042", rainbow_steps, colour_specs, fade_in=2000, hold=500)
blue, red = (0, 0, 255), (255, 0, 0)
odd_blue = {i: (blue if i % 2 == 0 else red) for i in CANS}
odd_red = {i: (red if i % 2 == 0 else blue) for i in CANS}
oe_a = add_scene("Can Odd Blue Even Red", odd_blue)
oe_b = add_scene("Can Odd Red Even Blue", odd_red)
add_chaser("Odd Even", "4284752486", [oe_a, oe_b], colour_specs, fade_in=3000, hold=1000)
scanner_steps = []
for i, can in enumerate(U_WALK):
scanner_steps.append(add_mask(f"Can Scanner {i + 1}", {can}))
add_chaser("Scanner", "4292033564", scanner_steps, spatial_specs, fade_in=0, hold=400)
fill_steps = []
for n in range(1, 9):
fill_steps.append(add_mask(f"Can Fill {n}", set(U_WALK[:n])))
add_chaser(
"Fill", "4278218076", fill_steps, spatial_specs, fade_in=200, hold=300, run_order="PingPong"
)
center_steps = []
for i, ring in enumerate(CENTER_RINGS):
center_steps.append(add_mask(f"Can Center {i + 1}", set(ring)))
add_chaser(
"Center",
"4280817043",
center_steps,
spatial_specs,
fade_in=200,
hold=300,
run_order="PingPong",
)
pair_steps = []
for i, ids in enumerate(PAIR_SETS):
pair_steps.append(add_mask(f"Can Pairs {i + 1}", set(ids)))
add_chaser(
"Pairs", "4294946560", pair_steps, spatial_specs, fade_in=200, hold=400, run_order="PingPong"
)
lr_a = add_scene(
"Can Left Blue Right Red",
{**{i: (0, 0, 255) for i in LEFT_CANS}, **{i: (255, 0, 0) for i in RIGHT_CANS}},
)
lr_b = add_scene(
"Can Left Red Right Blue",
{**{i: (255, 0, 0) for i in LEFT_CANS}, **{i: (0, 0, 255) for i in RIGHT_CANS}},
)
add_chaser("Left Right", "4279648704", [lr_a, lr_b], colour_specs, fade_in=3000, hold=1000)
theater_steps = []
for step in range(3):
theater_steps.append(
add_mask(f"Can Theater {step + 1}", {can for can in CANS if can % 3 == step})
)
add_chaser("Theater", "4285143962", theater_steps, spatial_specs, fade_in=0, hold=400)
add_chaser(
"Collapse",
"4281545523",
[*reversed(center_steps), off],
spatial_specs,
fade_in=200,
hold=300,
run_order="Loop",
)
add_chaser(
"Chase Out",
"4284900966",
[*scanner_steps, off],
spatial_specs,
fade_in=0,
hold=300,
run_order="Loop",
)
return "\n".join(blocks), colour_specs, spatial_specs
def can_pattern_xml() -> str:
colours, _ = pattern_colour_scenes_xml()
patterns, _, _ = build_can_patterns()
return colours + "\n" + patterns
def can_pattern_colour_button_specs() -> list[tuple[str, int, str]]:
_, solids = pattern_colour_scenes_xml()
_, colour_chasers, _ = build_can_patterns()
return solids + colour_chasers
def can_pattern_button_specs() -> list[tuple[str, int, str]]:
_, _, spatial = build_can_patterns()
return spatial
def scale_rgb(rgb: tuple[int, int, int], level: float) -> tuple[int, int, int]:
return (round(rgb[0] * level), round(rgb[1] * level), round(rgb[2] * level))
def blend_rgb(
a: tuple[int, int, int], b: tuple[int, int, int], w: float
) -> tuple[int, int, int]:
"""w=1 is all a, w=0 is all b."""
return (
round(a[0] * w + b[0] * (1 - w)),
round(a[1] * w + b[1] * (1 - w)),
round(a[2] * w + b[2] * (1 - w)),
)
RGB3 = tuple[int, int, int]
def mood_scene_xml(
func_id: int,
name: str,
cans: dict[int, RGB3] | None = None,
movers: dict[int, list[RGB3]] | None = None,
) -> str:
"""Every step of a mood carries the same channels so the chaser crossfades them."""
vals = [can_fixture_val(fid, *rgb) for fid, rgb in (cans or {}).items()]
for fid, heads in (movers or {}).items():
parts: list[int] = []
for i, (r, g, b) in enumerate(heads):
base = 10 + i * 4
parts += [base, r, base + 1, g, base + 2, b, base + 3, 0]
vals.append(
f' <FixtureVal ID="{fid}">{",".join(str(x) for x in parts)}</FixtureVal>'
)
return f""" <Function ID="{func_id}" Type="Scene" Name="{name}">
<Speed FadeIn="0" FadeOut="0" Duration="0"/>
{chr(10).join(vals)}
</Function>"""
def build_moods() -> tuple[str, list[tuple[str, int, str]], list[tuple[str, int, str]]]:
"""Returns xml, can mood buttons, mover mood buttons."""
blocks: list[str] = []
can_specs: list[tuple[str, int, str]] = []
mover_specs: list[tuple[str, int, str]] = []
fid = MOOD_FUNC0
heads = range(7)
def add_chase(prefix: str, caption: str, bg: str, steps: list[tuple[dict, dict]], dest) -> None:
nonlocal fid
step_ids = []
for k, (cans, movers) in enumerate(steps):
blocks.append(mood_scene_xml(fid, f"{prefix} {caption} {k + 1}", cans, movers))
step_ids.append(fid)
fid += 1
blocks.append(
chaser_xml(fid, f"{prefix} {caption}", step_ids, fade_in=MOOD_STEP_MS, hold=0)
)
dest.append((caption, fid, bg))
fid += 1
def wave(i: float, s: int, n: int) -> tuple[float, float]:
phase = 2 * math.pi * (i / n - s / 8)
w = 0.5 + 0.5 * math.cos(phase)
lvl = MOOD_FLOOR + (1 - MOOD_FLOOR) * (0.5 + 0.5 * math.cos(2 * phase))
return w, lvl
for theme, a_name, b_name in MOOD_PAIRS:
a, b = PALETTE[a_name], PALETTE[b_name]
bg = qlc_color(*mix_color(a, b))
pulse = [(a, 1.0), (a, MOOD_FLOOR), (b, 1.0), (b, MOOD_FLOOR)]
# Cans. Breathe: all cans swell and sink in one colour, then the other.
add_chase(
"Can Mood",
f"{theme} Breathe",
bg,
[({c: scale_rgb(rgb, lvl) for c in CANS}, {}) for rgb, lvl in pulse],
can_specs,
)
# Tide: odd/even, then left/right, each trading colours.
add_chase(
"Can Mood",
f"{theme} Tide",
bg,
[
({c: (a if c % 2 == 0 else b) for c in CANS}, {}),
({c: (a if c in LEFT_CANS else b) for c in CANS}, {}),
({c: (b if c % 2 == 0 else a) for c in CANS}, {}),
({c: (b if c in LEFT_CANS else a) for c in CANS}, {}),
],
can_specs,
)
# Drift: a colour wave rolls along the U with two soft bright crests.
drift = []
for s in range(8):
cans = {}
for i, c in enumerate(U_WALK):
w, lvl = wave(i, s, 8)
cans[c] = scale_rgb(blend_rgb(a, b, w), lvl)
drift.append((cans, {}))
add_chase("Can Mood", f"{theme} Drift", bg, drift, can_specs)
# Movers, colour only. Breathe: the two heads counter-pulse.
steps = []
for k, (rgb, lvl) in enumerate(pulse):
other_rgb, other_lvl = pulse[(k + 3) % 4]
steps.append(
(
{},
{
M1: [scale_rgb(rgb, lvl)] * 7,
M2: [scale_rgb(other_rgb, other_lvl)] * 7,
},
)
)
add_chase("Mover Mood", f"{theme} Breathe", bg, steps, mover_specs)
# Tide: one mover each colour, then the rings split, then swap.
alt_ab = [a if h % 2 == 0 else b for h in heads]
alt_ba = [b if h % 2 == 0 else a for h in heads]
add_chase(
"Mover Mood",
f"{theme} Tide",
bg,
[
({}, {M1: [a] * 7, M2: [b] * 7}),
({}, {M1: alt_ab, M2: alt_ba}),
({}, {M1: [b] * 7, M2: [a] * 7}),
({}, {M1: alt_ba, M2: alt_ab}),
],
mover_specs,
)
# Drift: a colour wave spins round each mover's seven heads.
drift = []
for s in range(8):
m1, m2 = [], []
for h in heads:
w, lvl = wave(h, s, 7)
m1.append(scale_rgb(blend_rgb(a, b, w), lvl))
w, lvl = wave(h + 3.5, s, 7)
m2.append(scale_rgb(blend_rgb(a, b, w), lvl))
drift.append(({}, {M1: m1, M2: m2}))
add_chase("Mover Mood", f"{theme} Drift", bg, drift, mover_specs)
return "\n".join(blocks), can_specs, mover_specs
def can_mood_speed_functions() -> list[tuple[int, int, int]]:
_, specs, _ = build_moods()
return [(fid, SPEED_DURATION_ONE, SPEED_DURATION_ONE) for _c, fid, _b in specs]
def mover_mood_speed_functions() -> list[tuple[int, int, int]]:
_, _, specs = build_moods()
return [(fid, SPEED_DURATION_ONE, SPEED_DURATION_ONE) for _c, fid, _b in specs]
def move_lab_aim(fid: int, t: float, dx: int = 0, dy: int = 0) -> tuple[int, int]:
"""DMX pan/tilt t of the way from Down to Wall, nudged by dx/dy."""
down = POSITIONS[0][1] if fid == M1 else POSITIONS[0][2]
wall = POSITIONS[2][1] if fid == M1 else POSITIONS[2][2]
pan = down[0] + (wall[0] - down[0]) * t + dx
tilt = down[1] + (wall[1] - down[1]) * t + dy
return max(0, min(255, round(pan))), max(0, min(255, round(tilt)))
def build_wander_functions() -> tuple[str, list[tuple[str, int, str]], list[tuple[int, int, int]]]:
"""Per-position Wander chasers. Returns xml, position buttons, speed-dial funcs."""
blocks: list[str] = []
specs: list[tuple[str, int, str]] = []
speed: list[tuple[int, int, int]] = []
fid = WANDER_FUNC0
for pos_name, m1, m2, _bg in POSITIONS:
step_ids: list[int] = []
for k, (d1, d2) in enumerate(WANDER_STEPS):
vals = []
for mover, base, (dx, dy) in ((M1, m1, d1), (M2, m2, d2)):
pan = max(0, min(255, base[0] + dx))
tilt = max(0, min(255, base[1] + dy))
vals.append(
f' <FixtureVal ID="{mover}">0,{pan},1,0,2,{tilt},3,0</FixtureVal>'
)
blocks.append(
f""" <Function ID="{fid}" Type="Scene" Name="Wander {pos_name} {k + 1}">
<Speed FadeIn="0" FadeOut="0" Duration="0"/>
{chr(10).join(vals)}
</Function>"""
)
step_ids.append(fid)
fid += 1
blocks.append(
chaser_xml(
fid, f"Wander {pos_name}", step_ids, fade_in=MOVER_PATTERN_MS, hold=0
)
)
specs.append((pos_name, fid, WANDER_BG))
speed.append((fid, SPEED_DURATION_ONE, SPEED_DURATION_ONE))
fid += 1
return "\n".join(blocks), specs, speed
def build_move_lab() -> tuple[str, list[tuple[str, int, str]], list[tuple[int, int, int]]]:
"""Returns xml, buttons (row per spot, column per style), speed dial functions."""
blocks: list[str] = []
specs: list[tuple[str, int, str]] = []
speed: list[tuple[int, int, int]] = []
fid = MOVE_LAB_FUNC0
for spot, t in MOVE_LAB_SPOTS:
for style, bg, kind, args in MOVE_LAB_STYLES:
name = f"Move Lab {style} {spot}"
if kind == "efx":
efx_ids = []
for mover in (M1, M2):
pan, tilt = move_lab_aim(mover, t)
y, h = efx_fit(tilt, args["h"])
blocks.append(
efx_block(
fid,
f"{name} M{mover - 7}",
args["algo"],
args["w"],
h,
[(mover, "Forward", 0)],
pan,
y,
duration=MOVE_LAB_STEP_MS * 4,
)
)
efx_ids.append(fid)
speed.append((fid, MOVE_LAB_EFX_MULT, 0))
fid += 1
blocks.append(collection_xml(fid, name, efx_ids))
else:
step_ids = []
for k, (d1, d2) in enumerate(zip(args["m1"], args["m2"])):
vals = []
for mover, (dx, dy) in ((M1, d1), (M2, d2)):
pan, tilt = move_lab_aim(mover, t, dx, dy)
vals.append(
f' <FixtureVal ID="{mover}">0,{pan},1,0,2,{tilt},3,0</FixtureVal>'
)
blocks.append(
f""" <Function ID="{fid}" Type="Scene" Name="{name} {k + 1}">
<Speed FadeIn="0" FadeOut="0" Duration="0"/>
{chr(10).join(vals)}
</Function>"""
)
step_ids.append(fid)
fid += 1
blocks.append(
chaser_xml(fid, name, step_ids, fade_in=MOVE_LAB_STEP_MS, hold=0)
)
speed.append((fid, SPEED_DURATION_ONE, SPEED_DURATION_ONE))
specs.append((f"{style} {spot}", fid, bg))
fid += 1
return "\n".join(blocks), specs, speed
def fixture_xml() -> str:
parts = []
for i in range(8):
parts.append(
f""" <Fixture>
<Manufacturer>beamZ</Manufacturer>
<Model>BCC145</Model>
<Mode>8 Channel</Mode>
<ID>{i}</ID>
<Name>BCC145 #{i + 1}</Name>
<Universe>0</Universe>
<Address>{87 + i * 8}</Address>
<Channels>8</Channels>
</Fixture>"""
)
for i, addr in enumerate((0, 44)):
parts.append(
f""" <Fixture>
<Manufacturer>Small Eye 7</Manufacturer>
<Model>Mover</Model>
<Mode>43 Channel</Mode>
<ID>{8 + i}</ID>
<Name>Small Eye 7 #{i + 1}</Name>
<Universe>0</Universe>
<Address>{addr}</Address>
<Channels>43</Channels>
</Fixture>"""
)
return "\n".join(parts)
def fixture_groups_xml() -> str:
def heads(fids: list[int]) -> str:
return "\n".join(
f' <Head X="{i}" Y="0" Fixture="{fid}">0</Head>'
for i, fid in enumerate(fids)
)
return f""" <FixtureGroup ID="0">
<Name>Cans 1-2</Name>
<Size X="2" Y="1"/>
{heads(GROUP_L)}
</FixtureGroup>
<FixtureGroup ID="1">
<Name>Cans 3-6</Name>
<Size X="4" Y="1"/>
{heads(GROUP_C)}
</FixtureGroup>
<FixtureGroup ID="2">
<Name>Cans 7-8</Name>
<Size X="2" Y="1"/>
{heads(GROUP_R)}
</FixtureGroup>
<FixtureGroup ID="3">
<Name>Small Eye Movers</Name>
<Size X="2" Y="1"/>
<Head X="0" Y="0" Fixture="8">0</Head>
<Head X="1" Y="0" Fixture="9">0</Head>
</FixtureGroup>"""
def main() -> None:
sl_w, sl_h = 44, 240
block_gap = 28
row_gap = 36
header_h = 28
widgets: list[str] = []
wid = 0
max_x = 0
max_y = 0
def place_slider(
caption,
x,
y,
w,
h,
channels,
value=0,
fg="Default",
cng="None",
inverted=False,
high=255,
):
nonlocal wid, max_x, max_y
widgets.append(
slider(
wid,
caption,
x,
y,
w,
h,
channels,
value=value,
fg=fg,
cng=cng,
inverted=inverted,
high=high,
)
)
wid += 1
max_x = max(max_x, x + w)
max_y = max(max_y, y + h)
def place_speed_slider(
caption,
x,
y,
time_ms,
functions,
*,
min_ms=50,
max_ms=8000,
w=64,
h=sl_h,
visibility=SPEED_VIS_FADER,
):
nonlocal wid, max_x, max_y
widgets.append(
speed_dial(
wid,
caption,
x,
y,
w,
h,
time_ms,
functions,
min_ms=min_ms,
max_ms=max_ms,
visibility=visibility,
)
)
wid += 1
max_x = max(max_x, x + w)
max_y = max(max_y, y + h)
return x + w
def place_looks(
title: str,
looks: list[tuple[str, int, str]],
x: int,
y: int,
*,
cols: int = 2,
btn_w: int = 156,
sink: list[str] | None = None,
frame_y: int | None = None,
) -> int:
nonlocal wid, max_x, max_y
pad = 4
gap_x, gap_y = 6, 6
n = len(looks)
cols = max(1, min(cols, n))
rows = max(1, (n + cols - 1) // cols)
frame_w = pad * 2 + cols * btn_w + (cols - 1) * gap_x
frame_h = header_h + sl_h
inner_h = sl_h - pad
btn_h = (inner_h - gap_y * (rows - 1)) // rows
look_btns = []
frame_id = wid
wid += 1
for i, (caption, func_id, bg) in enumerate(looks):
col, row = i % cols, i // cols
look_btns.append(
button(
wid,
caption,
func_id,
pad + col * (btn_w + gap_x),
header_h + pad + row * (btn_h + gap_y),
btn_w,
btn_h,
bg,
indent=" ",
)
)
wid += 1
fy = y - header_h if frame_y is None else frame_y
xml = solo_frame(
frame_id,
title,
x,
fy,
frame_w,
frame_h,
"\n".join(look_btns),
)
if sink is None:
widgets.append(xml)
max_x = max(max_x, x + frame_w)
max_y = max(max_y, fy + frame_h)
return x + frame_w
sink.append(xml)
return frame_w
_, look_specs = build_looks()
y0 = header_h
x = 10
x = place_speed_slider(
"Tap",
x,
y0,
TAP_MS,
tap_tempo_functions(),
min_ms=100,
max_ms=4000,
w=110,
visibility=SPEED_VIS_TAP,
)
x += block_gap
place_slider(
"M Bright",
x,
y0,
sl_w,
sl_h,
[(M1, MOVER_DIM), (M2, MOVER_DIM)],
255,
"4294967295",
)
x += sl_w + 2
place_slider(
"M Focus",
x,
y0,
sl_w,
sl_h,
[(M1, MOVER_FOCUS), (M2, MOVER_FOCUS)],
FOCUS_DEFAULT,
"4294902015",
)
x += sl_w + 2
place_slider(
"Speed",
x,
y0,
sl_w,
sl_h,
[(M1, MOVER_SPEED), (M2, MOVER_SPEED)],
0,
"4294967295",
inverted=True,
)
x += sl_w + 2
place_slider(
"M Strobe",
x,
y0,
sl_w,
sl_h,
[(M1, MOVER_STROBE), (M2, MOVER_STROBE)],
0,
"4294967040",
high=200,
)
x += sl_w + 2
x = place_speed_slider(
"M Pat",
x,
y0,
MOVER_PATTERN_MS,
mover_pattern_speed_functions(),
min_ms=200,
max_ms=12000,
)
x += 2
for name, _can_ch, mover_chs, fg, cng in RGB:
place_slider(
f"M {name}",
x,
y0,
sl_w,
sl_h,
[(fid, c) for fid in (M1, M2) for c in mover_chs],
fg=fg,
cng=cng,
)
x += sl_w + 2
x += block_gap - 2
move_pad = 4
looks_x0 = x
looks_chunks: list[str] = []
inner_x = move_pad
inner_w = place_looks(
"Position",
position_button_specs(),
inner_x,
y0,
cols=2,
btn_w=72,
sink=looks_chunks,
frame_y=move_pad,
)
inner_x += inner_w + block_gap
move_specs = move_pattern_specs()
for title in ("Figure 8", "Zigzag", "Swirl"):
inner_w = place_looks(
title,
move_specs[title],
inner_x,
y0,
cols=2,
btn_w=72,
sink=looks_chunks,
frame_y=move_pad,
)
inner_x += inner_w + block_gap
_, wander_specs, _ = build_wander_functions()
inner_w = place_looks(
"Wander",
wander_specs,
inner_x,
y0,
cols=2,
btn_w=72,
sink=looks_chunks,
frame_y=move_pad,
)
inner_x += inner_w + block_gap
parent_w = inner_x + move_pad
parent_h = header_h + sl_h + move_pad
widgets.append(
solo_frame(
wid,
"",
looks_x0,
y0 - header_h,
parent_w,
parent_h,
"\n".join(looks_chunks),
show_header=False,
)
)
max_x = max(max_x, looks_x0 + parent_w)
max_y = max(max_y, y0 - header_h + parent_h)
wid += 1
x = looks_x0 + parent_w + block_gap
x = place_looks("Movers", look_specs["movers"], x, y0)
y1 = y0 + sl_h + row_gap
x = 10
place_slider(
"C Bright",
x,
y1,
sl_w,
sl_h,
[(f, 0) for f in CANS],
255,
"4294967295",
)
x += sl_w + 2
place_slider(
"C Strobe",
x,
y1,
sl_w,
sl_h,
[(f, CAN_STROBE) for f in CANS],
0,
"4294967040",
)
x += sl_w + block_gap
x = place_looks("Cans", look_specs["cans"], x, y1)
x += block_gap
x = place_looks("Cans Odd/Even", look_specs["cans_oe"], x, y1)
x += block_gap
x = place_looks(
"Pattern Colour",
can_pattern_colour_button_specs(),
x,
y1,
cols=3,
btn_w=72,
)
x += block_gap
x = place_looks(
"Can Patterns",
can_pattern_button_specs(),
x,
y1,
cols=3,
btn_w=72,
)
x += 8
place_speed_slider(
"C Pat",
x,
y1,
PATTERN_SPEED_MS,
can_pattern_speed_functions(),
min_ms=50,
max_ms=4000,
)
y2 = y1 + sl_h + row_gap
x = 10
_, can_mood_specs, mover_mood_specs = build_moods()
x = place_looks("Can Moods", can_mood_specs, x, y2, cols=3, btn_w=120)
x += 8
x = place_speed_slider(
"C Mood",
x,
y2,
MOOD_STEP_MS,
can_mood_speed_functions(),
min_ms=1000,
max_ms=30000,
)
x += block_gap
x = place_looks("Mover Moods · colour", mover_mood_specs, x, y2, cols=3, btn_w=120)
x += 8
place_speed_slider(
"M Mood",
x,
y2,
MOOD_STEP_MS,
mover_mood_speed_functions(),
min_ms=1000,
max_ms=30000,
)
y3 = y2 + sl_h + row_gap
x = 10
_, lab_specs, lab_speed = build_move_lab()
x = place_looks(
"Move Lab · Down → Wall", lab_specs, x, y3, cols=len(MOVE_LAB_STYLES), btn_w=100
)
x += 8
place_speed_slider(
"Move",
x,
y3,
MOVE_LAB_STEP_MS,
lab_speed,
min_ms=500,
max_ms=20000,
)
total_w = max_x + 16
total_h = max_y + 16
artnet_uid, artnet_line = artnet_bind_uid_line()
artnet_node = discover_artnet_node(artnet_uid)
print(
f"Art-Net bind {artnet_uid} line {artnet_line} → {artnet_node} universe 0"
)
qxw = f"""<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE Workspace>
<Workspace xmlns="http://www.qlcplus.org/Workspace" CurrentWindow="VirtualConsole">
<Creator>
<Name>Q Light Controller Plus</Name>
<Version>4.12.7</Version>
<Author>Jimmy</Author>
</Creator>
<Engine>
<InputOutputMap>
<Universe Name="Universe 1" ID="0">
<Output Plugin="ArtNet" UID="{artnet_uid}" Line="{artnet_line}">
<PluginParameters outputIP="{artnet_node}" outputUni="0"/>
</Output>
</Universe>
<Universe Name="Universe 2" ID="1"/>
<Universe Name="Universe 3" ID="2"/>
<Universe Name="Universe 4" ID="3"/>
</InputOutputMap>
{fixture_xml()}
{fixture_groups_xml()}
{look_scenes_xml()}
{position_scene_xml()}
{move_efx_xml()}
{build_wander_functions()[0]}
{can_pattern_xml()}
{build_moods()[0]}
{build_move_lab()[0]}
</Engine>
<VirtualConsole>
<Frame Caption="">
<Appearance>
<FrameStyle>None</FrameStyle>
<ForegroundColor>Default</ForegroundColor>
<BackgroundColor>Default</BackgroundColor>
<BackgroundImage>None</BackgroundImage>
<Font>Default</Font>
</Appearance>
{"\n".join(widgets)}
</Frame>
<Properties>
<Size Width="{total_w}" Height="{total_h}"/>
<GrandMaster ChannelMode="Intensity" ValueMode="Reduce" SliderMode="Normal"/>
</Properties>
</VirtualConsole>
<SimpleDesk>
<Engine/>
</SimpleDesk>
</Workspace>
"""
OUT.parent.mkdir(parents=True, exist_ok=True)
OUT.write_text(qxw)
print(f"Wrote {OUT} ({total_w}x{total_h}, {wid} widgets)")
if __name__ == "__main__":
main()