WEBVTT

00:00.000 --> 00:05.000
[Automatic captions by Autotekst using OpenAI Whisper V3. May contain recognition errors.]

00:08.089 --> 00:17.841
Okay, so the first thing we're going to do is just go to gibber.cc and 
you'll get the landing page and you'll just need to go to the playground

00:17.881 --> 00:27.832
here. My background's white, you can change it here. Yours should be 
some sort of default black. I'm just gonna start off by writing down a

00:27.892 --> 00:39.962
command Bible here to make sure that everyone knows how to use this. So 
yeah, like Stefano said, this is all JavaScript, but the only special

00:39.982 --> 00:51.831
things you need to know are Control and enter. It's going to run the 
current line of code that you're on at the start of the next measure. As

00:51.851 --> 01:00.198
you can see here, Gibber always has this metronome counting here. so 
that everything stays synchronized ideally, the visuals and the audio

01:00.258 --> 01:19.274
as well. You can also do Alt and Enter will run the current block of code. 
Control and period, that's going to stop running all the audio.

01:23.110 --> 01:30.236
And for debugging purposes, of course, that's important. I'll show you 
visually, and then I'll just write it down so you don't forget.

01:30.956 --> 01:43.326
Right-click, go to Inspect, and go to Console here. And then you can see 
any errors that you get. So if you just type gibberish and try to run it,

01:43.866 --> 02:03.334
you're going to get an error trace and say that this is not defined. So 
I'll let this go for now. right click into inspect into console is debug

02:06.195 --> 02:19.819
okay so now we can begin coding I guess so let's start by making our first 
object just have it be pretty basic synth inside the parentheses you can

02:20.039 --> 02:29.227
put single quotes and it'll give you all the different possibilities of 
synths that they have in here let's do let's do square bass to begin with

02:29.487 --> 02:39.796
choose whichever one you want and let's just start off by playing a basic 
note so this would be all considered one block here so you're gonna press

02:40.276 --> 02:47.068
alt and enter And then that was kind of quiet. But here, let me do 
something that's not a bass.

02:50.492 --> 02:55.758
Let's do a bleep. Yeah. So you have your first note.

02:58.849 --> 03:09.383
So the zero here represents the zero with note on the scale. I believe 
it's an A minor. Is that? Yeah. Yeah. The default scale is an A minor. If

03:09.423 --> 03:17.617
you go to the reference page, there's a theory. If you want to get really 
into it, we won't go into it too much right now. but you can get very

03:17.657 --> 03:24.880
granular with the notes you're playing. I know people on previous 
workshops have wondered if you can play microtonally. I believe you can

03:24.940 --> 03:38.204
here, you can do 0.5. You can do note F and specify the frequency of the 
note you wanna play as well. 49 for instance. But yeah, so now we want to

03:38.324 --> 03:50.844
actually sequence this. Let's keep that note F, let's keep 49. or let's 
go 440 and let's do a sequence just a basic one so the sequence is going to

03:50.864 --> 03:59.805
take two arguments the first one is the note it's going to play so let's 
have it just be actually yeah let's just do sequence.note

04:01.026 --> 04:11.776
s.note.sequence so it's going to play one and it's going to play that 
every fourth note so if you play that you should get steady rhythmic

04:11.816 --> 04:15.717
fourth note change that to an eighth note

04:19.259 --> 04:37.144
16th note then drop the bass just a few uh things if you want to change up 
the bpm clocked up bpm so here you can hear just the beep here And I'm going

04:37.164 --> 04:41.926
to change it. I believe it starts at 120 or 140. So let's slow it down to 80.

04:52.569 --> 05:01.958
And as always, it starts when you do the Alt-Enter once it gets to the 
beginning of the measure here. You can also, if you really want to, you

05:01.998 --> 05:09.184
can do shift and enter to play a note immediately, but then things start 
getting unsynced, so just be careful about that. I use Jupyter

05:09.224 --> 05:15.049
Notebook, and that's kind of second nature to me, and that leads to some 
pretty weird synchronization issues, so just be very careful with

