Creating Deterministic Melodies Using the Polygrid Sign Mode

Tutorial | Feb 01, 2021

In this video, I demonstrated how to create deterministic melodies with the sign mode in the Polygrid. It starts with setting up a face input to get a steady signal. I then used a sign mode to transform the signal, followed by an oscillator and amplifier to produce sound. I also used a pitch scalar, pitch quantizer and sample and hold to create a pitch signal that is within an audible range. I then used a clock quantizer to synchronize the signal to the transport, and a trigger module to create a static pulse. Finally, I showed how to use random modulators to create evolving patterns and an average module to even out the signal.

You can watch the Video on Youtube - support me on Patreon

Questions & Answers #

Maybe you dont watch the video, here are some important takeaways:

What is the purpose of using the sign mode in the polygrid? #

The sign mode in the polygrid is used to create deterministic melodies by transforming the input face signal into a more complex and repeatable signal. It is also used to modify and change the signal to create a pitch range, which can then be used as a trigger signal for a synthesizer.

How do you make the signal synchronized to the transport bpm? #

To make the signal synchronized to the transport bpm, you can use a clock quantizer to quantize the signal. This will ensure that the signal is in sync with the transport bpm. You can also use a trigger module to output a static pulse synchronized to the transport.

What is the benefit of using two sign modes? #

The benefit of using two sign modes is that it allows you to change the pitch and the gate signals at the same time. This makes it easier to create a more complex melody line and also makes it possible to have an evolving sound.

Transcription #

This is what im talking about in this video. The text is transcribed by AI, so it might not be perfect. If you find any mistakes, please let me know.
You can also click on the timestamps to jump to the right part of the video, which should be helpful.

