Kore, Komplete, Reaktor @ cdm

Minisite with tutorials, tips, features on making the most of Native Instruments music production tools

Let’s continue learning about the Roux sequencer macro. Last time we looked at the Event Table module in Reaktor and how a clock signal can read values from it. Since the Event Table has no memory associated with snapshots, builders typically use a Snap Value Array to store and recall sequences with snapshots.

Here’s the Snap Value Array in the Roux sequencer macro. I’ve pulled up the properties palette so you can see that it has all the default values except for the array size which is 64. Why 64? It’s four bars of sixteenth notes, which seems adequate for a short sequence, and it’s also a power of 2 which appeals to my inner programmer.

The two output ports on the Snap Value Array are Idx (index) and Out. Idx produces an event with the  current index, or position in the array between one and 64, and Out produces an event containing the value at that index. “Self-Iteration” is ticked in the properties, which is the default and means that this module will instantly spew out its contents when you change snapshots. This is how the Event Table gets populated with data.

Idx is connected to the WX (write x) port on the Event Table, and Out is connected to In port on the Event Table. When the snapshot changes, each event from Idx - values from 1 to 64 – is followed by an event from Out with the value at that index. When these events enter the WX and In ports on the Event Table, each one slots perfectly into the Event Table in turn.

Now you’re probably wondering why we’re subtracting 1 from the value coming from Idx. It’s because the Event Table starts counting at zero (up to 63 in this case) but the Snap Value Array starts counting at one (up to 64). Subtracting one from the value shifts the range so things line up on both sides.

Now let’s look at the input ports on the Snap Value Array. There’s an Idx port again, and a W(rite) port. The Idx sets the location where the next event at W will be written, and the event at W is recorded there. “Events Thru” is ticked in the Snap Value Array’s properties by default, which means that any values recorded here will also be passed through to the output ports and written into the Event Table. And since the Event Table gives you a graphical view of the values, you have some indication of what you’re doing!

I realize that this is a lot of information to take in, so if you have questions, please ask about it in the comments and I will explain. Maybe some of you are saying “this is definitely not for me!” – and that’s okay too – there’s more than one way to work with Reaktor. Not everyone has to be a builder! And not every builder has to work on the lowest level. Some of the most interesting user ensembles in the Reaktor library come from users piecing together macros and chunks of instruments created by others. However, diving down into the nuts and bolts, as we’re doing here, gives you a lot more flexibility and control over your creations.

I think we’re almost done looking at the low-level structure of this thing; one more installment ought to cover it. After that, I want to show you a few examples of applying it to other instruments, like a software version of circuit bending. After all, the point of all this is to make some noise.

7 Responses

  1. sowari

    another excellent bite-sized tutorial Peter :-)

    and if some of you are finding it difficult to take in, don’t worry, it will start to make sense soon… just give it a bit of time.

    so i suggest you copy and paste all these Roux tutorials and keep them in a folder so you can look at them at your leisure.

    looking forward to the circuit bending instrument!

  2. Peter Dines

    Hi Phil – yeah, I’m planning to collect these together in a single package after the last installment.

    I’ve never actually circuit bent anything physical – too lazy to get up early for garage sales and score old electronic toys, basically. Doing it to Reaktor ensembles lets me sleep in. :-)

  3. [...] Last time we looked at the Roux Sequencer we examined the Snap Array module, how it retains values and how it feeds them to the Event Table module when you change snapshots. In this post we finish up by focusing on how the Mouse Area module allows you to add and change the sequencer’s values. [...]

  4. [...] 1 – introduction Part 2 – the X+ module Part 3 – the event table Part 4 – the snap array Part 5 – the mouse [...]

  5. joshua kern

    thank you so much for this and all the work you’ve done, its been very helpful.

  6. Allpa

    This is exellent! and you have reason…this is much info for a begginer as me! I made some lfo’s in the past (tremolos, vibratos, wahs) but its definitely the next level

    thanks!

  7. Dave

    Peter, this is awesome: exactly the right information, just the right amount.

    Thanks for taking the time to put it up.

Leave a Reply