05:15.069 --> 05:24.794
that. Okay, so like I said, you can do control and period to stop 
everything. You can also, if it's easier for your brain, you can just do

05:25.854 --> 05:37.257
s.clear for whatever, if you want to control each individual instance 
that you want to stop. So yeah, so let's create a slightly more

05:37.897 --> 05:47.502
complicated sequence here. So as I said, the two arguments are the notes 
you're gonna play and the rhythm, but it also takes arrays. So let's just

05:47.522 --> 05:52.645
do a basic one, two, three, zero, one, two, three.

05:59.489 --> 06:04.229
And likewise, you can pass arrays in here as well. to give you different 
rhythms.

06:16.678 --> 06:23.402
And let's say you want to just create some randomness. So it's not the 
same thing over and over again. You're just going to go to the end of your

06:23.422 --> 06:36.279
array and write .rnd and put parentheses at the end of it. And then you'll 
be able to visually see here It chooses one of these at random every

06:36.299 --> 06:42.343
single time. We can do the same for our rhythms as well.

06:51.308 --> 06:55.771
So already you can get some pretty dynamic sounds out of this.

07:00.399 --> 07:14.023
And we can go a bit more into detail here. We can make an ADE SR envelope as 
well. So let's change the attack of this. Let's make it 1 4th

07:17.404 --> 07:26.646
and 1 8th. Make that random as well. And let's apply it. Yeah, let's just 
do it every fourth note.

07:31.175 --> 07:45.059
And likewise, you can do attack, decay, sustain, and release. We can 
also, if you don't want to write it all out like this, you can create maybe

07:46.019 --> 07:55.901
a rndi. Note the capital R here. And then this will turn a random integer 
number between 0 and 8. Do negative numbers.

07:58.599 --> 08:06.522
And then if you run it with control and enter, you should be able to see 
exactly which number it's producing here.

08:14.301 --> 08:29.512
so uh likewise if you want a more interesting way of uh picking a note for a 
synth let's keep the bleep synth and let's do s dot note dot seek and let's

08:29.552 --> 08:40.336
have it take in a sine wave So the sine function here is going to take in two 
arguments, period and amplitude. And you should be able to see it once we

08:41.077 --> 08:51.743
run this here. And let's have it sample the wave every eighth note. So run 
this. And then if you do Control-Enter here, you will be able to see your

08:51.783 --> 08:57.346
wave and which parts of the wave it's sampling, from 5 to negative 5.

09:09.199 --> 09:10.019
amplitude

09:12.480 --> 09:13.880
period make it run faster you

09:20.502 --> 09:33.306
can also as stefano mentioned before the gen uh if you're familiar with 
uh max msp you can use that as well gen cycle two times three

09:43.360 --> 09:54.342
Similar kind of thing to what we're doing. And let's make the rhythm a 
little more interesting, too. They offer a Euclidean distance

09:54.562 --> 10:06.024
function here. So it also takes in two arguments. Let's do six and eight. 
So for this, with an eighth note, it's going to return six evenly spaced

10:06.164 --> 10:17.022
beats. And you should be able to see that visually. There it is, yeah. So 
it's six of the most evenly spaced beats in a set of eight. If you do three,

10:17.042 --> 10:20.187
you'll see the same thing here. If

10:25.975 --> 10:36.640
you want to get really granular, you can also do hex, so for those that 
aren't familiar with hexadecimal code, it's gonna take in something

10:36.660 --> 10:50.804
that looks like this, 0.X0000, and each of these digits here, I guess, is 
gonna represent four values in binary, so for instance, one is gonna

10:50.824 --> 10:52.344
equal 0001, two is going to equal that

11:01.507 --> 11:18.471
If you do, let's see, yeah, 16, no, 15's all of them? 15's, yeah, all ones, 
which is F, yeah, yeah. It goes from A to F once you get past nine. So let's

11:18.491 --> 11:26.813
say you do something like eight, A, F, and two.