[00:00.000] Hey guys, welcome back to another tutorial for Bitvic Studio.
[00:04.000] Today it's about creating deterministic melodies with the sign mode in the polygrid.
[00:11.200] And this technique, or kind of technique, was invented by the Pope actually on the Bitvic
[00:15.640] Discord.
[00:16.640] So I want to give him full credit for this.
[00:19.800] And I saw I'm posting this, I don't know, a month ago, and I was trying it out in the
[00:24.880] recent stream, some of you actually saw me using this technique.
[00:30.320] And yeah, I was trying it out and it's actually super helpful.
[00:35.400] It works pretty well.
[00:36.960] And I want to show you in this video how it works step by step.
[00:41.160] So let's start.
[00:43.160] At first we need a face input.
[00:47.040] And the face input gives us a steady signal from the transport.
[00:52.400] And I use an oscilloscope here so you can see the signal.
[00:59.920] But it's just a ramp, right?
[01:02.280] I showed you this in some of my earlier tutorials.
[01:06.960] And we just try to transform the signal so we can use it for our purpose.
[01:15.880] So what we need is a sign mode and the sign mode transforms the face signal, as you can
[01:22.760] see here, instead of this ramp, we now get this pretty complex complicated signal here.
[01:29.320] And we can modify this signal for our liking, right?
[01:36.120] And the best part about this signal is that it's repeating.
[01:40.320] You get a repeatable add-on, it's also deterministic because every time you set up the right numbers
[01:51.560] or the same numbers, for instance, here 1.14 and here we have 135%.
[02:00.160] And you input the same signal, you get always the same outcome.
[02:06.280] So you know exactly what you get when you dial in the numbers and this is called more
[02:11.520] or less deterministic.
[02:15.240] What we need now is of course something that produces sound, so we need an oscillator
[02:21.800] and we need an amp and a lobe and we need an output.
[02:30.600] And when you use this combination of modules, you have of course a pre-code activated for
[02:39.680] the pitch.
[02:40.680] We can use the MIDI keyboard, but you don't want to use that now, so I disabled this.
[02:46.240] And we also don't want to use the gate input pre-code here.
[02:49.800] So we want to trigger this by ourselves with the signal coming out of the sign mode, right?
[02:55.520] So what we can do basically is just hook this up here to the pitch input and maybe also
[03:01.360] just trigger this here, which creates some kind of weird noises.
[03:11.320] And that's maybe okay, that's maybe exactly what you want, but in our case we want to create
[03:17.760] more kind of a melody.
[03:21.080] So we need to transform this signal more, maybe just delete this line here.
[03:26.400] And we need to bring this into a pitch range.
[03:31.360] And this you can do by a scalar, pitch scalar.
[03:37.160] And you can change in which range you want to create notes or pitch signals.
[03:42.160] In this case it's between C3 and C4, maybe go down to C2 here.
[03:48.080] Right now we just trigger this again.
[03:56.840] So it's more like in an audible range, right?
[04:00.560] And we can of course narrow this more down to a scale with the pitch quantizer.
[04:11.240] We choose some kind of notes here we want to have in our pitch signal, so this is D sharp
[04:18.240] minor.
[04:26.480] The problem now is that we have some kind of clites between the notes because the pitch
[04:30.000] signal is not, you know, you have some transitions here from different notes.
[04:34.760] So we need to use a sample and hold before here we go into the pitch input check.
[04:44.320] And we need to trigger this here with our trigger signal.
[04:48.040] And now we get some kind of stepped input and see here this is how basically the pitch
[04:54.200] signal looks like now.
[04:56.840] This was the pitch signal before.
[05:00.440] See all kinds of clites and transitioning here.
[05:06.000] And this red one here is basically after this, so we can change at the signal a bit.
[05:15.120] So the problem now is basically that because we use the sign mode output here also as a
[05:24.120] trigger signal, we only trigger the AD when we have high notes or high pitch notes.
[05:32.440] It's the same signal, right?
[05:34.200] So when you can see when we look here at the signal, so every time we are basically at the
[05:40.080] top, you generate high pitch notes, we also trigger the AD.
[05:44.320] So we only let basically high, high notes through the AD.
[05:51.120] So we need to change the signal for the triggers a bit differently or treated a bit differently,
[05:57.880] or maybe even use a different input as a signal.
[06:02.440] So maybe we use the gates module as an input for the AD and we use this for the pitch.
[06:14.400] Something like this.
[06:31.760] So this is a possibility.
[06:34.200] You can also maybe change the signal even more, so maybe we have this our first sign mode
[06:41.560] signal and then we use the second sign mode here, go with the sign mode output here in
[06:46.400] this one and generate the second signal, right?
[06:50.240] That's even more complex than the first one.
[06:56.960] And then we use this as a trigger and delete the gates module.
[07:19.960] So the benefit of this is when you change the first sign mode, you also change basically
[07:24.840] the second one, so you change the pitch and the gate signals at the same time, maybe change
[07:37.880] here a bit.
[07:50.120] So now the problem is the trigger signal is completely off the grid, it's not synchronized
[07:54.320] with our 110 bpm bit grid, right?
[07:57.640] So what we can do now is we can use a clock quantizer, clock quantize here and we basically
[08:07.280] quantize our signal.
[08:09.840] So we go into this here and then we use this output as a trigger for the sample hold and
[08:17.400] the AD.
[08:19.040] And all we need to do now is we need a static bit quantized or transport synchronized signal.
[08:26.760] We can use trigger module, this one here, basically outputs a static pulse synchronized to the
[08:36.640] transport and we use your 16th notes, 16th notes bit grid, go into here and now we can
[08:46.520] use this as a trigger signal and it's completely synchronized now to our 110 bpm.
[09:15.040] So now maybe use a second oscillate oscillate oscillate oscillate oscillate oscillate here.
[09:25.200] So basically the first signal here is our signal log generated by the first sign mode and
[09:31.720] we're using this for the notes.
[09:34.160] And the second signal here is basically the first sign mode signal changed with the second
[09:41.480] sign mode signal and it's much more complex and we use this to trigger the AD here.
[09:49.920] And we also synchronized this to a 16th notes grid based on our transport bpm setting.
[10:04.200] So this is your basically the outcome of this and see this is our trigger signal.
[10:11.680] So we have created the trigger signal and a pitch signal from the face input signal just
[10:20.640] by changing and modifying signals and using the signal, these signals basically to change
[10:27.720] pitch and gate for our synthesizer.
[10:32.400] And like I said in the beginning, this is completely deterministic.
[10:36.800] So when we remember here the settings, this is 115%, 1.12 and every time we come back
[10:46.920] to these settings we have the same melody line.
[11:10.520] So same numbers, same outcome, it's deterministic.
[11:15.800] Yeah, this is basically the simple setup you can think of of a nice generative patch
[11:23.040] because it's not evolving, right?
[11:25.640] If you want to have some evolving things into this, you probably want to modulate here
[11:31.440] the settings of the first sign mode and maybe the second sign mode.
[11:35.440] And because everything is synced here to a bitgrid and also pitch quantized, you never get
[11:44.160] out of the scale and you never lose basically rhythm or you basically not off-grid basically
[11:51.840] with the rhythm.
[11:52.840] That's what I want to say.
[11:54.520] So you can change this basically pretty easily here with some random modulators if you
[12:00.880] want.
[12:30.440] So now you basically have two random modulators modulating the sign mode setting one and
[12:37.760] setting two here, it's the amount and the rate basically.
[12:42.960] So you kind of create multiple different combinations of these two values.
[12:49.240] So you have kind of an evolving thing going on.
[12:53.680] Also we change the second sign mode which controls the trigger signal.
[12:59.640] So you have different combination of melodies, add rhythms that change over time.
[13:05.480] So it's kind of generative.
[13:08.080] At some point you probably run into repeating patterns but you know it's still interesting
[13:16.120] to use.
[13:31.960] Also interesting is we have the signal here by the first sign signal and so yeah you can
[13:39.440] see it's pretty drastic in the changes sometimes.
[13:43.400] It's the steep value changes here over time.
[13:47.040] So what we can do is we can try to even this out with an average module.
[13:56.160] And you see transitions from more like rounded and smoothed out on the edges.
[14:06.200] What we lose is basically the signal arrangement.
[14:09.040] As you can see some of the signals doesn't go up to the one line here or back to the
[14:15.560] zero line and if you increase the average thing here it becomes flatter and flatter.
[14:24.880] What you can use this also here is an input for a pitch scalar and change the melody over
[14:32.600] time a bit.
[14:33.760] So you have another value that you can modulate and change over time to create more interesting
[14:41.080] or different patterns.
[14:47.360] So what you can do now is if you raise the average you basically stay on one node longer
[14:57.480] until you at the highest point you're basically just generate just only one node.
[15:04.240] And if you pull this back to zero you generate a big range of dynamic values.
[15:16.360] So you can decrease or increase the dynamic of your signal for the nodes.
[15:40.560] So yeah that's it for this video basically I want to give you some kind of rough inspiration
[15:45.760] for using the sign node as a pitch input or as a gate input signal.
[15:51.960] And you can do a lot more with these signals you can of course add all the phase modifiers
[15:57.880] after the sign node or before the sign node to shape the signal even more or you can use
[16:02.960] delays to offset these signals if you use for trigger signals and the pitch signals the
[16:08.680] same phase signal as an origin you can offset these both signals to delay the trigger signal
[16:15.920] from the pitch signal.
[16:18.040] And so on there's a lot of stuff you can do you can of course use feedback loops if
[16:22.400] you want or sample some of the stuff with the recorder and play it back in different
[16:28.200] settings or different timings you know there's a lot of things you can do.
[16:34.400] So I wanted to keep it a bit simple for this tutorial to show you the general setup of
[16:39.200] this and yeah want to inspire you to try it out for yourself.
[16:44.240] So thanks for watching please leave a thumbs up if you liked the video subscribe to the
[16:48.800] channel and maybe think about the subscription or unpatrion or here on YouTube.
[16:52.880] That's me a lot thanks for watching and I'll see you in the next video bye.