Introducting jambient Matrix

jambient Matrix is a Reaktor ensemble in the jambient series. Ensembles in the jambient
series are designed for live jamming with samples, geared to ambient-style sound making
and nonrythmical audio collage. This one is designed to be played as a VST instrument
and is inspired by the capabilities of Ableton's Live sequencer. But it is designed to do
something that Live strangely makes impossible: playing and organizing samples, Live
style, without having them be locked/stretched to a rhythmic grid.

When listening to the included demo, make sure to select the AlterFan Tour Slow
snapshot in the jamPaneer Instrument, or play with other jamPaneer snapshots.

The main instrument is the jambient Matrix. This contains eight Sample Columns, each
containing eight samples. Use drag and drop (for example, from the jambient Browser,
available in the Reaktor user library, or FileMatrix) to fill up and continually change your
Matrix of 64 samples. Click on the Column buttons to select the samples you want to
play, and change pitches (including playing in reverse) as you like. When using VST
automation for sample selection, this means that you can travel through samples with a
turn of your hardware controller.

Each Column contains a Sequencer, so that when a sample in the Column repeats N
times, there is a probability that the next, previous or a random sample in the bank is
played, or that playing stops. The sequencing behaviour is controlled by the dropdown at
the middle left of each Column; N by dragging left or right the yellow line in the
Repetition Trigger bar above the dropdown, just below the Sample Repetition Count
meter; and the Sequencing Probability by the box to the right of the drop down. In the B
view, you can also draw Pitch Sequences for all samples in the bank, to give melodic
contours to your sequence, or select other instruments to use as pitch modulators.

Matrix Controls on the right hand side of the instrument let you play entire Rows in the
Matrix. There is a also a Row Sequencer for sequencing play of entire Rows. Interaction
between the Row Sequencer and the Column and Pitch Sequencers allows for complex
self-chaning landscapes. Columns can be isolated from Matrix using the dropdown at the
middle right of each Sample Column.

Each Column has a Volume control that fades output up and down at a speed defined in B
View. Clicking on Swch fades up the sound if it is muted, and fades it to mute if there is
some volume. Clicking on Swch in the Matrix controls lets you fade out all Column
currently sending output, and fade up all Columns currently muted, to achieve dissolve
between outputs of Columns.

See the tooltips in the Matrix for further documentation.

The ensemble includes the jamPaneer instrument, which provides dynamic pan
modulation. Or it can be used to simply mix down the 8 mono outputs of the Matrix to
stereo LR, or pass through all 8 mono outpus to 8 stereo outputs (these options save
CPU). See documentation below for use of jamPaneer.
The ensemble ships with a small number of sampless, so you don't have to tell Reaktor to
respond to missing samples 64 times--but normally you'd have close to 64 different
samples loaded.

The jambient Matrix instrument accepts 8 modulation inputs which can be selected on a
per Sample Column basis to modulate the pitch of sample playback. Included in the
ensemble are instruments containing jambient Modulators (see documentation) for
achieving turntable like effects, and a jambient TerrainoSoar, which generates modulation
signals by having a 'record needle' soar over a graphic landscape (stored in an event
table). See documentation below for more on these modulators. You can mute these to
save CPU.

Some elegant programming (using one ramp oscillator per eight lookup tables) and
interface tricks makes this ensemble relatively light CPU usage: 21% on a 2.4 GHz P4,
versus 64% for an instrument that uses 64 tapes or regular sample modules. Mute the the
jambient Modulators and set jamPaneer to merge to stereo to bring down CPU usage.
VST automation IDs and names have been tweaked to make it easy to map automation
parameters in your host.

jamPaneer

jamPaneer is a mixing instrument that lets you place incoming mono signals in the stereo
image. It incorporates an algorithm to simulate distance from listener, see B view to
fiddle with parameters.

The top row specifies position of the listener relative to the position of the 8 incoming
signals. The rows below that specify stereo position of each signal.

Each position can be 'thrown' (see below) so that they move back and forth within a range
at a speed corresponding to the speed of throw, with a movement pattern set by the slider
at the far left of the position control.

Try the snapshots to see what you can do with it.

jamPaneer Switching

The Switching dropdown in jamPaneer lets you modify routing between the 8 mono
inputs and the 8 mono outputs of the instrument.

If you want to use all 8 outputs and process them outside the ensemble, say in a VST host,
select 8 in to 8 out; if you want to merge inputs to a stereo out, without panning, select
Merge to Stereo. These options save CPU since jamPaneer is disabled. Paneer to Stereo
lets you mix to stereo with pan modulation.

Do not change this Switch in mid performance, since it starts and stops modules,
producing unpredictable playback effects. Set this on a per-setup basis.
In technical detail:

Merge to Stereo: jamPaneer is disabled, and the 8 mono inputs are merged down to stereo
outputs L & R, with the same signal on each line. No output on lines 3-8.

Paneer to Stereo: jamPaneer is enabled, with the 8 mono inputs dynamically panned to
stereo outputs L & R.No output on lines 3-8.

8 in to 8 out: jamPaneer is disabled, and the 8 mono inputs are pass through to the outputs
L, R, and 3-8.

Throwing

In the jaModulator and jamPaneer, the XY control pads are set up to enable 'throwing.'
Basically, if you quickly drag the cursor between two points and 'let go' of the cursor, it
will start bouncing around in the rectangular region defined by the endpoints of the drag.
The speed of bouncing is proportional to the speed of your drag.

