On The Inside

On The Inside

Tuesday, October 27, 2015

Reaktor 6, Faking Blocks with "Mocks"

Fig 1. Simple "Mocks" VCA that will work with Blocks.
Reaktor 6 blocks sure seem to be getting a lot of attention. Interestingly, users who haven't done much building in the past are viewing blocks as a gateway into understanding the internals of Reaktor. The idea of building just one part of a synth seems less daunting than the idea of building an entire synth.

On the one hand, the general idea is  true. Because you don't have to build the entire synth, just a block, then there's less to learn and you can focus on just that one thing. On the other hand, blocks are painfully complicated for the Reaktor newcomer, so building proper "blocks" is not really a good place to start learning. That said, you don't have to build proper blocks to combine blocks with your own creations. They're just instruments with audio ins and outs. If you don't mind a few compromises, then it's possible to make blocks-like modules that work with blocks.

A Trivial Example

 

Suppose that you wanted to build a VCA from scratch in Reaktor. Well, at a very basic level, it's trivial, it's nothing more than a multiply. You can certainly just put this in an instrument and use it with blocks, it will work fine.

Figure 1 shows what the structure of such an exceedingly simple VCA might look like. I call the instruments described in this post "Mocks, short for Mock Blocks. They look like a block, they act like a block, they are compatible with blocks from the user's perspective, but they're not blocks according to Native Instruments.

Fig 2. Mocks Silly VCA in a simple synth.

I've added the stacked size macro to force it to block size and the text module to give it a nice blocks-ish front panel look. It's a bit silly, but it works. It might look something like Figure 2 in your blocks synth. Here I've used  a background lifted from the Bento Box VCA. While you're at it, no point in going halfway in the looks department, it's easy enough to add the icon image so that the structure is even pleasant to look at. Granted, there isn't much value to putting a multiplication inside an empty U/I, this is just a trivial example,
Fig 3.  Structure of the simple synth shown in Figure 2.
So, sure, the idea of using blocks to understand synth parts is perfectly valid. You don't have to create a block just to learn how to create a part of a synth in Reaktor. Just make sure to scale the inputs and outputs appropriately. Some are going to present more of a challenge than others, but learning how to interface the two worlds will provide good motivation for learning more details of building with Reaktor without the daunting experience of starting from ground zero.

While there is a lot to be said for adhering to the blocks "standard", building blocks with primary process macros, or even, as I did above, with no macro at all, still leads you to an instrument that can work. Even some of NI's "blocks" use primary process macros. The "Note in" is an obvious example, but the Monark oscillator wraps the core macro inside a primary macro. My guess is that's an early block and they decided later to go with core process blocks, but, it is still an example and uses primary to generate a random seed.

Fig 4: Top level of a Mocks Mixer
Personally, I think that the two best features of blocks are the introduction of "separation of concerns" into the Reaktor builder mindset and the introduction of standard sizes for instruments. I've been building my stuff like this for a while, but having it sanctioned by NI means that others will follow suit. I suspect that the current incarnation of blocks is some intermediate step in the evolution of Reaktor and that at some point in the future having instruments with non-core process blocks will break some feature, e.g., maybe you won't be able to take advantage of multicore if you aren't using true blocks. For the present, it really doesn't break very much to have non-core process blocks, as long as one takes care of the inputs and outputs properly.


A Better Example


Here's the mixer from my poly nano ensemble from the user library. Note that I don't call this a block, and I didn't upload it as a block, but you can believe that I use it as a block. You don't need core to make a simple un-modulated mixer and this breaks absolutely nothing and works exactly as you expect with any blocks patch that you build.

Fig 5. Process macro of Mocks Mixer from Poly Nano
 There are no modulation inputs and, thus, no expectation of audio rate modulation. Note, that doesn't mean that you couldn't incorporate modulation inputs, but they're certainly quick and dirty to create if you don't have to think about modulation. Inside the process macro is exactly what you would expect, a couple of primary mixer modules with level inputs scaled to work with a linear knob.