11:37.051 --> 11:48.042
you can also apparently i think it's hold shift and click on this or alt 
and yeah now hold alt and click on this and you should be able to edit the

11:48.082 --> 11:48.623
pattern live

11:54.017 --> 12:03.500
It's crashed my browser before. Just be very careful if you want to use 
this. Yeah, nothing will be saved if it crashes. So just use with caution

12:03.681 --> 12:13.525
and then you have to click alt and on the pattern again and then it should 
apply the pattern there. Okay,

12:13.945 --> 12:18.347
let's create a sequence like this.

12:23.424 --> 12:25.345
And play it every eighth note.

12:31.009 --> 12:39.694
If you would like to play around with the sequence without using the 
random functions and random number generators, you can also define

12:39.854 --> 12:51.882
this array as a variable. So let's just call it SA, whatever you want to 
name it. You can also call it a node array, maybe more descriptive.

12:54.537 --> 13:01.399
And there's a lot of things you can do to note array. One of them, for 
instance, you can transpose it.

13:05.120 --> 13:14.723
So I'm going to transpose the note array by one for every one measure that 
it goes through. And you should be able to, if you do the control enter,

13:14.843 --> 13:23.766
you should be able to see each number here go up by one. Oh, yeah, because I 
never defined this. That's right. Yeah, now you can see it move up by one

13:23.806 --> 13:24.166
every time.

13:28.726 --> 13:33.849
so this will just go into infinity so you need to reset it as well

13:41.292 --> 13:48.216
and so what this does is reset it back to normal every four measures and 
then back to normal

14:04.127 --> 14:15.014
Let's also change the cutoff on the synth as well. We can slowly fade it 
in. So let's go from 0 to 0.5 over the course of eight measures. And then

14:15.034 --> 14:16.034
you'll get a slow ramping in here.

14:34.810 --> 14:48.278
And yeah, let's start adding some effects as well. So we can add some 
reverb as well to this. We're going to call the space reverb here. Send it

14:48.298 --> 14:57.863
to a bus and also a delay. And yeah, like you said, note the capitals here 
as well with the functions for reverb and delay.

15:02.620 --> 15:12.049
And on the delay, you can actually see all the different kinds of delay 
you can choose between. I'll do eighth note delay. Send that to a bus as

15:12.089 --> 15:25.701
well. Then all you need to do, well, first you need to run this to make sure 
they're declared. Then you'll need to connect the synth to the effect

15:25.781 --> 15:28.704
buses. So we're going to connect the reverb.

15:32.515 --> 15:42.401
and then the amount of reverb I guess you want on it. Yeah. Yeah,

15:42.762 --> 15:49.666
so it keeps going for two measures. Gonna bring that back down.

16:05.606 --> 16:17.970
And let's also connect it away. Yeah, maybe. Yeah, let's do, yeah. I'm 
not getting enough feedback so much.

16:37.869 --> 16:53.738
One last thing I forgot to do with synths. You're also allowed to make a 
polysynth as well. Same kind of things here. I'll keep it at bleep. And

16:53.778 --> 17:13.644
with the polysynth, you can make multiple sequences. So I'll start off 
with random between... 1 and 3, random int, excuse me. 0 and 3, every

17:13.704 --> 17:14.304
fourth note.

17:21.626 --> 17:28.907
And then we can also keep on going. And let's do a random int between 7 and 
10.

17:34.184 --> 17:45.233
Every fourth note. You also need to add a third argument now. So this is 
going to be 0 and this is going to be 1. And now they can both play at the same

17:45.293 --> 17:57.362
time. And if you want to access all of their components separately, you 
just need to say s.note and then index whichever one you want to deal

17:57.402 --> 17:57.542
with.

18:12.268 --> 18:23.735
Sorry, one more thing on the synth, because I know a lot of you were coming 
from the title cycles workshop as well. If you want to, if you're more

18:23.795 --> 18:33.721
comfortable with it, you can always call s.note.title instead. I 
personally like it for a lot of reasons, namely because you don't need to