Dropdown menus beside pads let you turn off throwing, restrict it to the X or Y axis, or
enable it for both X and Y axes. You can also modify the type of travel: straightline
Bouncing, sinusoidal Curving, or random Drifting.

If you want throwing to stop, 'grab' the cursor and hold it in place for a length of time, or
click on the little red light that goes when the cursor is travelling. This length of time is
specified by the Sns (sensitivity) setting in B view. If you want to increase the range of
different speeds you can throw at, increase Sns; if you want to able to stop throws in
shorter period of time, decrease Sns.

Note that the settings for throws are stored and recalled in snapshots, but are not
otherwise permanent across saves.

The V setting in the B view controls the speed of the cursor for a given speed of throw.
To decrease speed, increase V.

jaModulators

The purpose of jaModulators is to let you set up complicated dynamic modulating

patterns using a small number of settings. Instead of specifying all the detail of a pattern
step by step, with one throw of a cursor, you can set up a slowly changing frequency
pattern that varies and evolves over the playback of a jamLoop. How does this work?
Let's take a look at the jaModulator and see how it works with the Slp function.

The third dropdown menu from the top is where you pick the function for the
jaModulator: Nrm (normal), Lvl (level), Slp (slope), Sin (sine), Tri (triangle). (The top
two dropdown menus beside the parameter pad control 'throwing' of the cursor in the
parameter pad, see above.)

Select the Slp function, then click or drag in the parameter pad as your sample is playing.
Watch the yellow dot in the background of the parameter pad--it scans across at a
frequency set by the scan knob.

The slope of the line is set by the X position of the cursor in the parameter pad, the
intercept by the Y position of the cursor. When the cursor is centred left-right, the slope is
flat; to the left of center, the slope is negative, to the right positive. So, using the
parameter pad, you can make playback speed speed up over the course of playback, or
slow down, more or less drastically. Moving the cursor around during playback gives
nice scratch-like effects.

Now for the interesting bit: throw the cursor in the parameter pad. Depending on the
speed of throw, type of travel, the region in which the cursor is moving, etc., you will get
very different, evolving modulating effects. Try throwing so that the cursor just travels
left-right, or up-down (or use the X, Y, XY dropdown to restrict throwing to an axis).

This illustrates the basic principle of the jaModulator: dynamically setting parameters for
a function. Now for some more adjustments, and then the functions other than slope.

Adjusting output: The control to the right of the parameter pad lets you set a randomness
factor. After the random factor is added, the output of the jaModulator (which ranges
from 0 to 1) is scaled (multiply by a range, with an added offset). The output is then
damped and smoothed. You can set the factors for this in the B view. Playing with the
damping and smoothness settings can let you make the output more or less jumpy, etc. In
the case of the F jaModulator, playing with damping and smoothness is like playing with
the weight and damping of a turntable.

Speed of scanning: Adjust this with the scan knob.

Other functions:

The Lvl function is a special case of the Slp function--the slope is always level, and the
only parameter that matters is Y. The output varies with the height of the cursor, so
basically the jaModulator works like a knob. Throwing the the cursor in the Y axis will
make the output vary over time.

The Sin function computes a sine wave. The X value in the parameter pad sets the
amplitude of the wave, with positions to the left of centre giving a negative amplitude, to
the right giving a positive amplitude. The Y value sets the baseline, so you can move
your sine wave higher or lower. The control below the parameter pad lets you set the
number of cycles in the wave. Adjust to half a cycle to get a pattern that curves frequency
up and then back down.

The Tri function computes a triangle wave. Settings are as for the Sin function. Use this
with a half cycle to ramp frequency up and then down.
Nrm is a special function designed to let you quickly go back to normal when things get
too wacky. It always outputs the value 0.5. With the default scaling this yields a value of
0, i.e., no change to playback speed. Usually, you would choose the Nrm function by
clicking the Nrm button below the function dropdown. This selects the Nrm function and
stops throwing. After clicking the Nrm button, when you click in the parameter pad, the
function reverts to the type that you last selected (other than Nrm). (On startup clicking in
the parameter pad reverts to Slp.)

jambientTerrainoSoar

The basic idea behind this is to use a terrain--a 2d image representation of elevations--to
drive a modulator. Watch the little dot in the terrain window as it soars over the
landscape, like a record needle reading the landscape. The height of the landscape
determines the output of the needle. Select different snapshots to select different ways of
reading the landscape.

To use the TerrainoSoar modulator, first load one of the accompanying ntf table files (see
below for how to make your own). Then decide on how you want the terrain scanned: as a
Spiral on a Cylinder, Lawnmower Style, or an Archimedian Spiral. Set the speed of
scanning, Feedback if you want. In B view you can choose whether you want to read
elevation directly, or detect peaks, and you can set parameters for Spiralling. You can also
use Base Speed to control basic speed of playback. Also, for Lawnmower patterns, etc.,
you can reverse X and Y or flip X or Y, to change the orientation of the scanning.

Use jambient ImageTxtToTable in the NI Reaktor User library to generate NTF files from
images.

The ntf files:

ontario.ntf is the elevation of a portion of ontario near where I live. The source bmps
were produced using Virtual Terrain Project's ability to export bmps of elevations, using
data from the Canadian government. Elevation was scaled up, exported to a bmp,
equalized in Photoshop.

spheres.ntf was drawn in Photoshop using radiant gradiant fills, and sphereramp ntf was
adds linear fills.

If you find other ways of producing smooth gradient surfaces, please let me know.