Use X-Touch Mini to control everything (gig, scripts, panel & overlay templates included)

MAJOR UPDATE IN POST #3, expanded functionality and support for X-Touch Mini with full LED sync

Up-to-date instructions here

Old post hidden

So, after quite a lot of suffering and debugging, I made this script (two scripts actually, and a panel), to fill the functionality gap in GP that’s been bugging me forever.

Context and purpose
I have multiple racks with guitar plugins, which have various sets of controls, and different sets of “pedals”, i.e. individual effects. They are named differently, of course, and some effects are present in some rackspaces and missing in others.

However, most of these controls are in essence the same or similar - i.e. Gain, Mid, Treble, Presence, Mid Boost, Gain Boost etc. Also, the “pedals” also have logically similar controls - Mix, Level, Time (which could be Feedback for delay, Decay for reverb), Time could be synced to host tempo, etc.

I also have some effects on the Global rack, mostly used for vocal effects - these are always the same.

So I wanted to be able to control all this with just one hardware MIDI controller, with a limited number of knobs and buttons, so that the same knobs will control relevant parameters on many rackspaces, either Global or “Local”, depending on context (switchable mode) and what’s available in a given rack. But the knobs themselves would always be the same, so I can change parameters from the hardware, without much looking.

Description

The attached gig file is a template for this. I tried to make it as reusable as possible, but it’s not too easy with GPScript, unfortunately, to make it truly universal, so adapting it to your scenario (number of knobs on your hardware controller, for example, or mapping to actual effects on racks) will require some tinkering and editing the scripts. I tried to add as many comments as possible and provided some templates to make it easier, but it will still require attention, setting widget handles, and some understanding of how GPScript works.

There are three songs in the gig file with their racks. Two of them are similar (with an “amp”, some “pedals” and an “eq”), one has nothing and doesn’t even support this script. One of the racks switches the script to control the “amp”, another one switches to “eq” control, just for the sake of illustration.

When you switch rackspaces or variations, or load the gig file initially, there’s some “handshake” between the global and local racks to determine whether the rack supports the script and which mode the local rack wants to start in.

If the rack doesn’t support the script, the thing defaults to “Vox” mode, which is controlling the effects on the Global rack.

Using the thing

On the Global rack, there are:

  • 4 “mode” buttons - Amp, EQ, FX, and Vox, these determine what exactly is controlled.
  • 4 “FX” buttons. In Amp and EQ modes, they turn individual effects on or off. In FX mode, they select individual effects on the Local rack to adjust with knobs. In Vox mode, they select individual effects on the Global rack. These can be mapped, for example, to a footswitch, to control effects during playing.
  • 4 control knobs and 4 control buttons - these are the controls that change things depending on context. These can be mapped to a hardware controller such as X-Touch Mini, for example.
  • If a rackspace doesn’t have some effect (or an “Amp” doesn’t have some control), the relevant knobs/buttons on the Global panel will become hidden (and their value set to 0).

How to adapt it to your actual racks/gig file

To see how it works, you can of course just open the attached gig file, it should work, but make sure you have OSC enabled. There aren’t any actual plugins in this file, this is just a demonstration.

If you like this and want to use it in your actual gig file, here are the things you should do:

  1. Enable OSC
  2. Save the panel from the attached gig file, add it to your Global rack. Change the number of widgets and their handles to have as many knobs as you need (or your hardware controller supports).
  3. Add the Global script to your Global script, and modify it to reflect the number of knobs you have on your Global panel, map actual Global rackspace effects (and probably delete the ones from this gig file if you don’t need them). You’ll need to modify the declarations, OnWidgetValueChanged, OnOSCMessageReceived callbacks, the rest should work, hopefully.
  4. Add the Rackspace script to your Rackspaces, modify accordingly to declare and map actual widgets, modify OnWidgetValueChanged and OnOSCMessageReceived callbacks.
  5. Map your hardware controller to the global rackspace controls on the new panel, and control everything using the same set of knobs regardless of plugins being used.

Known issues and limitations

  1. Mapping this to your actual racks is a manual process, there’s only so much I can do to universalize this, due to GPScript limitations (or my understanding of them). For example, the OnWidgetValueChanged (…) From doesn’t accept arrays, you have to manually type names of widgets separated by commas. So you’ll have to adjust that carefully.
  2. 90% of the time I spent doing this was trying to avoid feedback loops trying to sync widgets (you change widget A, it changes widget B, which in turn changes widget A etc.). After trying multiple techniques the one I’m using works well for buttons but skips every other step with knobs, so sometimes syncing isn’t awfully smooth, sometimes a global control may fail to update when you switch variations/song parts. If somebody can come up with a better way to sync widgets, it would be great.

