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.

Sequencers are, by definition, all about controlling sets of events. Having unlocked the mysteries of time — the clock and timing data you need to keep your sequencer in sync — Peter Dines now tackles how a table can organize a sequence of events or steps. Take it away, Chef! -PK

Here’s the next puzzle piece in our series dissecting the guts of the Roux step sequencer macro - the event table. As you might guess from the name, the event table receives and sends event rather than audio data.

By default, the event table holds values between zero and one, and I know I bang on about this lot, but that’s a super convenient range because it’s so easy to scale. Ed.: It’s what’s called a “normalized” range for this reason - and easy to scale, indeed. Want 0 to 127, for instance? Just multiply by 127.) -PK We dealt with scaling the output in the last post on the Roux sequencer.

I decided the best way to tackle teaching the guts of the Roux step sequencer is to blog one piece at a time, and work backwards from the business end where the values emerge.

The values that this macro produces are between 0 and 1 by default, which is a convenient range for all sorts of applications, but sometimes you need a different range of values - for example, from 0 to 127 for MIDI note pitches. I’ve included an X+ module just before the output to make it easy to scale values:

The values emerging from the event table are multiplied by one and have zero added to them, which means they pass through unmodified. Here’s a video demonstration of what happens when you multiply and add other numbers:

Multiply / Add module in Reaktor from Create Digital Media on Vimeo.

If you’ve ever worked with electronics, think of the way the X+ is used here as being like those little mini trimpots on a circuit board - handy for adjustments but not something you mess with every day once you’ve got a contraption put together the way you like.

In French cooking, there’s a sauce base called a roux (pronounced “roo”) that is the foundation of bechamel and other sauces. This is a sequencer macro that is the equivalent for programming sequenced instruments in Reaktor - you can take it in any direction from here. In its most basic form it can send velocity information to trigger percussion, or modulate instrument parameters like cutoff and resonance. With a few simple changes it becomes a pitch sequencer, suitable for use in something like the Frankenloop device.

Last time around, we had a look at creating a basic grain delay from scratch. It’s usable, but why stop there? Here are some improvements.

I’ve really been enjoying playing with patches based on Peter Dines’ Grain Delay tutorial. If you haven’t yet checked out that tutorial, it’s a terrific way to get started with a built-in Reaktor module that’s essential to all kinds of effects. The ensemble itself doesn’t get too fancy, meaning it’s friendlier to beginners than some of the polished-but-complex ensembles you find in the Reaktor examples and User Library. And that’s part of the point — the way most people are likely to use Reaktor in their own ensembles is to start small and basic, not necessarily with elaborate custom skins and complex features.

Peter’s example works really nicely for navigating an ambient sound. But I started thinking about using this for rhythmic ideas, so I could build a custom grain delay effect set up for easy live performance in Kore. To get beat-synced, sequenced effects, you need to work with clock information. The clock will act as a kind of metronome for your beat-based effects. That means turning to a previous Peter Dines tutorial:

Revving up Reaktor: A Refresher on Clocks and Events

We had a refreshingly frank comment from reader armachian:

“after reading I now realise that Reaktor is not for me!! Compared to something like the Clavia G2 this seems like a lot of steps (and hidden tricks) for a simple sequencer/clock demo. Life is too short!”

Actually, that’s right – life is too short! But I think armachian misunderstood. The whole point of having a modular system is you don’t have to repeat the same steps over and over again. You can simply re-use basic macros, like the SeqDriver macro Peter created, shown top right. You don’t have to even know how it works (though it couldn’t hurt); you can instead focus on what you want to do. In fact, even if you’re using macros you’ve created yourself, this can keep you focused on your musical aims rather than getting hung up on the mechanics underneath.

In a previous post, I linked you up with a Native Instruments tutorial on DSP in the Core level of Reaktor 5. Ed.: That’s “Core,” as in the powerful low-level sound engine inside Reaktor, not Kore with a “K” as in the Kore product.-PK That may have been a little… challenging, shall we say… for average Reaktor users, as it involved some skull shattering mathematics.

