Virtual Mapping Techniques

Midihub Tutorials
1

Hey everyone.

This is my attempt to collect together techniques I picked up with physical loopbacks, and have adapted to the new world of virtual mappings.

I hope folk find something useful in the entries below

cheers, R




Intro
This topic describes various “techniques” that can be useful with virtual mappings.
The list is not exhaustive.
Please add your own or PM me with suggestions.

Each Demo can be taken as stand-alone; have a quick scan of the notes about patches which explains the common structure

Contents

That's as far as I've got right now...

…other sections to follow as hinted at below.

If anyone else wants to provide content –either that I’ve not yet written or stuff I’ve not thought of– that would be great.

(Add it in a reply or PM me and I’ll insert it in the flow)

I’d really like this to be the go-to resource to help more users realise how useful virtual mappings can be: more shared knowledge leads to a better Midihub world

3 Likes
2

Setting Mappings

The mapping buttons now have symbols to keep them compact:

VMapBtnLegend
VMapBtnLegend1172×262 68.1 KB

MIDI Learn only works when Midihub is connected.
The other three buttons can be used any time (making it possible to write entire patches while disconnected)



When you have a lot of mappings to create, setting each of the four mapping properties by hand can be time-consuming.

Fortunately, the Dialogs are set up so you can effectively Copy & Paste mappings.

Here’s a sequence of examples:

You can set a virtual mapping that’s similar to an ‘external’ mapping

When connected, you can use the M button and turn a knob to MIDI Learn the properties…

VM0 init
VM0 init1377×260 59.3 KB

(here we’re about to click MIDI Learn on Work with … Range Low ) :asterisk:


VM1 Learn
VM1 Learn1390×720 140 KB

…then use Edit to adjust them

Copying Mappings

An existing mapping can be ‘copied’ to another property:

Click Edit to see the existing mapping…

…and just click OK to ‘copy’ it…

VM2 Edit
VM2 Edit1395×1517 225 KB

…Now when you click Add on another property…

…those same values are now ready to assign to that ‘new location’…

VM3 Add
VM3 Add1377×1057 189 KB

(In this example both ‘Range High’ and ‘Range Low’ are mapped to the same message)



…or modify before assigning:

VM4 AddChange
VM4 AddChange1362×1612 257 KB

(In this example, the ‘Range Low’ property of the next pipe is now mapped to CC98)



With a little planning ahead it becomes easy to assign a whole bunch of mappings quite quickly.

