I am Hydlide of Reason experts. In this article, I am going to create a combinator that would be similar as an approach to how the NNXT internally works. Since I have heard a lot of times, we need a better sampler inside Reason. Yet at this point, we have a better sampler since Reason 10, Grain sample manipulator. The only issue with Grain in its current state is that it is a single-layered sampler (kind of similar as the NN-19 would be). Single layered meaning, it can only hold one sample per instance and we can modify one sample per instance of Grain. However, when you start stacking instruments inside the Combinator you will get the best of both worlds: 1. A better sampler in reason and 2. a layered grain engine. I might note that the amount of time that goes into setting one up is pretty much insane. It totally depends on how much time and effort you want to put into making a custom sampler in this context. But I can also add that layering samples inside the NN-XT are also pretty time consuming (as I have noticed while making my Refill 2016, a year time was put into that... ).
Anyhow, the method I am going for this approach is going to be rather straightforward and it requires a lot of repeating step. Just to avoid too much repetition I will keep things simple for now, provide the patch as it is built (based on this article) and you can examine the build I have created. So you would get a more in-depth clue on what is really going on here.
The NN-XT sampler, how it works
The NN-XT sampler in Propellerhead Reason is a multi-layered sampler consisting of zones. Each zone can be seen as a layer that has a boundary of rules that are defined within the NN-XT sampler itself.
In this case, one of the zones has a rule that the low velocity is set to 1, while the high velocity is set to 97. Different settings could be applied within one specific zone. The velocity to level could be one. A different one could be velocity to filter. Or one could define different ADSR (Attack, decay, sustain and release) for another one. These are different takes you could make when it comes to defining what set of parameters are defined within one zone.
While looking at grain, this is a whole different story since grain does not operate in terms of zones.
Grain houses a single sample, and all the definitions of the layer are made inside one single instrument. While adding a second layer of Grain they do not know much from one and other what to do with them.
So in theory, grain is somewhat like a dumb single use sampler where you can't really control much on when it comes to interacting with other devices. Sure you can create a nice modulation bus matrix that defines how a single sample plays like. But what if you want to layer different sounds with different velocities and then have the movement different per velocity state and define this with a set of groups/zones?
The answer lies in the following paragraph, but first I want to ask did you take your medicine today? ;)
The Combinator and Zones
Inside the combinator, you may find a setting called a "programmer" (show programmer). This programmer is often used to program settings such as rotaries and buttons. Where you can connect a single rotary to connect to one or more parameters. Normally this works pretty well (however I am really missing the copy/paste instrument inside the combinator and it would use the same settings from the pasted device). But if you look at the bottom of the combinator you can see different ranges that can be defined.
These would be the key range and velocity range. While a lot of zones inside the NN-XT are using mappings such as "this sample can only play from this key to that key", and also uses different velocity states per zone, we can define such a set of zones inside the Combinator. Make note, this does not include round robin by default (where the NN-XT has this, the combinator does not, but Blamsoft Distributor could be a replacement tool for that)! Just to avoid too many patients ending up in the hospital, I will keep things simple for now. Focusing on the key range and velocity range.
While you can setup key ranges and velocity ranges, they do not work the exact same way as the NN-XT. Since inside the NN-XT you can define a zone.
To make a conversion from NN-XT to grain (one to one) you will need to define what makes the sound tick more or less. It begins with analyzing the different zones, what are the differences there, and look which samples are used in the NN-XT. For this example, I will be looking at a patch like the Grand Piano, and I will be making my granular version out of that one.
The grand piano from the NN-XT instrument has two different zones where one zone is mapped from low velocity 1 till high velocity 97.
This is what is referred to the soft layer of the grand piano. And it contains samples ending with the suffix "3". For multiple notes ranges, a key is sampled. And these ranges may vary. The second zone consists of samples ranging from low velocity 98 till 127.
The samples used are having the suffix "4x". Again the note ranges may vary. But luckily these are also in the naming convention of the samples themselves (so we can use that as a reference).
When we have that all down, we can start building a combinator patch with the initial concept that contains all the samples from the low (soft) layers. Expand that with the high (hard) layers later.
These are all the individual samples coming from the Grand Piano. All are now ported into individual grain samplers instead. So we now can build a unique complete granular piano.
Programming the combinator
Now comes the boring part (because of the Reason workflow, there is simply no other way... just saying). While inside the NN-XT we could map the zones automatically, using the grain setup as above we need to make that manual. The idea here is to map the keys so they fit in the key range they should be located at. While porting the zones from an NN-XT sampler we can get this information from the individual samples themselves.
The key range a sample is playing is located under the low key and high key settings. These are the ranges used to trigger that specific note.
To port this to the combinator we can use the "show programmer" part. To make things a little bit easier I have mapped all the labels with the notes they are playing. This makes finding the proper start and end notes much easier. Because all we need now is to look up the current label, the previous label and the next label and we already know what the key range is that is used for that specific grain sampler in particular.
In this case, the layer D#23 could be using the key range D1 till E1. Every note is one octave lower (compared to what the original label says in this particular case).
In the end, the keymapping could be looking like this. Every instance of Grain now listens in to a specific key range. These ranges might need adjustments later (because of pitch variations that are not correct)
Next, we need to define the velocity for every instrument. The first range is 0 to 97. The second range is 98 to 127 in this context.
Ones everything is set up, we can modify different settings the way we see fit. For instance, we can define a single rotary to control the filter, or we can change the grain engine, etc. It just depends on which direction you want this granular engine to be like.
I might note it has taken me up to 15 minutes to program just every single rotary. Where these are programmed as such:
Rotary 1: changes the play mode (algorithm) of the grain engine
Rotary 2: changes the motion (the way that the grains are played back)
Rotary 3: changes the start position of the sample. for the piano, not a good idea, but for other samples they might be handy
Rotary 4: the release of the amplitude
You can download this Reason 10.2 combinator patch using the following button:
Have a nice weekend!
Written by hydlide