Fig 6. Mocks Mixer panel macro.
The panel macro is shown in Figure 6. and it just contains all of the nice blocks U/I bits that make them pleasant to look at. At the top level there is the stacked macro that forces the size and the text that gives you the logo. I should have named it "module name", but I did this quickly.
Knobs are kind of a pain in blocks because you have to include several images layers to build up the look.The knob shadow, for example, isn't in the knob filmstrip. Even with a Mocks block I still want to have a nice looking panel and so I create macros for knobs so that it makes them easy to move around. By selecting the macro in the structure, you can move all of its contents around in the panel view. 
Fig 7. Knob macro from mixer panel.
 The inside of the panel macro can be seen in Figure 7. As discussed above with the simple VCA, none of the separation of concerns or encapsulation is really necessary to make this work with blocks, it just makes it easier to reuse the parts of it in other instruments. Adding modulation is not difficult, but, you want to pay attention to event rate vs audio rate signals. I'm going to use a simple example from the factory library that already has an audio rate modulation input.

 

 

An Example With Modulation

Fig. 8. Factory "filter" module from the library.

There are several filters and oscillators in the factory library. At first you might think, why would I care, blocks has plenty of choices. This is true, but, the blocks that come with Reaktor are CPU hogs. Often you might have a need for a filter that won't be pushed to the limit and so the value of fancy new technology is just wasted in extra CPU cycles. Or, simply, perhaps you prefer the filter response curve that's displayed in the factory macro. I'm going to use the State Variable macro that is in the library under filters, it's just called, "filter." Figure 8. shows what this macro looks like as shipped from the factory.
Fig. 9. Mocks SVF
The standard macro is fine, but it won't fit well with blocks. It's easy enough to rearrange the panel elements and change the knob images so that it looks something like Figure 9. I changed the list for filter type to a menu. To allow control of the modulation input, I added a single knob to the panel macro and connected it to a terminal as before. I've added a background and the 3U stacked macro to the instrument so that it is blocks compatible, visually speaking.
 
Since the modulation input to the macro is already an audio rate input, there is no reason that we can't use this directly with Blocks. The only thing that we need to do is to provide scaling. Now, if we were committed, we could actually create a true block out of this macro since it is core at its core (you knew that was coming). But, I don't always need or want all of that U/I. The big win comes from the consistent size and the slightly larger knobs and panel elements. To control the modulation amount, we only need to add a simple VCA, like above, between the ModA input and the mC modulation input to the macro. That's really all that you need to control modulation, all of the rest of the stuff in the Blocks U/I is to show you pretty modulation rings, flashing lights, and mouseover values. Yes, they're useful, no, they're not essential, yes they consume CPU!

Fig. 10. SVF Modulation input. 



That's it, now this can be used with other Blocks just as you would use any other Blocks filter. Will it sound as good? In a word, no! But it is useful, and it's not incompatible with Blocks

Fig. 11. Mocks SVF added to the simple synth from above.
Blocks make building up synth patches fast in Reaktor 6. Many of the factory blocks use relatively new technology which is why they sound so good, so it's understandable that people are excited about building blocks. If you want to create actual blocks that can be uploaded to the user library and shared with other blocks users, then you should take the time to read the NI blocks document and download the template. On the other hand, blocks are not the only way to create modular instruments in Reaktor. There have been many different efforts over the years and it isn't necessary to throw out the old baby with the dirty bathwater. In some cases, such as the mixer above, the "core" advantage to sound quality is slim to none. Consequently, it makes sense to resuse a lot of what already exists alongside the new technology. These older macros and instruments can not only be combined with blocks, but, their contents can be given a face lift to make them easy to use with blocks.

 





Thursday, October 8, 2015

Reaktor 6 Blocks - Multi BreakPoint EG

I'm really enjoying a lot about Reaktor 6. The new Blocks format is, on the one hand limiting because they are monophonic, is still a lot of fun and great for rapid instrument prototyping. They do remind me a lot of working with the Nord Modular.

In Reaktor 5 one could do reasonably rapid prototyping with one of two macro collections provided by NI. Both the building blocks collection and the classic modular collection of macros behaved similarly to blocks, they just aren't quite as sexy looking, or sounding.

Since blocks are new, there's still a lot of room for improvement in the diversity of available tools. For example, there were some very flexible and complex tools in the aforementioned collections. One that comes immediately to mind is Erik Weigand's multi breakpoint envelope.

I converted this macro to blocks format, which wasn't too bad since most of the heavy lifting in Erik's macro is done in a core cell. However, it's no small task to get all of the bits of the new user interface elements lined up, something that I wish NI would work on improving.

I've added modulatable time scale and shape factor, added switchable velocity sensitivity, and change the color scheme to be similar to the bento blocks. 


It's free for Reaktor users and you can get it in NI's User Library. Please feel free to leave any comments or feedback, bugs, issues, feature requests, either in a comment here, the user library, or in NI's Reaktor forum.