(This is particularly true with virtual mappings: because we often can choose which CC#s, etc to use, we can make similar assignments only 1 or 2 small changes apart)



:asterisk: On some OS’s (Win? Linux?) the selected button has a helpful red border all the while the dialogs are open. On Mac OS X you just have to remember. I dunno if @Giedrius can fix this; in the meantime Mac users get extra practice with the UnMap button…

2 Likes
3

The Demo Patches

Although explanations and pictures might be useful, seeing pipes and pipelines in action is the best way to learn Midihub.

To help show each of the “techniques” below, I’ve written a brief patch/preset to illustrate the idea.


Each patch is written to be standalone:

  • You can use your own keyboard/controller if you want…

    (there are MIDI & USB “Input Lines” for that)

    …but there’s no immediate need.

  • That’s because every patch has a Midihub LFO generating messages for us:
    (the “Generator Line(s)” )

  • These messages then make the mappings:
    (the “Mapping Line(s)” )

  • Then the mappings make changes to certain key pipes:
    (the “Demo Line(s)” )

    • sometimes the effects will be visible without even inspecting the mapped pipe – for example a Bypass getting toggled or an Input/Output changing its Source/Destination

    • in other examples, a key property like Transpose can be inspected, or an LFO or Equalizer graph can be watched.

So each demo patch will follow this pattern:

VM DemoSections
VM DemoSections727×730 85.6 KB

Note that I will often make no attempt to give the mapped pipes an output.
That’s because the demos are only there to show a technique and leave it you to adapt it for real use.


Trying out a technique

Unless the new capabilities a technique opens up are really obvious, I’d urge users to play around with the demo patch:

  • use MIDI Monitor on pipes in the mapping line to see how the mapping is created

  • change, say, a Rescale so the mapped options change (eg. reverse its High/Low)
    (eventually, why not even map the Rescale options themselves?)

  • try hooking a mapping up to an external device’s parameter so you can hear the effect

  • Sometimes, there might be an extra demo patch to spark the imagination with extra ideas.
    Again, very grateful for additions from other users. I’ll add them to the relevant entry.

back to contents
2 Likes
4

“Scaled” mappings

Before Virtual Mappings, many users pined for the ability to limit or scale the range of incoming messages for a mapping:

so if a control sends in values in a [0,127] range, we might want the effect on a mapped property to be only in the range [0, 32]
Virtual Mappings allow us to use Rescale to modify the incoming messages before they
reach a virtual port and can be used as a mapping.

This Demo

VM1_rescaled_mappings.mhp

There are 3 Rescale pipes creating 3 mappings:

  1. CC#3 is Rescaled from 72 → 119;
    this changes the Input Pipe Source from Virtual A → Virtual G

  2. CC#4 is Rescaled from 52 → 76;
    this is used to restrict Transpose to ±12 semitones

  3. Note 24 (low C) Bypasses MIDI D OUT when the velocity is low

Extra

VM1a_rescaled_extra.mhp

This patch shows the effect of more than one synced CCs on, say, LFO or Equalizer

back to contents
2 Likes
5

“Scale Down → Scale Up” mappings

Using Rescale to ‘squeeze’ the 0 → 127 range to a small number of values, then another Rescale to ‘stretch’ them is a good way to make a few ‘spaced out’ values

VM2scaling

This Demo

VM2_double_scaled_mappings.mhp

  1. A Transpose pipe mapped to jump in octaves

  2. A Delay pipe with Time Division mapped to only give the dotted times (1/16• → 1/2•)



Notes:

  • as two mapping lines are used here for clarity, each has a CC Range Filter to prevent unscaled mappings reaching the same virtual out of the other line.
    This can avoided with just one mapping line obviously, or by using different virtual outputs, if you’re not already running short!

  • Rescaling down to a small number (3 → 20 ish) leaves a noticeably smaller range for the highest and lowest values. I compensated for this by clipping the In Ranges of “Scale Down” Rescales.

:thought_balloon: getting a “double rescale” right can take a little tweaking. Should have we an explainer for Rescale/Remap?

back to contents
2 Likes
6

“Toggled State” mappings

Another popular request answered by virtual mappings: a toggle switch that alternates with successive key presses.

Here the mapping line is mapped to itself: the value stored is Argument 1 of a Transform pipe is flipped by the Rescale at the end of the pipeline. This “reversed” value is then mapped back the Argument itself, changing it ready for the next key-press.

This Demo

VM3_toggle_switches.mhp

Many “switch” Transforms can be placed in the same mapping line.
This Demo uses 3 switches (but you can add as many as you like)- each controls a Bypass in the demo line.

One Button CC version (no Generator Lines)

Here’s a two line preset showing just a CC10 being used to switch an input On & Off
VM3.1_Single_CC_Toggle.mhp

These diagrams show the message flow…


…when the CC10 button is pressed…

VM3_1 0-127
VM3_1 0-1271983×1213 181 KB

…and then pressed again…

VM3_1 127-0
VM3_1 127-01983×1216 176 KB

(Check this with the MIDI Monitor at various pipes)

back to contents
3 Likes
7

“Cycled State” mappings

A toggle state cycles between just two values. This demo show one way of cycling between up to 16 values by using Dispatcher

This Demo

VM4_cycled_mappings.mhp

The Demo line source will cycle between certain inputs dictated by the Dispatcher channels selected.

Notes:

  1. Whereas a “Scale Down → Scale Up” mapping will allow output values like 16, 24, 40, 48, 56, 64, this technique goes through the values in (‘Round Robin’) order
    and allows us to skip values to give, say, 16, 24, 56, 64

  2. This Dispatcher is set to the original ‘Round Robin’ Algorithm to ascend the values and then cycle back to the lowest.

    Setting to ‘Ping Pong’ or ‘Random’ will give quite different results which may also be useful or interesting.

  3. The key Transform uses Set Value to Incoming Channel. This produces values 0, 8, 16, 24,…
    A Rescale is included to change this to whatever mapping is suitable.



Other techniques which can give similar results include:

  • Multiple “Range” mappings.
    A pipe per value approach.
    More flexible, can be any length/spacing, more laborious to write and adapt

  • Scale Remap approaches.
    Limited to 12 values initially.
    Very useful when you need a custom route through a set of values
    (This is detailed below & an example can be found here)

Scale Remap cycles

The Dispatcher technique above allows a single key/button to run through an ascending sequence –perhaps with gaps– with up to 16 elements:

0 → 1 → 3 → 6 → 8 → 9 → 12 → 0

This variation allows for a sequence in any order with up to 12 elements:

0 → 6 → 3 → 11 → 10 → 9 → 5 → 0

It uses (misuses?) the Scale Remap pipe’s ability to send any semitone to any semitone…
…and stores the result in the Transform that creates the Remap’s incoming note.

VM4a_ScaleRemap_cycled_mappings.mhp

This animation shows this in action selecting 4 LFO Waveforms:

Saw Up → Tri → Saw Down → PWM → (Saw Up)

LFOcycleUniF
(the Roman numeral interval numbers get a bit confusing – I just ignore them and count from zero!)

Other use examples would be selecting Arpeggiator Note Lengths &/or Arp Types in a particular order.

This approach, like “Toggled State” mappings needs to store its state in a Transform argument

here's the message flow

VM4a_schematic
VM4a_schematic864×544 74.2 KB

here the Scale Remapped note has two roles:

  1. to create an scale the mapping state we want for elsewhere in the preset

  2. to map the new note# back to the “creator” Transform so that it is ready for the next external trigger.

NB. The Length pipe is necessary as, otherwise, Scale Remap will not work as expected once it has reached it’s memory limit. We use the Note Off here for mapping 2.

Scale Remap Extras


Intro and Loop sequences

Scale Remap can also be used for a lead in to a cycle eg.

0 → 6 → 3 → (11 → 10 → 5 → ) (11 → 10 → 5 → )…

or even

0 → 6 → 3 → (11 → ) (11 → ) (11 → )…


Multiple sequences
In these cases, it may be useful to use a separate button/key to jump back to the beginning of the sequence.

The approach can also be used for multiple cycles triggered from separate Transform Note On “creators”, each following a (non-coincident) path;

  • say 0 → 6 → 3 → 11 → 10 → 9 → 0

  • and 1 → 4 → 8 → 7 → 10 → 2 → 1

(here the separate “creator” Notes are on different channels so that they can be handled independently after the Scale Remap)

back to contents
1 Like
8

“Trigger” mappings

Mappings that only happen when a value threshold is reached



to be continued…

9

Multiple “Range” mappings

Similar to above – using Transform pipes to select ranges of input values



to be continued…

10

“Timed Choice” mappings

Using Virtual mappings to distinguish between say a “long press” and a “short press”




to be continued…

11

“Anonymous” or “Proxy” mappings

Even ‘traditional’ mappings can be made more versatile by substituting virtual mappings.

This perhaps so simple it’s easy to overlook how useful it can be.


Instead of the usual mapping from MIDI-A, USB-C and so on…

Anonymous0

…use a virtual mapping


The mapped property behaves exactly the same…

…but now you have the freedom to send the mapping message from wherever you want…

Anonymous1
Anonymous1483×533 82.5 KB

…without having to remap your controls


Why is this useful?

The mapping might be modulated initially from a keyboard or controller on MIDI-A…

…but later you might want to send these same mapping events from…

  • …a sequencer on MIDI-B

  • …or a DAW on USB-A

  • …or even from within Midihub itself
    (showing an LFO here but there are many other possibilities)


“Anonymous” mappings allow us to just add those inputs to the message flow…

…instead of re-designing the mappings or adding extra ones.

And if you decide later you want to change the channel (or some other attribute) of the mapping…
…it’s maybe be easier to just add a “channel translation” Transform to “correct” the incoming channel…

… particularly when that mapping is used multiple times…

… or it’s months later and you can’t really remember exactly what you did back then!

Anonymous2
Anonymous21279×943 313 KB

Lastly, it might make it easier for folk to adapt your patch if you decide to share it (as discussed here)

(FWIW, nowadays, I use this technique as soon as I go beyond the “quick and dirty” phase of building a preset.)

Demo patch

VM11_anonymous_mappings.mhp

The LFO in the last pipeline has it’s Depth and Phase modulated by CC3 & 4 respectively

  • “Un-Bypass” pipeline 3 and watch the mapped LFO graph move automatically

  • Bypass pipeline 3 and modulate the graph manually from one of the external inputs.


These CCs are “channel corrected” by the two Transforms in pipeline 4 so you can either…

  • …“break” the mappings by Disabling the Transforms and using a Channel input other than Ch.1

  • … or change the Work with CC Number in Range Low|High value to adjust to the CCs coming from your controller.

12

04/02/2025 Update
content finally added for “Anonymous” mappings

1 Like
13

21/02/2025 Update
content added for “Cycled State” mappings using Scale Remap cycles

LFOcycleUniF


Also, graphic added for “Scale Down → Scale Up” mappings

1 Like