18:33.741 --> 18:43.605
keep writing commas here. So if you want, you can do exactly what we're 
doing in the title. Oh yeah, we need to declare a synth actually first

18:43.665 --> 18:43.865
though.

18:53.213 --> 19:00.820
So for whatever reason, you're more comfortable with using this. You 
can do that as well, but I'm just going to keep going in the Gibber syntax.

19:01.607 --> 19:14.333
I'm going to move on to drums and to triggering. So let's start off with 
just a basic kick instance. And it's going to work a very similar way to

19:14.353 --> 19:27.043
the synth, except instead of sequencing it, you are going to trigger it 
in a sequence. And it also takes two arguments, but this time it's the

19:27.083 --> 19:37.431
first argument is the the gain the amplitude of the kick and then Yeah, 
the same as before. It's just the rhythm. So this is just gonna do a kick

19:38.252 --> 19:43.916
Same volume every fourth note if you want to make it quieter Turn it down 
to 0.5 And

19:47.178 --> 19:48.940
then the same as before you can do

19:52.628 --> 19:53.568
An array of rhythms.

20:00.570 --> 20:01.530
Random float.

20:11.752 --> 20:16.333
And there's really a lot you can do here, so let's make this back into an 
array here.

20:24.105 --> 20:25.526
Oh, yeah, remember the comma here.

20:32.772 --> 20:50.405
Let's make this into a Euclidean rhythm. And like before, we can see the 
rhythm here. And let's give that a name. Let's go kick rhythm. rhythm

20:51.025 --> 21:00.531
let's do something let's do let's reverse it actually that's probably 
the word i was looking for here you can see every time i call this now it's

21:00.611 --> 21:09.277
doing the reverse of the pattern before so this one ends up in the last 
spot etc etc

21:13.439 --> 21:24.163
put it back to normal We can also, let's say, I'll keep this up so people 
can have it. Let's rotate the pattern.

21:27.045 --> 21:31.468
Let's rotate it by one eighth note to every one measure.

21:36.211 --> 21:40.374
Oh yeah, sorry, we have to do dot seek for that as well to sequence it.

21:44.937 --> 21:55.873
Now you can follow. ones moving along the way here and just like any 
sequence you can add arrays as well

22:05.933 --> 22:16.881
Close this off. A good indication that your code isn't running is if you 
press Control-Enter and it doesn't light up the text like that. You know

22:16.901 --> 22:19.864
you've done something wrong. And now it's good.

22:28.490 --> 22:45.181
And let's just fill out the rest of the drum kit here. So let's go snare. 
trigger sequence so if you want to do something like you want the snare to

22:45.221 --> 22:53.547
hit every offbeat you can always put an underscore as the first value of 
your array then do one

22:56.590 --> 22:58.271
for every fourth note

23:03.953 --> 23:13.363
as opposed to if you do this, then you have it hit on, well, yeah. All the 
notes, and then this would be one and three.

23:24.326 --> 23:31.915
You can also declare hi-hats, it's just called a hat here. Also worth 
noting, if you put single quotes in any of these, you can choose between

23:31.955 --> 23:37.040
different kinds of snares, hats, kicks, whatever you want. I

23:41.585 --> 23:43.387
don't like the sound of that, I'm gonna keep that normal.

24:11.681 --> 24:21.627
We're gonna get started with part two here and it's all gonna be about 
visuals and audio visuals specifically connecting all the things that

24:21.647 --> 24:32.192
we've been doing all the sounds and creating visuals with that so first 
things first this is very processing intensive especially on the the

24:32.212 --> 24:46.697
browser here so just to prevent any potential disasters we're going to 
set the graphics quality to low and keep it there for the duration of

24:46.737 --> 24:55.144
this. If the browser crashes, you're gonna lose all your code, like I 
said, and we don't want any bad things to happen there. So let's just

24:55.164 --> 25:12.723
start off by rendering a box. So we have the capital B, the box function, 
and then render is also the function. There's our box. If we want a better

