Added second launchpad vibrato mode (pitch bend), reduced midi messages, gamepad experiment, improved mpe setup

Author: flipcoder

midimech.py

@@ -14,6 +14,7 @@
 from src.note import Note
 from src.settings import DeviceSettings
 from src.core import Core
+from src.gamepad import Gamepad
 
 with open(os.devnull, "w") as devnull:
     # suppress pygame messages

src/articulation.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from src.util import sign
+from src.util import *
 from src.constants import *
 
 class Articulation:
@@ -8,7 +8,7 @@ class Articulation:
     def __init__(self, core):
         self.core = core
         self.value = 0.0
-        self.time_between_ticks = 0.05
+        self.time_between_ticks = 0.02
         self.timer = 0.0
         self.state = self.State(self.State.off)
 
@@ -27,6 +27,16 @@ def __init__(self, core):
 
         self.mod = 0.0
         self.mod_changed = True
+        self.last_midi_message = None
+
+        self.mode = self.core.options.vibrato
+        if self.mode not in ('mod', 'pitch'):
+            print('Vibrato option must be mod or pitch. Using mod.')
+            self.mode = 'mod'
+        self.t = 0.0
+        self.vibrato_speed = 5.0
+        self.vibrato_depth = 1.0 / 4.0
+        self.vibrato_shift = 0.0 # 0.1
 
     def pressure(self, value):
         if not value or value <= 0.0:
@@ -88,7 +98,24 @@ def tick(self):
         #     return
 
         if self.mod_changed:
-            self.core.midi_write(self.core.midi_out, [0xb0, 1, int(self.mod * 127)])
+            if self.mode == 'mod':
+                msg = [0xb0, 1, int(self.mod * 127)]
+                if msg != self.last_midi_message:
+                    self.core.midi_write(self.core.midi_out, msg)
+                    self.last_midi_message = msg
+            elif self.mode == 'pitch':
+                if self.mod > 0.0:
+                    wave = self.mod * math.sin(math.tau * self.t * self.vibrato_speed) * self.vibrato_depth + self.vibrato_shift
+                    pb = compose_pitch_bend(wave)
+                    msg = [0xe0, pb[0], pb[1]]
+                    if msg != self.last_midi_message:
+                        self.core.midi_write(self.core.midi_out, msg)
+                        self.last_midi_message = msg
+                else:
+                    msg = [0xe0, 0, 0x40]
+                    if msg != self.last_midi_message:
+                        self.core.midi_write(self.core.midi_out, msg)
+                        self.last_midi_message = msg
             self.mod_changed = False
 
         # held_note_count = self.core.held_note_count()
@@ -97,6 +124,7 @@ def tick(self):
 
     def logic(self, dt):
         self.timer += dt
+        self.t += dt
 
         self.vibrato_window_t = max(0.0, self.vibrato_window_t - 1.0 * dt)
         if self.vibrato_window_t <= 0.0:

src/core.py

@@ -14,6 +14,7 @@
 from src.note import Note
 from src.settings import DeviceSettings
 from src.articulation import Articulation
+from src.gamepad import Gamepad
 
 with open(os.devnull, "w") as devnull:
     # suppress pygame messages
@@ -122,12 +123,12 @@ def set_light(self, x, y, col):  # col is [1,11], 0 resets
             self.send_cc(0, 22, col)
 
         if self.launchpad:
-            lp_col = COLOR_CODES[col]
+            lp_col = COLOR_CODES[col] / 4
             if 0 <= x < 8 and 0 <= y < 8:
                 if not self.is_macro_button(x, y):
                     self.launchpad.LedCtrlXY(x, y+1, lp_col[0], lp_col[1], lp_col[2])
                 else:
-                    self.launchpad.LedCtrlXY(x, y+1, 127, 127, 127)
+                    self.launchpad.LedCtrlXY(x, y+1, 63, 63, 63)
 
     def reset_light(self, x, y, reset_red=True):
         note = self.get_note_index(x, y)
@@ -176,16 +177,16 @@ def reset_launchpad_light(self, x, y):
     def set_red_light(self, x, y, state=True):
         self.red_lights[y][x] = state
         if self.launchpad:
-            lp_col = ivec3(127, 0, 0)
+            lp_col = ivec3(63, 0, 0)
             if state:
                 self.launchpad.LedCtrlXY(x, y, lp_col[0], lp_col[1], lp_col[2])
 
     def set_launchpad_light(self, x, y, color):
-        col = COLOR_CODES[color]
+        col = COLOR_CODES[color] / 4
         if not self.is_macro_button(x, 8 - y - 1):
             self.launchpad.LedCtrlXY(x, 8-y, col[0], col[1], col[2])
         else:
-            self.launchpad.LedCtrlXY(x, 8-y, 127, 127, 127)
+            self.launchpad.LedCtrlXY(x, 8-y, 63, 63, 63)
 
     def setup_lights(self):
         for y in range(self.board_h):
@@ -397,6 +398,7 @@ def init_board(self):
             self.notes[i] = Note()
 
         self.chord_notes = [False] * 127