Screenshot

Gig file
GlobalLinkPoC(4).gig (1.7 MB)

1 Like

Thanks for sharing!

Updated the gig file and scripts to work with X-Touch Mini, with full bidirectional LED sync, using different LED modes - i.e. they blink when there’s a widget to control but it’s off, light up when it’s on, knobs also change their LED modes - blink, switch to single when the controlled widget is off and “fan” when it’s on, so there’s now complete visual feedback.

The main purpose is to be able to quickly adjust things without looking at the screen, using muscle memory (plus the overlay template that indicates what’s where and visual cues from the LEDs).

With these scripts, X-Touch Mini can now control:

  • Up to 16 knobs and 16 buttons in an “Amp” plugin in rackspaces (32 parameters total)
  • Up to 16 bands of EQ in rackspaces
  • Up to 24 individual effects in rackspaces, with up to 16 knobs and 16 buttons each
  • Up to 24 effects in the Global rackspace, again with up to 32 parameters
  • In Layer B, it also controls global playhead, toggles metronome and tuner, has a tap tempo button which also blinks with tempo.
  • The fader on X-Touch controls output plugin level, if available.

If a rackspace doesn’t support the script, only the global rackspace mode is available.

Here’s how it looks:

Amp:

Amp mode

global link - amp

EQ:

EQ mode

global link - eq

FX:

FX mode

global link - fx

Vox (Global Rackspace effects):

Vox mode

global link - vox

GP transport/metronome/tempo control:

GP global controls

global link - gp control

As a free little bonus, there’s also tap tempo script for iRig Blueboard Bluetooth footswitch, also blinking a LED with current tempo.

The script will adapt to what your rackspaces have. The gig file has a rackspace that doesn’t support the script, and one that doesn’t have an “amp”. The knobs and buttons on the controller always control the same parameters, they will just be inactive if a rackspace doesn’t have something specific.

The gig file:
GlobalLinkPoC.gig (3.3 MB)

The scripts (need all of the includes for the beast to work, copy to your Scripts directory, be careful not to overwrite your $rig$ and $system$ scripts if you have any:
globallink_scripts.zip (23.6 KB)

If you want to adapt it to your gig file:

  1. the zip also contains the global script, the gig script, and a template (look in the templates folder) to make rackspace configuration easier (now you only have to declare the widget handles, and if you have Github Copilot (or a similar AI tool), it is fairly good at doing all the rest (it takes me now about 5 minutes to adapt the scripts to a rackspace).
  2. attach the panel to the Global Rackspace

Configuration instructions

The panel:
GlobalLink.gppanel (1.7 MB)

And last but not least - there’s also an overlay template for the X-Touch Mini:

An editable .psd for the template:
global_link_overlay.zip (9.8 MB)

And a printable .pdf:
gl overlay x-touch mini 4.pdf (782.4 KB)

Also, everything is now on Github, and there’s more stuff coming like new rackspaces (if time permits, within 1-2 weeks, hopefully).

Enjoy!

6 Likes

Impressive :beers:
(GitHub Link)

1 Like

This is fantastic. I would have received my X-Touch yesterday, but we got over a foot of snow and I live on a 16% grade hill. I’m not snowbound, but my car is. Hopefully deliveries will resume Thursday.

I’ve got a simpler use case. I’ll use the knobs as mixer trims, and I’ll control some global parameters like Play/Stop, Next/Prev Song, Next/Prev Part, Tuner, etc.

I’m confident about getting parameters from the controller to Gig Performer. I’m less confident about getting the GP values to the controllers. It will be a nicety to control the button LEDs, but the important part will be to get the continuous knobs to sync.

Any tips on where I should start? I expect to write my own scripts, stealing bits and pieces from your code to graft in.

Behringer should have given you a commission for my purchase. :grinning:

Well if you simply want to map the controller to some widgets that are always the same you don’t have to do anything special, just do it the normal GP way.

What scripting does here is 1) dynamic context aware reassignment so it works with various racks, 2) syncs button LEDs, which is tricky with XTM, and 3) uses different LED modes. The core really is 1, it’s an abstraction layer which will work with any controller (or without a controller at all).

I’m traveling this week so not near my XTM, but as far as I recall knob LEDs work without scripting.

1 Like

If the knobs work properly without any scripting, that’s excellent. The board will be useful within minutes. I’ll dig into the code to see how the button LEDs are handled. And I’ll be surprised if I don’t find more use cases that will have me adding features over time.

Thanks for the great script and motivation. And safe travels!

1 Like