25:13.063 --> 25:30.249
look at the box, we can rotate it, say 45 degrees, and then along x, y, and z 
axes, calling 111. We can change these numbers up as well.

25:35.069 --> 25:47.923
Get different views of the box. And similarly, you can call sphere, you 
can call cone, small cone, but we're going to keep it on a box right now.

25:55.248 --> 26:07.597
so let's say we want to change the size of it in a sequence we can do exactly 
what we're doing in jibrew before with the synths size dot seek and then

26:07.657 --> 26:15.102
we can choose different sizes of the box so change it every eighth note

26:23.089 --> 26:33.495
And we can apply all of our fancy functions like we did before. But let's 
do something a little different. Let's do some animation. So we have a

26:35.176 --> 26:51.502
built-in onFrame function. It has one variable, time. And the onFrame 
function will run once for every single animation frame. So if you want

26:51.522 --> 26:55.283
to do something like b.translate,

26:55.704 --> 27:04.748
I'm actually just gonna shut this down. All audio visuals have the same 
command. So if you press control period, it'll also shut down the box. So

27:04.888 --> 27:20.624
we do b.translate and let's do a sine wave, let's say. Over the course of 
time, And this is going to be the x-axis that it's going to be translating

27:20.724 --> 27:29.905
on. And let's do a cosine for the y-axis. So render the box.

27:32.906 --> 27:43.888
Oh no, there it goes. Okay. Yeah. So now our box, I guess when you expand it 
becomes a rectangle like that. Let's speed it up a little bit.

28:01.951 --> 28:04.712
And we can also animate the rotation as well.

28:08.293 --> 28:21.298
Let's also do that as a sine wave. times pretty high number and then same 
thing along one one one like we had up here

28:27.203 --> 28:33.829
and now our box is bouncing and rotating let's make the rotation a bit 
let's do 360.

28:44.117 --> 28:56.226
If you want to make it a bit more complicated, Gibber also has a pretty 
dense library of fractals. So for instance, this one called Julia.

28:56.246 --> 29:06.113
Let's stop this real quick. Let's make a J for Julia and render this.

29:10.658 --> 29:20.042
I guess it's a little hard to see with the low quality. I think I change it 
to high just for right now. You can see it's quite detailed here.

29:20.482 --> 29:24.264
Actually,

29:24.304 --> 29:25.765
let's just scale it up a little bit.

29:29.727 --> 29:40.629
So when you scale and then put the number in there, it can increase the 
size of whatever graphic you're working with. And yeah, so we can also

29:41.449 --> 29:46.390
change up the number of folds here. Yeah,

29:46.430 --> 29:51.851
there we go. You have to make it equal to two. Three, four.

29:54.351 --> 29:59.490
Everything looks a little different. Like before, you can... Sequence 
it

30:02.412 --> 30:06.955
to display a bunch of different kind of visuals. I can already feel it 
lagging a little bit, so I'm going to change this back to low.

30:10.138 --> 30:12.439
And change this up every eighth note.

30:22.887 --> 30:37.532
OK. So now that we have some kind of command over these shapes, let's... 
I'm just going to delete this. Excuse me. Let's synchronize it to our

30:37.652 --> 30:42.474
audio. So let's actually start from the beginning. Let's make sphere.

30:48.217 --> 30:48.637
Render that.

30:51.648 --> 30:53.869
And let's make a kick object.

30:56.790 --> 31:02.952
And then all in the same line, I'm just going to trigger it so that it runs 
once every fourth note.

31:07.153 --> 31:12.755
And then pretty simply, I'm just setting the sphere.radius equal to 
kick.

31:16.596 --> 31:23.739
As you can see, it's pretty far away here, so we just need to make a little 
offset. Sphere.radius.offset.

31:23.779 --> 31:33.223
I'm going to make that equal to 1 to get it a little closer to us. Do 2, you 
can get even closer. 10

31:36.004 --> 31:38.585
doesn't work. Keep it at 2.

