Lookup Data Tables - Bitwig Grid Module Guide

[00:00:00] Inside of the grid of Bitwig Studio,
[00:00:02] we have the lookup tables.
[00:00:04] They look like this here.
[00:00:05] They have different shapes, pulse shapes,
[00:00:07] saw shape, sign shape, triangle shapes.
[00:00:11] And inside of Bitwig,
[00:00:13] there are inside of the data category.
[00:00:16] So when you switch it to data, at the end,
[00:00:20] you can find these kind of modules.
[00:00:22] Also some other modules here,
[00:00:24] and they're not really defined as lookup tables,
[00:00:26] but they kind of work in the same way.
[00:00:28] And I show you this in a minute.
[00:00:30] You can also search for lookup here in the search bar.
[00:00:34] And you get here the array and the lookup tables
[00:00:36] and also your steps and transfer graph.
[00:00:39] So like I said, they're kind of working
[00:00:41] all in the same kind of manner,
[00:00:43] but there are some differences there.
[00:00:45] So first up, we look into these modules here
[00:00:48] and what they actually do
[00:00:50] because they look like there are oscillators.
[00:00:53] And if you use here, for instance, sign oscillator,
[00:00:58] you can see we have here the same graphical image
[00:01:01] inside of the sign oscillator.
[00:01:03] And yeah, it's basically that these modules
[00:01:08] are just a part of the bigger oscillator.
[00:01:11] Here we have some additional features.
[00:01:14] Of course, we can detune it.
[00:01:15] We have also your internal face signal
[00:01:19] that is generated with the pre-code.
[00:01:21] So when we change basically a MIDI note on the keyboard
[00:01:25] or in the piano roll, we change the face.
[00:01:28] And then the face goes into the lookup table
[00:01:31] and then it plays back basically what's inside of this table.
[00:01:34] And then we get here a different shape out of it,
[00:01:37] which then ends up being a sound.
[00:01:39] So the lookup tables are basically just a part of other modules.
[00:01:44] For instance, the oscillators here and the oscillator modules.
[00:01:50] Okay, so how does this work now?
[00:01:52] We can see how this works by just using an oscilloscope here
[00:01:56] and we are hooking this up here to another signal.
[00:02:00] For instance, a face signal.
[00:02:06] And this face signal looks like this.
[00:02:08] It's a ramp signal.
[00:02:09] It's going up from zero to one.
[00:02:12] And I think I made already a video
[00:02:15] about the face signal, how this works.
[00:02:17] It's inside of the grid, it works like a positioning signal.
[00:02:21] You can use the signal then to recall certain informations
[00:02:24] or position things or synchronizing things and so on.
[00:02:28] So it's like a signal that you can use in multiple ways.
[00:02:33] And you can see at the sign,
[00:02:35] lookup table also has an input, a purple input.
[00:02:38] So it hints at the possibility
[00:02:40] that it's probably something you can use here.
[00:02:43] So we hook up here this phasor signal.
[00:02:47] By the way, this phasor signal generates a face signal,
[00:02:50] which is a ramp signal exactly in the frequency
[00:02:54] of the current pitch of the grid.
[00:02:58] So when you change the pitch of the grid,
[00:03:00] which you can influence by using a piano roll
[00:03:03] or the MIDI keyboard,
[00:03:05] you change basically the size or the width of this ramp signal.
[00:03:10] And then you also influence, of course,
[00:03:12] the pitch of the sign, lookup table output.
[00:03:16] So here you can see the face signal is a ramp signal
[00:03:19] going up from zero to one and it's just a value going up.
[00:03:23] So it's a value starting at zero
[00:03:26] and then it goes up until you hit one
[00:03:28] and then it goes back to zero.
[00:03:30] So it's just a value going up all the way periodically.
[00:03:35] And we maybe can see this here also on the readout.
[00:03:38] It's just this, you can see it's just a value going up
[00:03:44] over time and you can also switch it
[00:03:47] or oscilloscope too fast.
[00:03:49] You can see it's just happening over and over.
[00:03:51] So having this on pitch, you can see just a window of it.
[00:03:55] Okay, so the signal is going up from zero to one
[00:03:59] and then we go into the lookup table.
[00:04:01] And then what happens inside of the lookup table
[00:04:04] is that we map the value to a certain different value.
[00:04:09] So inside of the lookup table,
[00:04:10] there's this sign, shape or cycle here
[00:04:14] and it starts in the beginning with zero.
[00:04:16] So we recall from this lookup table,
[00:04:20] what's at the position zero
[00:04:21] and this is the red line here, right?
[00:04:23] So at position zero, we have output zero.
[00:04:26] At position, I don't know, zero dot four,
[00:04:31] we have maybe this position.
[00:04:34] So we get the red position here, right?
[00:04:36] So we send in a signal and we get out a different value
[00:04:40] based on this lookup table.
[00:04:42] And it's really like a table.
[00:04:45] You can imagine this like a table,
[00:04:47] excellent table, right?
[00:04:48] And you have on the bottom end,
[00:04:50] you have all the index or all the numbers.
[00:04:53] You start at zero and then you go up to,
[00:04:55] I don't know what the resolution is up until 127.
[00:05:00] And at each position,
[00:05:01] you recall something from this sign shape here, right?
[00:05:05] Some value from the sign shape.
[00:05:08] And then if you do this multiple times per second,
[00:05:11] then we get an audio rate modulation
[00:05:14] on this sign lookup table and we get a sound out of it.
[00:05:18] So this is basically the idea behind these lookup tables.
[00:05:22] And if you use your different lookup table,
[00:05:26] of course, you get a different shape out of it.
[00:05:29] This lookup table here even has a slider on it.
[00:05:33] So you can influence what's going on.
[00:05:36] It's a waveform sharpness, that's how they call it.
[00:05:39] So we can influence how the output is
[00:05:42] of this sort lookup table.
[00:05:45] Okay, then we have here the triangle one.
[00:05:48] Also same idea, right?
[00:05:51] Different data inside of the table.
[00:05:54] So we get a different audio output.
[00:05:57] So the idea behind of these is here
[00:05:59] that if you need something like a triangle shape
[00:06:02] or saw shape, sign shape,
[00:06:03] and you don't need all the other features
[00:06:06] of the oscillator, if you want to influence
[00:06:09] some of the parameters of the oscillator,
[00:06:12] then you can just use these lookup tables
[00:06:16] and you can build your own oscillator
[00:06:18] with different features or a different setup maybe.
[00:06:22] That's the idea behind it.
[00:06:24] I also want to show you this here
[00:06:26] with a second oscilloscope.
[00:06:29] Maybe put this here a bit lower.
[00:06:33] And then we take a value slider, something like this,
[00:06:38] and maybe we use a readout and another readout here.
[00:06:43] So when we send in a value,
[00:06:49] let's say 10, 10% here,
[00:06:55] it's going up from zero to 100%.
[00:06:58] So we can see this here on the readout.
[00:07:03] So maybe go to 25, let's go to 25%.
[00:07:06] So this is a value of 0.250.
[00:07:10] This is the values we are sending in.
[00:07:13] And then we receive an output value of one.
[00:07:16] So this is the highest point of the sign shape here.
[00:07:20] So we are probably here, maybe go to 20%.
[00:07:24] So sending in 0.2, we get out 0.951.
[00:07:32] So it's really just sending in a value
[00:07:34] and then getting back a value at this position
[00:07:37] inside of the table.
[00:07:39] That's all it is.
[00:07:40] It's just a table and we query certain values
[00:07:45] from this table at a certain position at this table.
[00:07:49] So sending in a value, getting out a different value.
[00:07:52] If you do this very fast,
[00:07:54] you get the sign shape out of it.
[00:07:55] So we can use here also a modulator here, modulators,
[00:08:01] and then modulators value.
[00:08:03] And you can see we get the sign shape out of it, right?
[00:08:07] It's just a table and we query this table with the value
[00:08:10] and we get a different value out of it.
[00:08:12] You can even call this a mappings.
[00:08:14] We map one value to another value.
[00:08:17] And that's also why we have here certain other modules
[00:08:21] like the array, for instance.
[00:08:23] The array works exactly like the lookup tables,
[00:08:26] but here we can write our own values
[00:08:29] at our own positions, right?
[00:08:31] So we can send in, maybe we can do this here.
[00:08:36] It's actually not a video about the array,
[00:08:40] but I can show you this here.
[00:08:42] So we send in a value, 50,
[00:08:45] and to use another value, let's say 10,
[00:08:50] and then we send this here at the input
[00:08:55] and we say write face, write this value at this position,
[00:09:00] and then we need to trigger,
[00:09:01] and we can write this value into the array.
[00:09:08] You can see we have here now this output.
[00:09:10] So every time we go to this position here,
[00:09:14] we get this value out because at this position in time
[00:09:21] or in this table, we have this kind of value.
[00:09:24] The only difference between the array
[00:09:27] and these lookup tables is that here you can write
[00:09:30] your own data into the lookup table,
[00:09:32] and here you have predefined data,
[00:09:34] which is just a sine shape or a triangle shape,
[00:09:37] saw shape, pulse shape, and so on.
[00:09:39] So this is the whole idea behind it.
[00:09:41] It's just really a table,
[00:09:42] and that's why it's called a lookup table.
[00:09:46] Also here, when we go for a lookup,
[00:09:49] you can see we have here a step axis or step.
[00:09:51] It's basically the same thing, right?
[00:09:54] We have here data at certain positions.
[00:09:56] We switch this off, use a value slider,
[00:10:01] and then we go to a certain position inside of this table,
[00:10:05] and then we have this value here,
[00:10:07] and then we get this value out at this position, right?
[00:10:12] Also, it kind of works in the same way.
[00:10:15] So this is just to show you to give you an idea
[00:10:19] how this kind of works.
[00:10:22] I hope I made it clear how it works.
[00:10:25] So these are, we have only here a few of these,
[00:10:31] triangle, and then we have, what's the another one?
[00:10:35] The sine one, yeah, these four lookup tables.
[00:10:41] Oh yeah, we have also one thing it's called window.
[00:10:46] This looks kind of the same as the sine here.
[00:10:50] It's just one part of the sine.
[00:10:52] It's the top part, so it's called window,
[00:10:55] because you can use this to make some window functions,
[00:10:59] which means, let's say you have,
[00:11:02] you can also make an example.
[00:11:05] We have a phaser, and we drive here the saw with this,
[00:11:10] and we have an oscilloscope, something like this,
[00:11:16] and you want to apply some kind of windowing function,
[00:11:21] and you want to have, in each of these cycles,
[00:11:25] happening something to the volume, for instance.
[00:11:27] So we can use a multiply, which is just changing the volume,
[00:11:33] and we drive this with the same phase signal,
[00:11:36] and then we apply this here to the saw,
[00:11:40] and yeah, you can see we have now kind of a rounded saw.
[00:11:44] It's like a smoothed out saw,
[00:11:47] because we apply here a certain window
[00:11:51] to the saw, which looks like this.
[00:11:55] Maybe you give this a different color here.
[00:11:57] We give this green.
[00:11:58] So yeah, we change basically the volume, right?
[00:12:02] We're going with the volume, or we have no volume here,
[00:12:05] then we bring in the volume there,
[00:12:06] and then we can shape the volume of the saw output here
[00:12:11] exactly when something happens inside of the lookup table.
[00:12:16] So the window function is sometimes really nice
[00:12:18] if you want to shape partials or audio rate signals,
[00:12:23] or anything else.
[00:12:25] If you want to smoothly fade in and out sounds,
[00:12:29] that's usually how I use this here
[00:12:32] in some of my grid patches.
[00:12:35] We can also here use this to fade this in and out,
[00:12:37] so we can say, oh, actually, when I have,
[00:12:40] let's say, a constant of one, this is the full volume, right?
[00:12:43] If I put this in here,
[00:12:46] the saw is completely fine, but when I use the window,
[00:12:50] it looks like this.
[00:12:51] And then we can say, we want to fade between the two,
[00:12:56] so I use a blend, use the window function,
[00:13:01] use the constant, and then I use the constant here
[00:13:03] to bring this in, and then we can smoothly fade
[00:13:07] between the saw and the window function,
[00:13:11] and we have a different shape.
[00:13:12] So we are already wave shaping more or less here, this thing.
[00:13:17] We can also do something like moving this around.
[00:13:21] So if you think, oh, I don't want to have here
[00:13:24] a different value, you can use a shift,
[00:13:28] and then we shift this window function around, right?
[00:13:33] There's a different effect on the waveform.
[00:13:38] So the window function here
[00:13:43] influence basically the volume over time,
[00:13:45] and because this is the same face signal,
[00:13:49] we do this basically exactly in the same cycle.
[00:13:53] So it's wave shaping more or less,
[00:13:56] or you influence how the saw is played back
[00:14:00] because we influence the volume.
[00:14:02] It gives you different sounds or different ideas.
[00:14:05] You can also use the window function, of course,
[00:14:07] not with audio rate, you can also use this over two bars
[00:14:10] or three bars in length to shape,
[00:14:15] I don't know, the arrangement or the loudness of things.
[00:14:17] So you don't need to use this with audio rate signals here.
[00:14:20] You can use this at any position in time, right?
[00:14:23] Or any time speed, I don't know how to call it.
[00:14:28] But yeah, very useful in a lot of ways.
[00:14:35] In a lot of different areas in the grid.
[00:14:40] So the best is that you know that this exists,
[00:14:43] and if you need something like this,
[00:14:45] then you use it or misuse it for your use case.