17. MIDI Routing and Note Map

The preceding chapters have focused on what Poly generates – Euclidean distributions, macro-driven density curves, scene morphing, compositional arcs. But generation is only half the story. The other half is routing: where those generated notes go, and what they sound like when they arrive. Poly’s MIDI channel assignment and Note Map systems sit between the engine’s output and your DAW’s instruments, giving you precise control over which sounds receive which patterns without ever touching the rhythmic logic itself.

This separation is deliberate. The engine generates patterns based on Euclidean mathematics, cycle lengths, and macro modulation. The routing layer shapes the sonic result independently. Change a lane’s MIDI channel and the pattern stays identical – only the destination instrument changes. Remap a note and the rhythm is untouched – only the timbre shifts. This decoupling means you can experiment with orchestration freely, swapping kit pieces or entire instruments without rebuilding your patch from scratch.

Hosts

Poly generates MIDI and plays nothing itself, so everything in this chapter happens inside a host that routes that MIDI to a drum instrument. This is the host table the project publishes, and it lists only what has been measured:

Host	Version	Platform	Status	Routing
Cubase	Pro 15	macOS	supported	Instrument track for Poly; a drum instrument whose MIDI input is Poly on all channels, or a MIDI Send from the Poly track
Cubase	14	Windows	supported	The same; exercised nightly by the Cubase harness
Other VST3 hosts	—	—	untested	Routing MIDI out of a plugin is where hosts differ most; nothing has been measured

Poly is built and tested in Cubase. Other hosts may work and have not been tried; a measured host table for them is planned.

Per-Lane MIDI Channel

Each lane in Poly has a midiChannel parameter that determines which MIDI channel its output events are sent on. The parameter accepts two kinds of values:

• Auto – uses the lane’s position as the channel. The first lane sends on Channel 1, the second on Channel 2, and so on. This is the default for new patches.
• Channel 1-16 – explicit assignment. The lane always sends on the channel you pick, regardless of its position in the lane list.

Poly numbers channels 1-16, the same way Cubase and every other DAW does. The underlying midiChannel parameter stores the MIDI wire value, which is 0-15 with -1 reserved for Auto, so a lane displayed as Channel 1 is stored as 0. That distinction only matters if you are reading a saved patch or the parameter automation directly; everywhere Poly shows you a channel, it shows the number your DAW shows.

In the engine, the channel resolution is straightforward: if midiChannel is non-negative, the lane uses that value directly; otherwise it falls back to the lane index. The result is stamped on every NoteEvent the lane produces, and the plugin’s processor passes it through to the VST3 output event list unchanged.

Start Here: One Drum Instrument

Leave every lane on Auto and do nothing else. Poly sends each lane on its own channel – the kick on Channel 1, the snare on Channel 2, and so on – and a drum instrument that listens on all MIDI channels receives every lane and plays each one on its GM note: kick, snare, hats and the rest land on the sounds a General MIDI kit keeps there. This is how the factory presets are meant to be heard, and it is what a new instrument track does out of the box: Cubase’s default MIDI input channel is Any, so the routing is invisible because there is nothing to route.

In Cubase:

1. Add an Instrument track with Poly as its instrument.
2. Add an Instrument track with your drum instrument – Groove Agent, Battery, Kontakt, or any GM-compatible kit.
3. Set the drum track’s MIDI input to Poly in the Inspector and leave its channel on Any.
4. Press play. Every lane arrives; the kit mapping inside the instrument decides what each note sounds like.

A MIDI Send from the Poly track to the drum instrument does the same job and keeps the routing on the Poly track’s own Inspector; the Using Poly guide walks through that option step by step.

For most creative work with a single drum kit, this is all you need. The per-lane channel becomes interesting when you want to break out of a single instrument.

Advanced: One Lane, One Channel

Assign lanes to different MIDI channels and you can drive separate instruments from a single Poly instance. A kick and snare go to an acoustic kit on Channel 1. A hi-hat goes to an electronic kit on Channel 2. A percussion lane goes to a world percussion library on Channel 3. Each instrument receives only the lanes assigned to its channel, and each can have its own processing chain, mix level, and spatial positioning.

Multi-Instrument RoutingCustom: Multi-Output

Lane	Role	Note	MIDI Ch	Target
1	Kick	36	1	Groove Agent (acoustic kit)
2	Snare	38	1	Groove Agent (acoustic kit)
3	Hi-hat	42	2	Battery (electronic kit)
4	Perc	63	3	Kontakt (world percussion)

This configuration produces a hybrid groove where the kick and snare share the warm acoustic character of one kit, the hi-hat has the crisp attack of an electronic sample, and the percussion lane draws from an entirely different timbral world. The polymetric relationships between the lanes are unchanged – the engine does not care about channels. But the sonic result is dramatically different from routing everything to a single instrument.

The practical benefit extends beyond timbre. With separate instruments on separate channels, you get independent mixing. The acoustic kit can sit in a tight, dry room. The electronic hat can have its own sidechain compression. The world percussion can swim in a long reverb. Each timbral layer occupies its own space in the mix because each has its own signal path.

Setting this up in Cubase takes a few steps, but the result is a flexible setup you can reuse across projects:

1. Leave Poly’s MIDI output on all channels. Poly already sends every lane on its own channel; nothing on the Poly track changes.