31:44.781 --> 31:53.087
And then if you want it to be a bit more extreme of a pulsing motion, you can 
do sphere.radius.multiplier.

31:55.468 --> 32:04.795
Make that equal to whatever number you think looks the best. Anyway, 
there's a few other graphics you can render as well. So for instance, we

32:04.835 --> 32:06.156
can render a plane.

32:11.221 --> 32:23.109
Again, with higher graphics quality, you'll be able to see it kind of 
stretch into infinity here. We can give the plane texture. So before we

32:23.270 --> 32:27.873
render it, let's give it dot texture, dots.

32:32.076 --> 32:37.740
And then, yeah, let's make it audio reactive. So I'm going to make an FM 
synth.

32:42.927 --> 32:54.791
gong here. Not gong gong, just gong. Another thing is that you can 
declare audio effects directly in here if you want. So you can have a

32:54.811 --> 32:58.632
decay of six or something like that.

33:01.593 --> 33:07.215
So we have our FM synth and now we're just going to sequence it.

33:16.355 --> 33:18.676
So it's gonna play once every four measures.

33:21.617 --> 33:32.503
And now we're just going to map this plane's texture, which is the dots, 
the radius of each dot.

33:35.764 --> 33:36.525
Map the gong.

33:40.643 --> 33:44.870
from three to zero. Oh, I'm sorry, yeah, yeah, yeah, I'm sorry, yeah, 
thank you.

33:51.921 --> 33:54.265
So now our dots are reactive to our gong.

34:11.977 --> 34:22.885
I'm just going to refresh this real quick so we get back to our normal 
chipper theme here. But we're going to be using P5 to generate some

34:23.386 --> 34:37.337
visuals now. Just as easy as this, use P5. And then we can go ahead and use 
everything in their library. So we can set the background. So if you pass

34:37.397 --> 34:51.468
it one... One argument, it's a grayscale. If you pass it three, it's RBG. 
And

34:51.488 --> 34:59.614
you can also draw shapes. So for instance, rectangle, it's going to take 
four arguments for the four different points that the corners are.

35:02.336 --> 35:11.996
So when you pass width in here, that's the width of the canvas. 
automatically returns that, so let's do width divided by two, height

35:13.116 --> 35:15.997
divided by two, and then 100

35:17.697 --> 35:24.338
and 100, and it'll draw us a nice little square here. If we change this,

35:27.659 --> 35:39.390
well, you need to run the background first, actually, because... We're 
just rendering one frame at a time. But yeah, so if you want to actually

35:39.710 --> 35:43.531
draw with this, so there's a draw function for p5.js.

35:46.931 --> 35:56.313
And we're going to set the background to this color for every single 
frame. This is like the on frame function that we had before. It runs

35:56.373 --> 36:07.170
every single frame. And yeah, let's give our rectangle a fill color. 
Let's just make it bright red stand out against the green background,

36:07.190 --> 36:10.973
and then draw our rectangle.

36:15.015 --> 36:23.461
So this is the same as before, except it's actually running for every 
single frame. And if we want to animate it, let's just make a variable

36:23.501 --> 36:27.184
called x up here. And

36:28.004 --> 36:40.648
yeah, let's make it x plus equals five. So now we have our rectangle 
moving slowly off screen. And then we just need to add a little line down

36:40.708 --> 36:50.132
here. If it becomes greater than the width of the canvas, then we need to 
set X back to zero.

36:55.235 --> 37:05.632
We're just gonna go straight into the audio visual aspect of this. So 
yeah. Let's make kick like normal.

37:08.293 --> 37:11.214
Trigger it every fourth note.

37:15.654 --> 37:19.075
And let's go back to our draw function.

37:21.816 --> 37:26.697
And for the red value of the background, let's replace that with 
kick.out.

37:29.387 --> 37:38.391
And that's going to return a pretty small number. So you're going to need 
to pass an argument here, which is a multiplier. It's going to kick that

37:38.431 --> 37:43.314
out, return its value between 0 and 1. So this is going to return a value 
between 0 and 127.