Now Stefan Schmitt has posted Vadim’s Core structures in the user library so the rest of us mere mortals can make some use of these algorithms. Stephan explains in plain English -

In a nutshell: it’s a way to get high-quality filters without oversampling.

Ah! Well then, we shall have to try to work these into an instrument.

Kore’s hardware controller is great, but sometimes you want control from another device.

I’m working on a Kore performance and setup that allows the use of a Nintendo Wii Balance Board (as included in Wii Fit) for live performance. I’m having a great fun and can share the results in a few days. But I realized the basic procedure applies to other tasks, as well, and may not be obvious to beginners.

Last week, I covered the way different control pages can be used:

Demystifying Kore Control Pages for Automation and Performance, Pt. I: Different Page Types

MIDI Assignment

In this case, I want to create a user page that covers “macro”-style assignments for my whole performance, so I want a performance-level user page. I can map those eight parameters to whatever I like. (For the Balance Board, I’ll just use the top four, because the hardware has four sensors. If you had an X/Y pad like a Korg KAOSS Pad, you might use just two.)

Then I want to give these MIDI controller assignments, in addition to the usual Kore Control assignments.  From the user page, click “Control.” In the bottom right, you’ll see a “Controller #” assignment. You can type in a controller number directly. (Once it’s typed in, you can drag up or down to change it with the mouse or type a new number.)

Reaktor and Kore 2 complement each other nicely, and one of the ways that is most apparent when using Reaktor effects in Kore. The high resolution control knobs and buttons are a snap to map to Reaktor’s faders, knobs and switches. Creating Kore sounds out of your Reaktor patches is also a good way to keep track of your creations and search for sounds by keywords.

Building and Using a Reaktor Grain Delay in Kore 2 from Create Digital Media on Vimeo.

In this video tutorial I’ll walk you through building a granular delay effect - in essence, it’s more like a granular live-sampler, which you can use with canned loops or audio from live musicians. I’ll also show you how to map its controls to the Kore 2 controller. This is just the beginning! In upcoming tutorials we’ll look at adding modulation, automation and other refinements.

The following download contains a Kore performance and the Reaktor ensembles you’ll need to follow along with the tutorial. Have fun!

Grain Delay in Kore

Note: Because Kore uses absolute paths for presets, you’ll need to manually point it at the included preset using whatever directory you’ve chosen for installation.

There are now plenty of ways to assign controllers to software, via old-fashioned MIDI learn and new automatic mapping features. But one major strength of Kore is that you get a number of benefits these methods don’t generally have (or don’t have all in one place):

• Hardware control with the Kore controller, not only for individual encoders but even navigating between pages and parts of the interface. (You really don’t have to touch your mouse for many features.)
• Visual feedback and navigation using the hardware, so you can always see what you’re controlling.
• Eight things: Because the layout is always eight encoders (4×2), you never have more than eight things to keep track of at a time – much easier on your brain. And you can choose those eight things:
• Custom pages: Rather than paging through the dozens of parameters in many plug-ins, you can make custom pages. This lets you choose which parameters are important and organize those parameters however you like.
• Host automation support: In addition to using control pages for physical control with the Kore controller, you can use these pages to better organize which parameters are accessed by your host. That makes it much easier and more fun, for instance, to draw in control curves in Logic or SONAR or use envelopes in Ableton Live.

Initially, though, you may find the various levels of pages Kore lets you use confusing. Before you can be productive with Kore, it helps to fully comprehend what’s going on with the different pages.

There are three basic kinds of control pages:

1. Channel pages (automatic)

2. Plug-in pages (automatic)

3. User pages (editable)

The only pages you can custom edit are actually the user pages. Both channel and plug-in pages are automatically populated by Kore’s software. It’s easier to see what this means by walking through each. I’m duplicating the manual a little bit here, but I think seeing this stuff in action is a little more manageable.