2. Create an instrument track for each target. A Groove Agent track, a Battery track, a Kontakt track – one for each destination instrument.

3. Set each target track’s MIDI input to Poly with channel filtering. In Cubase’s Inspector, set the MIDI input to your Poly instance and restrict the channel to match the lanes you want that instrument to receive. In the patch above, the Groove Agent track listens on Channel 1, Battery on Channel 2, Kontakt on Channel 3.

4. Each track receives only its assigned lanes’ notes. The channel filtering ensures clean separation – no cross-talk between instruments. Poly sends everything on every channel simultaneously, and each target picks out only its own.

This approach scales to as many instruments as you have channels. With 16 MIDI channels available and up to 8 lanes in Poly, you have more than enough headroom for complex multi-timbral setups. You can also double up – put two lanes on the same channel when you want them to share an instrument, as in the kick-and-snare pairing above.

Note Map

The Note Map is a 128-entry remapping grid that transforms MIDI note numbers before they reach the output. It sits at the scene level in the SceneState, which means the same mapping applies to all lane output regardless of which scene is active or where the Scene Morph position sits.

The concept is simple: each of the 128 MIDI note numbers (0-127) has a destination note. By default, the map is an identity – note 36 maps to note 36, note 42 maps to note 42, every note passes through unchanged. But you can remap any source note to any destination note, and the transformation happens after the engine generates its events but before they reach the DAW.

In code, the mapping is a single array lookup. The NoteMap::apply() method takes a source note, bounds-checks it, and returns the destination from the map array. The processor calls this on every note-on event just before writing it to the VST3 output event list. The operation is trivial in cost and completely transparent to the engine – the rhythmic generation has no knowledge that its output is being remapped.

The NoteMapView Editor

The Note Map is edited through the NoteMapView panel in Poly’s UI. The editor displays a row for each active lane, showing the lane’s source note, its GM drum name (if applicable), and the current destination note. Click any destination cell to open a menu of all available drum notes with their GM names. A Reset button restores the identity mapping.

The editor focuses on the drum range (notes 35-81) where General MIDI defines percussion sounds, but the underlying map covers the full 0-127 range. Remapped entries are visually highlighted so you can see at a glance which notes have been changed from their defaults.

GM Drum Kit Reference

The editor labels notes with their General MIDI drum names for quick identification. Here is a representative subset of the most commonly used mappings:

Note	GM Name	Common Use
35	Kick 2	Secondary kick
36	Kick 1	Primary kick
37	Side Stick	Rimshot, cross-stick
38	Snare	Acoustic snare
39	Clap	Handclap
42	Closed HH	Closed hi-hat
44	Pedal HH	Pedal hi-hat
46	Open HH	Open hi-hat
49	Crash 1	Crash cymbal
51	Ride 1	Ride cymbal
56	Cowbell	Bell patterns
60	Hi Bongo	Bongo high
63	Open Conga H	High conga open
75	Claves	Clave patterns

The full GM percussion map runs from note 35 (Kick 2) through note 81 (Triangle Open), covering 47 defined instruments. Poly’s editor includes all of them in its destination menu.

Practical Examples

Kit Swap. You have built an intricate six-lane patch using GM-standard note numbers, but your target kit uses a non-standard layout – perhaps a vintage drum machine where the kick lives on note 48 instead of 36, and the snare is on note 52 instead of 38. Rather than editing every lane’s note assignment and breaking your carefully tuned Euclidean distributions, remap 36 to 48 and 38 to 52 in the Note Map. The patterns are identical; only the kit layout changes. Swap to a different non-standard kit and you only need to update the Note Map, not the patch.

Octave Layer. Map kick note 36 to destination 48. Now every kick hit triggers the sample on note 48 instead of 36. If you have a second Poly instance or a layered kit that responds to both 36 and 48, you get sub-bass from one sample and attack from the other. The engine generates one event per kick hit; the Note Map and instrument routing turn it into a layered sound.

Melodic Percussion. Remap your lane notes to pitched instruments – marimbas, steel drums, tuned percussion. A lane generating Euclidean patterns on note 60 (Middle C) through note 72 produces a tonal polyrhythmic melody. The patterns are still governed by Euclidean distribution and macro modulation, but the result is melodic rather than percussive. This works especially well with kotekan interlocking lanes, where the complementary patterns create implied harmonies.

Note Map and MIDI Channel Interaction

The Note Map applies to all notes regardless of their MIDI channel. A kick on Channel 1 and a kick on Channel 3 will both be remapped if note 36 has a non-identity mapping. This is by design – the Note Map is a pitch transformation layer, not a channel-aware router. If you need channel-specific remapping, use different source notes on different lanes and remap each independently.

What to Listen For

Per-lane MIDI channels and the Note Map separate what plays from what you hear. The engine generates patterns based on Euclidean logic, cycle lengths, and macro modulation – pure rhythmic structure with no awareness of timbre or routing. The channel assignment directs each lane’s output to a specific instrument. The Note Map transforms note numbers to match whatever kit layout that instrument expects. Change the routing and the groove is unchanged. Change the Note Map and the groove is unchanged. Only the sonic result shifts. Listen for how the same patch sounds radically different when you reassign channels to contrasting instruments or remap notes to unexpected destinations – the rhythmic relationships remain locked, but the timbral character transforms entirely.