37:46.955 --> 37:52.278
Maybe it's better if we just do grayscale for this. Yeah, that's 
actually a bit less subtle there.

37:56.832 --> 38:04.335
If you don't want it to start from black and start from more of a gray, this 
127 right here is going to be a bit of an offset.

38:11.718 --> 38:15.680
And yeah, let's make an FM synth.

38:46.234 --> 39:03.867
Right. So let's change our rectangle. Let's not make it move as much. 
Let's make it expand with the base. So let's make a constant here called

39:03.987 --> 39:15.928
B. we're going to do base dot out and multiply that by a thousand and 
instead of having the width and the height having a move like that we're

39:15.948 --> 39:21.769
just going to have b times minus 0.5

39:24.250 --> 39:28.551
b times minus 0.5

39:30.972 --> 39:32.632
and then these values will be b

39:37.551 --> 39:46.876
We should also probably translate the canvas as well so we can get our 
square over here. So we're going to translate it so that width divided by

39:47.256 --> 39:51.718
2 and height divided by 2, that becomes our 0 and 0, essentially.

39:55.237 --> 40:04.585
so now you can more easily see the uh the square reacting to the base and uh 
yeah we should probably smooth it out a little bit as well so we're gonna

40:04.605 --> 40:19.014
have a smoothing con constant rather uh just windowing function 
basically so we're going to add that to our fm dot out this zero we don't

40:19.054 --> 40:27.302
want any offset so it's just going to be zero and then we're going to add 
our smoothing constant we can also just add it directly into here as well

40:33.787 --> 40:45.315
looks much better So I refreshed my browser because between Hydra and p5 
there might be some namespace conflicts. So we're going to start off by

40:45.335 --> 40:54.063
just using Hydra like we did before with the p5 except to initialize it we 
have to type .then then

40:55.825 --> 41:03.492
init and then the pointy arrow and then init with parentheses at the end.

41:06.658 --> 41:18.584
And if you get the highlighting, then everything should be fine here. 
And then to get visuals, it's just as easy as doing OSC parentheses dot

41:18.704 --> 41:37.012
out. And then you get a little Hydra oscillator here. Very fun to play 
with so here you can Change some values of it. So the there's three things

41:37.032 --> 41:45.514
you can change the the frequency which I like to think it was like the 
density I guess of the lines here. So if you have a higher number you have

41:45.554 --> 41:46.174
more lines

41:49.315 --> 42:00.149
Keep it at 20 here and then the the sink value is which I like to think of as 
like the speed of how fast the lines are moving. Higher the value, the

42:00.169 --> 42:11.715
faster it is. I'm gonna keep it at one. And then our RGB offset. Give it a 
little bit of color here.

42:20.459 --> 42:22.120
Same line of code, you can rotate it.

42:28.300 --> 42:29.921
You can pixelate it.

42:38.348 --> 42:46.574
Plenty of fun things you can do with Hydra. But just to relate it to us, 
let's just make it audio reactive.

42:49.356 --> 42:53.860
Same as before, we'll make a kick. Trigger it.

42:56.622 --> 42:57.843
Every fourth note.

43:01.502 --> 43:05.345
And let's do OSC k.out.

43:07.366 --> 43:11.409
I'm going to multiply it by 500, 0.1,

43:16.832 --> 43:17.112
10.out.

43:22.936 --> 43:31.960
So already we're getting some pretty crazy visuals here. Let's make 
another FM synth like before. I probably should have kept this. That's

43:32.040 --> 43:32.380
on me.

43:47.910 --> 43:50.172
And then we can take the same OSC line here.

43:59.238 --> 44:13.926
And we can modulate it based on the FM synth. We're going to use a noise 
function. F dot out. Multiply it by 50. Dot out. Missing one

44:13.986 --> 44:22.010
parenthesis. Sorry. FM. Forgot that. There we go. And now we're getting 
some modulations.

44:48.596 --> 44:48.947
Thank you.

