The Sound and Threshold audio triggers go, with the Sound submaster beside the cans' Front and Back sliders (CC 100) and the Sound peak frame with its Peak submaster and Hit button and the Cans hit functions only Hit ran. Pads 1 and 2 are plain spare buttons again (scripts/shows/drop_sound.py). The pads frame's own Peak (knob 6) stays: it is the chases' peak. The pad controller drops its side of it: the Pump and Threshold modes, the CC 100 resets, holding the side knobs at the peak and the pad lamps that showed which mode was on. Pads 1 and 2 and knobs 5, 6 and 8 pass straight through. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
121 lines
5.2 KiB
Python
121 lines
5.2 KiB
Python
"""Hold Play to move the bank 2 pads up a layer.
|
||
|
||
The SMC-PAD sends CC 27 as 127 when Play goes down and 0 when it comes up.
|
||
While it is down, pad notes 52–67 go out as 68–83, so QLC+ can tell a
|
||
second set of buttons from the first. Play itself is not passed on.
|
||
|
||
Pause (CC 28) does the same for bank 1, but toggles: each press flips it.
|
||
Off, bank 1 pads 36–51 go out as they are, for the cans. On, they go out as
|
||
84–99, for the movers. Pause itself is not passed on.
|
||
|
||
colours holds the last colour pad pressed in each set, as sent (52–67 for the
|
||
cans, 68–83 for the movers), or None once it is pressed again: the colour
|
||
buttons toggle in a solo frame. QLC+ does not save which buttons are on, so
|
||
reopen() presses them again when QLC+ loads the show.
|
||
|
||
The movers' movement pads (pads 13–16, 9–12 and 5 on the movers layer: notes
|
||
96–99, 92–95 and 88) each toggle a relative EFX around the Pan and Tilt knobs (9
|
||
and 10, CC 38 and 39). They share a solo frame in QLC+, so starting one stops the others.
|
||
QLC+ 4.12 leaves an EFX's last offset on the movers when it stops, until those
|
||
sliders change, so when the one that is on goes off, settle asks for the two
|
||
knobs one step off and then back (nudge() and positions()). Swapping needs
|
||
none: the new EFX writes over the old one's offset. moving holds the note whose
|
||
EFX is on, from the presses: only a guess, as QLC+ sends no feedback for it.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
PLAY_CC = 27
|
||
FIRST_NOTE = 52
|
||
LAST_NOTE = 67
|
||
SHIFT = 16
|
||
PAUSE_CC = 28
|
||
BANK_1_FIRST = 36
|
||
BANK_1_LAST = 51
|
||
MOVERS_SHIFT = 48 # bank 1 goes out as 84–99 while Pause is on, above bank 2's held layer
|
||
KNOB_CHANNEL = 0
|
||
# Wander, Ballyhoo, Circle, Sweep; Diamond, Square, Corners, Leaf; Tilt: pads 13–16, 9–12, 5
|
||
RELATIVE_NOTES = (96, 97, 98, 99, 92, 93, 94, 95, 88)
|
||
POSITION_CCS = (38, 39) # knobs 9 and 10: the movers' Pan and Tilt
|
||
|
||
|
||
class PlayLayer:
|
||
def __init__(self) -> None:
|
||
self.held = False
|
||
self.movers = False # Pause toggles bank 1 between the cans and the movers
|
||
# (channel, note as pressed) -> note sent, so a release matches its press
|
||
self.sent: dict[tuple[int, int], int] = {}
|
||
# Pan and Tilt as last sent; QLC+ starts them at 0.
|
||
self.position = {cc: 0 for cc in POSITION_CCS}
|
||
self.moving: int | None = None
|
||
self.settle = False # a relative EFX just went off: the caller sends nudge(), then positions()
|
||
# set -> (channel, note sent) of the colour that is on
|
||
self.colours: dict[int, tuple[int, int] | None] = {1: None, 2: None}
|
||
|
||
def handle(self, data: list[int]) -> list[list[int]]:
|
||
"""The messages to send on. Empty when the message is swallowed."""
|
||
status = data[0]
|
||
kind = status & 0xF0
|
||
channel = status & 0x0F
|
||
if kind == 0xB0 and len(data) >= 3 and data[1] == PLAY_CC:
|
||
self.held = data[2] > 0
|
||
return []
|
||
if kind == 0xB0 and len(data) >= 3 and data[1] == PAUSE_CC:
|
||
if data[2] > 0:
|
||
self.movers = not self.movers
|
||
return []
|
||
if kind == 0xB0 and len(data) >= 3 and channel == KNOB_CHANNEL and data[1] in self.position:
|
||
self.position[data[1]] = data[2]
|
||
return [list(data)]
|
||
if kind not in (0x80, 0x90) or len(data) < 3:
|
||
return [list(data)]
|
||
key = (channel, data[1])
|
||
is_on = kind == 0x90 and data[2] > 0
|
||
if is_on:
|
||
out = self.shifted(data[1])
|
||
self.sent[key] = out
|
||
else:
|
||
out = self.sent.pop(key, data[1])
|
||
note = out
|
||
if note in RELATIVE_NOTES and is_on:
|
||
if note == self.moving:
|
||
self.moving = None
|
||
self.settle = True
|
||
else:
|
||
self.moving = note
|
||
if is_on and FIRST_NOTE <= out <= LAST_NOTE + SHIFT:
|
||
colour_set = 1 if out <= LAST_NOTE else 2
|
||
pressed = (channel, out)
|
||
self.colours[colour_set] = None if self.colours[colour_set] == pressed else pressed
|
||
return [[status, out, *data[2:]]]
|
||
|
||
def shifted(self, note: int) -> int:
|
||
"""The note a press goes out as: bank 2 up while Play is held, bank 1 up while Pause is on."""
|
||
if self.held and FIRST_NOTE <= note <= LAST_NOTE:
|
||
return note + SHIFT
|
||
if self.movers and BANK_1_FIRST <= note <= BANK_1_LAST:
|
||
return note + MOVERS_SHIFT
|
||
return note
|
||
|
||
def reopen(self) -> list[list[int]]:
|
||
"""QLC+ has loaded the show: everything is off. Press the colours that were on."""
|
||
self.moving = None
|
||
out = []
|
||
for colour in self.colours.values():
|
||
if colour is not None:
|
||
out += tap(*colour)
|
||
return out
|
||
|
||
def nudge(self) -> list[list[int]]:
|
||
"""Pan and Tilt one step off their knobs, so QLC+ writes them again."""
|
||
return [[0xB0 | KNOB_CHANNEL, cc, v - 1 if v else 1] for cc, v in self.position.items()]
|
||
|
||
def positions(self) -> list[list[int]]:
|
||
"""Pan and Tilt back at their knobs."""
|
||
return [[0xB0 | KNOB_CHANNEL, cc, v] for cc, v in self.position.items()]
|
||
|
||
|
||
def tap(channel: int, note: int) -> list[list[int]]:
|
||
"""A press and release of note, to toggle a QLC+ button off."""
|
||
return [[0x90 | channel, note, 127], [0x80 | channel, note, 0]]
|