+        self.note_set = set()
 
     def midi_write(self, dev, msg, ts=0):
         if dev:
@@ -514,6 +516,7 @@ def note_on(self, data, timestamp, width=None, curve=True, mpe=None):
                 note.split = split_chan
 
         self.chord_notes[data[1]] = True
+        self.note_set.add(data[1])
         self.dirty_chord = True
 
         if self.is_split():
@@ -610,6 +613,7 @@ def note_off(self, data, timestamp, width=None, mpe=None):
             data[1] += 7
 
         self.chord_notes[data[1]] = False
+        self.note_set.remove(data[1])
         self.dirty_chord = True
 
         if self.is_split():
@@ -806,16 +810,14 @@ def macro(self, x, y, val):
 
     # uses button state events (mk3 pro)
     def cb_launchpad_in(self, event, timestamp=0):
-        # if (self.launchpad_mode == "pro" or self.launchpad_mode == "promk3") and event[0] == 255:
-        # if event[0] >= 255:
-        #     # I'm testing the mk3 method on an lpx, so I'll check this here
-        #     vel = event[2] if self.launchpad_mode == 'lpx' else event[1]
-        #     for note in self.notes:
-        #         if note.location:
-        #             print(note.midinote)
-        #             self.note_on([160, note.midinote, vel], timestamp, width=8, mpe=True)
-        
-        if self.launchpad_mode == 'lpx' and event[0] >= 255: # pressure
+        if (self.launchpad_mode == "pro" or self.launchpad_mode == "promk3") and event[0] >= 255:
+        # if event[0] >= 255: # uncomment this for testing pro behavior on launchpad X
+            # I'm testing the mk3 method on an lpx, so I'll check this here
+            vel = event[2] if self.launchpad_mode == 'lpx' else event[1]
+            for note in self.note_set:
+                self.midi_write(self.midi_out, [160, note, vel], timestamp)
+                self.articulation.pressure(vel / 127)
+        elif self.launchpad_mode == 'lpx' and event[0] >= 255: # pressure
             x = event[0] - 255
             y = 8 - (event[1] - 255)
             vel = event[2]
@@ -1053,6 +1055,8 @@ def __init__(self):
         # ) or get_option(
         #     opts, "no_overlap", DEFAULT_OPTIONS.mpe
         # )
+        self.options.mpe = True
+        self.options.vibrato = get_option(opts, "vibrato", DEFAULT_OPTIONS.vibrato)
         self.options.midi_out = get_option(opts, "midi_out", DEFAULT_OPTIONS.midi_out)
         self.options.split_out = get_option(
             opts, "split_out", DEFAULT_OPTIONS.split_out
@@ -1358,6 +1362,13 @@ def __init__(self):
         self.visualizer = None
         self.launchpad = None
         self.launchpad_mode = None
+        
+        self.gamepad = None
+        if self.options.experimental:
+            pygame.joystick.init()
+            if pygame.joystick.get_count() > 0:
+                self.gamepad = Gamepad(self, 0)
+                print('Gamepad initialized')
 
         innames = rtmidi2.get_in_ports()
         for i in range(len(innames)):
@@ -1469,13 +1480,35 @@ def rpn(self, num, value):
         self.midi_write(self.linn_out, [176, 38, value_lsb])
         self.midi_write(self.linn_out, [176, 101, 127])
         self.midi_write(self.linn_out, [176, 100, 127])
-        time.sleep(0.1)
+        time.sleep(0.05)
 
     def mpe_rpn(self, on=True):
         if on:
             self.rpn(0, 1)
             self.rpn(100, 1)
             self.rpn(227, 0)
+
+            if self.options.hardware_split:
+                # left side channels
+                self.rpn(1, 1)
+                self.rpn(2, 0)
+                for x in range(3, 10):
+                    self.rpn(x, 1)
+                for x in range(10, 18):
+                    self.rpn(x, 0)
+
+                # right side channels
+                self.rpn(101, 16) # main=16
+                for x in range(110, 117):
+                    self.rpn(x, 1)
+                self.rpn(117, 0) # 16 off
+            else:
+                # left side only
+                self.rpn(1, 1)
+                self.rpn(2, 0)
+                for x in range(3, 18):
+                    self.rpn(x, 1)
+
         else:
             self.rpn(227, 5)
 
@@ -1682,6 +1715,16 @@ def logic(self, dt):
                 except KeyError:
                     pass
 
+            else:
+                if self.gamepad and ev.type in (\
+                        pygame.JOYAXISMOTION,
+                        pygame.JOYBALLMOTION,
+                        pygame.JOYBUTTONDOWN,
+                        pygame.JOYBUTTONUP,
+                        pygame.JOYHATMOTION
+                    ):
+                        self.gamepad.event(ev)
+                
             if not self.options.lite:
                 if ev.type == pygame.MOUSEMOTION:
                     x, y = ev.pos
@@ -1777,6 +1820,9 @@ def logic(self, dt):
         if self.launchpad:
             self.articulation.logic(dt)
 
+        if self.gamepad:
+            self.gamepad.logic(dt)
+
         # figure out the lowest note to highlight it
         # if self.options.show_lowest_note:
         #     old_lowest_note = self.lowest_note
@@ -1992,6 +2038,31 @@ def render(self):
                 x += 1
             y += 1
 
+        if self.gamepad:
+            pos = self.gamepad.positions()
+            # gp_pos.y = self.board_h - y - 1
+            
+            circ = [None] * 2
+            for i in range(2):
+                circ[i] = ivec2(
+                    int(pos[i].x * sz + b / 2 + sz / 2),
+                    int(self.menu_sz + pos[i].y * sz + b / 2 + sz / 2),
+                )
+                
+                pygame.gfxdraw.aacircle(
+                    self.screen.surface,
+                    circ[i].x + 1,
+                    circ[i].y - 1,
+                    rad,
+                    ivec3(0, 255, 0),
+                )
+                # pygame.gfxdraw.filled_circle(
+                #     self.screen.surface,
+                #     circ[i].x + 1,
+                #     circ[i].y - 1,
+                #     rad,
+                #     ivec3(0, 255, 0),
+                # )
 
         # if self.options.experimental:
         text = self.font.render(self.scale_name, True, ivec3(127))

src/gamepad.py

@@ -0,0 +1,56 @@
+import pygame
+from glm import ivec2, vec2, length
+from src.util import sign
+
+class Gamepad:
+    def __init__(self, core, num=0):
+        self.core = core
+        self.joy = pygame.joystick.Joystick(num)
+        self.notes = [None] * 16
+        for i, note in enumerate(self.notes):
+            self.notes[i] = set()
+        self.cursors = [ivec2(4, 5), ivec2(5, 2)]
+        self.offset = [vec2(0, 0), vec2(0,0)]
+        self.ioffset = [ivec2(0, 0), ivec2(0, 0)]
+        self.deadzone = 0.1
+    def positions(self):
+        return [self.cursors[0] + self.ioffset[0], self.cursors[1] + self.ioffset[1]]
+    def logic(self, dt):
+        for ofs_idx in range(2):
+            for axis, value in enumerate(self.offset[ofs_idx]):
+                self.ioffset[ofs_idx][axis%2] = int(round(value))
+                # fix corners
+                if abs(self.offset[ofs_idx].x) > 0.6 and abs(self.offset[ofs_idx].y) > 0.6:
+                    self.ioffset[ofs_idx] = ivec2(sign(self.offset[ofs_idx].x), sign(self.offset[ofs_idx].y))
+            # print(self.ioffset)
+        self.core.dirty = True
+    def play(self, ch, x, y, vel):
+        note = y * 8 + x
+        self.core.note_on([144, note, 100], 0, width=8, mpe=True)
+        self.notes[ch].add(note)
+    def event(self, ev):
+        if ev.type == pygame.JOYAXISMOTION:
+            axis = ev.axis
+            # print(axis)
+            if 2 <= axis < 4:
+                self.offset[1][axis-2] = ev.value
+            elif 0 <= axis < 2:
+                self.offset[0][axis] = ev.value
+        elif ev.type  == pygame.JOYHATMOTION:
+            self.cursors[0] += ivec2(ev.value[0], -ev.value[1])
+        elif ev.type  == pygame.JOYBUTTONUP:
+            for note in self.notes[ev.button]:
+                self.core.note_off([128, note, 100], 0, width=8, mpe=True)
+        elif ev.type  == pygame.JOYBUTTONDOWN:
+            for note in self.notes[ev.button]:
+                self.core.note_off([128, note, 100], 0, width=8, mpe=True)
+            if ev.button in (0, 1):
+                pos = self.positions()[ev.button]
+            elif ev.button == 2:
+                pos = self.positions()[0] + ivec2(2,0)
+            elif ev.button == 3:
+                pos = self.positions()[1] + ivec2(2,0)
+            x = pos.x
+            y = self.core.board_h - pos.y - 1
+            self.play(ev.button, x, y, 100)
+

src/note.py

@@ -3,6 +3,7 @@ def __init__(self):
         # self.bend = 0.0
         # self.pressed = False
         # self.intensity = 0.0  # how much to light marker up (in app)
+        self.ipressure = 0 # 0, 127
         self.pressure = 0.0  # how much the note is being pressed
         # self.dirty = False
         self.location = None  # on board

src/options.py

@@ -25,6 +25,7 @@ class Options:
     size: int = 128
     width: int = 16
     height: int = 8
+    vibrato: str = 'mod'
 
 DEFAULT_OPTIONS = Options()
 

src/util.py

@@ -102,7 +102,6 @@ def decompose_pitch_bend(pitch_bend_bytes):
     pitch_bend_norm = (pitch_bend_value - 8192) / 8192.0
     return pitch_bend_norm
 
-
 def compose_pitch_bend(pitch_bend_norm):
     pitch_bend_value = int((pitch_bend_norm + 1.0) * 8192)
     pitch_bend_bytes = [pitch_bend_value & 0x7F, (pitch_bend_value >> 7) & 0x7F]