Transcripts
1. Introduction: Hey everyone, welcome to And
Max for Live part three. Controlling Live
with Max for Live. In this class, we're
going to focus everything we've learned so far in the first two parts
on Max for Live. Now with Max for Live,
we have three goals. First thing we're going
to learn how to do is to ask live what
it's doing, okay? We're going to pull
information in from live. And then we'll be able to do all kinds of insane things with it. Like what is the tempo,
what bead are we on, What our effects doing, What is our automation,
What are our Midi notes? All of those things.
We'll be able to generate our own plug ins based on
what Live is currently doing. Second thing we're
going to be able to do is tell Live what to do. We're going to be able to
say, set this fader to here, set the pan position to this, create these notes,
launch these clips. That's part two. And the third thing we're
going to learn to do in this class is take audio and Midi directly
from live on a track, and process it in some way. And then send it back
through that track, basically acting just like
any other kind of effect or I'm going to give you a bunch of files
to work with in this class. In the end, we're
going to make some of my favorite little patches. Including one that I use on almost every project
I've released in the last five or six years. If you're not familiar
with what Max is, Max is a programming language designed for audio and video. It's a very different kind
of programming language. You're not going to
be writing codes, You're going to be
moving little boxes around and connecting things almost like a giant bunch of little guitar effects pedals. I've been using Max for
embarrassingly long time, and I've been teaching it in my university classes for
probably about ten years. The curriculum I've
developed has helped thousands of people learn how to use Max even though it is. Yes. Quite a complicated thing. But I promise you if you
go step by step with me, you'll understand how it
works, how to think like Max. And most importantly, my
own personal little motto. You will learn how
to learn math. This class, like
all of my classes, is endorsed by the International Association of Online Music
Educators and Institutions, which holds it to the
highest possible standards for online education
and classes. With that, let's dive
in start learning how to build audio
and video plug ins. And Max. And max for live. Here we go, Updates. There it goes, really
slick and nice. Okay, so this is our get information from live mini patch or
snippet. Let's save it. Right now we're not hearing
that because this plug in isn't sending the signal back to plug out. Right?
If we look down here. Okay. Next I've set up a little set here that
just has a bunch of clips. You could do this with
clips or audio clips. What I'm going to
basically do is tell it to pick a random and a random clip and launch it with all that
we have already. This is actually pretty simple and I bet you can figure this out on your own net. This last one, I think this
is my legit secret weapon. I think way at the
beginning I said that a lot of people use Max to make their little secret weapons
that they keep close. I made this a long time ago and started experimenting
with this idea. And then, um, I've been
using this all the time. It's a subtle effect,
it's kind of wacky.
2. Recap of Parts 1 and 2: Okay. It is impossible to
summarize everything that we've done in parts one and part two to get into this class, let me just tell you that if
you're just diving in here, if you haven't taken
part one and part two, you're just going
into part three. I would highly encourage
you to go back to at least part
two and part one, we really focused on finding Max patches that we can
take apart and play with, how we become part
of the community, the community of users and
makers of Max patches. Then in part two, we
really got down in the weeds and learned
how to program Max. Now we didn't learn everything. One can't learn everything. One thing I said in that
class way too many times, and I will probably say in
this class way too many times, is that the way to
learn Max is you have to learn how to learn Max. That is the secret to using Max. If you really want to be able to program your own plug ins, synthesizers, and
effects in Max for live, you really need to understand
the Max language we say, which is really just these boxes connected to other
things like you can see around me here. Please go back to part
two and start there. Part one would be even better, but at least part
two because I'm going to assume that
you've watched part two as I start building projects in this
class, part three, Cool. Now that we're on the same page, let's move on and talk about
our set up issues here.
3. Setting up M4L: Okay, since they,
meaning Ableton. Since the Max for Live, there has been a few different iterations of how it's worked. Because Max is its own program. Live is its own program. There's a version of
that runs within Live, but that may or may not be the full version
that runs outside of live. It's a little confusing. I have noticed that even I think might be playing
with how this works. This might be different
by the time you watch it. But let me show you how best to figure
out what's going on. I'm going to go to
my Settings in Live. I'm going to go to files and folders and go to
Max Application. And then look here, it says I can use the bundle
version or I can browse. If I browse, I'm going to
pull up my copy of Max. What I can see here is
I have two options. I can browse and find
my full version of Max's just called Max, there it is. Okay. So now I'm using
Applications Max app. I'm using my full
version of Ma and it is going to run
inside Ableton. But if I wanted to use the bundled version
which is different, I would click on this
use bundled version. Okay. And then it's here, it's just going to I'll do it. Say I need to restart
for that to work. But it says you're using
the bundled version of Max. There are two different
versions right now. As far as I can tell.
The two versions are essentially the same. Very little different
between the two versions. It doesn't really matter if you bought suite and you
have the bundle version, that's great use that, you don't need to buy Max. But if you want to use
Max outside of Ableton, then you might want to buy
a separate license to it. Like what I have. Maybe just to keep
things simple, I'm going to use the
bundled version of Max since that's probably
what most of you are using. Okay, I'm going to leave this on the bundled version and I'll
use that for this class. I'm going to restart. Then if I go to something like, let's just make a max for live something, you see it here. I'm going to hit this button
to actually open the editor. This is where Max is launching. It takes a second the
first time you do it. Okay, now I'm in the
bundled version of Max. It looks exactly the same.
4. Differences in M4L and Max: Okay. I did just say that the bundled version
of Max for live and the full standalone
version of Max don't have much
that are different. There are some things that are
different between the two. I actually just found a list. Let's take a quick look at it. This is on Cycling 74 website. They're saying you can do all
these things, direct audio, driver access, doing things like rewire and
multi channel audio, you cannot do in Max for live. That's not something
you're going to really need or want to do, especially multi
channel audio in Max. If you're handling
audio in live, doing multi channel
audio stuff is cool. But you can still do
that in live, right? Your inability to do it in Max here is not really that big of a deal because you
can still do it in live. Unlimited Midi
hardware messages, looks like they're
restricting some things about Midi hardware messages. Author and edit. En and MC is multi
channel patches. En is like another package that lets you do some
really advanced stuff. We won't really get
into En in this class, but it is super powerful. I would highly
recommend you check out Gen after you get
comfortable using Max. But you won't be able to make
En patches in Max for live. However you can use them. Export code from Gen
can output raw code. But we don't really
have access to Gen, this unlimited operation. I'm not really sure
what that means. I don't, I don't know, I don't know what they
mean by that here. But these are pretty
niche things. All the code, everything
we've learned so far, that's all the same. They're similar, right? It's really just gen in
the multi channel stuff. You're pretty much good with
the built in version of Max. The only real reason to buy the standalone version
of Max is if you want to build some tools outside of Ableton like some
standalone applications.
5. Our Three Main Goals: Okay, so when it comes
to using Max for Live, there's really three things that we need to be
able to do, right? Everything that we can do
with Max for Live comes down to these three things, okay? The first is getting
information from live. Okay? We can ask live,
what are you doing? What is the state of this fader? What is the state of the tempo? What is the transport doing? What is this effect doing? We can get information from
live with that information. We can do all kinds
of fun stuff. But that's the first
thing, learning how to ask Live for information. The second thing is
how to control live. Right? So we can say, set that volume to 50. Set that pan position to
this, launch this clip. Mute this track
solo, that track. Rename this track. Right,
Like that's controlling live. Okay, that's the second
thing, controlling live. Then the third thing is
processing audio from live. Be able to take the sound
that's on a particular track, route it through our max device, and then send it back
to that track, right? Be able to process that
audio within max for live. Those are the three things
that we need to learn how to do that makes it sound
so simple, right? The way I've organized this
class is we're going to start with six objects, we're going to focus
on six objects. These objects are really
designed to be used together. At least four of them
are funky objects, like they're tricky to really
wrap your head around, but these are going to be
the objects that we're going to learn that are going to help us do those
three main things. Okay, what we're going
to do is we're going to build the tools to
do those things. Like we're going to
build a little patch that goes and asks for
information from live. Then we're going to
save that as a snippet. We looked at snippets
in the first class. We're going to build those together so that you have them. You have a little arsenal of tools that you can use
to go get information, send back information
to control live and to get audio for processing. Then we're going
to go through how to use those little snippets in all kinds of different ways. How to ask for
different information, process different information, and do a whole bunch of stuff. And then at the end,
we're going to make a whole bunch of really
cool projects, trust me. All right, let's dive in.
6. The Three Types of M4L Patches: Okay, I think I
mentioned this already, but I just want to drill
down a little bit more on the three different
types of Max for live projects or Max
for live patches, just to make sure that
that's really clear. If we go here to our
Max for live stuff, the browser of live, we have three different things. Max audio effect, max
instrument, and max Midi effect. Now here's the most
important thing to know. No matter which of
these you start building with the code, and everything is
the same, okay? You can use all the same code. If I open audio effect, I have here a blank
audio effect. That's the one I'm
going to use to start building my own stuff. Then I also have a whole
bunch of other projects, things that people have made. That's cool, but if I
want a blank slate, I'm going to open
Max audio Effect. Now in Max audio Effect
I'm going to get this. It's going to have
plug in and plug out, that means I can get the audio signal from
live effectively. This audio signal, what shows up here is going to go
straight into this plug in. And this plug out is going to
go straight to here. Okay. I can build whatever I want
right there and do all kind of cool stuff, okay? When I open and max instrument, I need to put it
on a Midi track. It's going to say
Midi from live. All the Midi data
from right here. Anything going
into this track is going to go straight
into my project. The max instrument
is by default, set up to give you Midi
output audio, right? This Midi information is
going to go straight to Midi. In then at some point
in your project, you're going to generate sound. That's what an instrument
does, it makes sound. You're going to the
sound that you make into this plug out and it's going to go straight out of your track. Then the third one is
a max midi effect. With that one, we've
got Midi coming in mid, straight from there. Any Midi going into that track is going to
go right in there. Mi going to send it
right back out to live. So we're going to put an instrument out
here or something. Those are the three
types of things, but remember everything that you build within them is the same. This is just like
the starting point, right for the effect. Okay, I just wanted to make
sure that was super clear. Must go.
7. Launching MaxForLive: Okay, before we get
into these objects, let's just real quick, make sure that we're
all on the same page. When it comes to
actually launching Max for Live and the
Max for Live editor, there might be a
faster way to do it, but here's how I
always launch it. Click on Max for Live over here. Now you've got your three
different things here. I always just go
to the first one, then you've got
all these devices. Your list might be
different here, but I always just grab this first one here,
Max audio effect. This is just going to
be a blank effect. Throw it onto a, throw
it onto an audio track. Okay, now we get this. Okay, really simple
little patch. We'll explain what this is doing later if you can't
figure it out. But what we really
want to do to open our whole editor is hit
this button right here. Okay, Now the first time you hit that in a day, Max has to. It can take just a minute. You can see it spinning to
show you that it's doing it. Okay, now Max is launched. I have a ton of windows open. Let me close all of these. Okay, this is the only
thing we really need here. It launched that patch and
now I've got my editor. First thing I always do, make this window nice and big. Okay, so that's
how we launch Max. Now while we're
here, I will point out this little vertical
line because this might be something you notice that's different than standalone Max. This line doesn't really do anything when it
comes to programming. We can go under it, we can
put stuff wherever we want. But what it's doing is it's telling us that this
amount of space above this line is
what we're going to be able to see in live down here. Okay? This is what we're going to be able
to show on the screen. Anything under that line is
going to be like down here. We're not going to
be able to see it. You can program all you want. But when you build
your presentation mode and you want things
to look really nice, you want to move everything above that line
that you want to see. We'll deal with that later. But that's what
that line is doing, and that's why it says
device vertical limit. And this is just a
comment. You can delete that if you want. It doesn't matter. Okay, so now that we know how to
launch Max for live, let's go through these
six key objects.
8. Live.observer: Okay, our next object is
going to be live observer. Okay, now let's look
at the help file for this one monitor, changes in live objects. Live observer is
used to listen to changes in the values of
properties in the live object. Object works in conjunction
with a live path object which sends ID numbered messages into the right
in let of live observer. Cool, here's what that means. Live observer is going
to report the value of whatever we tell it
when that value changes. Which is great. That's
when we need to know it. The way we're going to
tell it what to look for is with the
live path object. Cool. Now, in order to do this we need to add one
other little thing in here. We need an object
called trigger. This is a weird object, it's always been really
confusing to me. But basically with
trigger trigger, basically you send it
something and then it outputs it a bunch
of different ways. The first thing to know about
trigger is that we can use the word trigger or
we can actually just use A okay, means trigger. Now, anything I give it after, it is going to tell it how I want it to format its outputs. Okay, I'm going to say B, L, L, here's what that means. What I've said is that
this is a trigger object. Out your first
outlet, send a bang. Out your second
outlet, send a list. And out your third outlet,
send another list. Okay? We're going to need all
three of those eventually, but we don't quite
need them all yet. We need the first two. Okay. I'm going to go, I'm
going to take the ID from live path and put it
into the trigger object. Then I'm going to send a bang. Oops, no, not skip.
One more thing. I need a message in here
that we're going to bang, that's going to be
property value. This message we're going to
bang from the trigger object. Send that into live observer. This is just like
you always need to send this to live observers. Strange, but that's
the way it goes. Then the list we're
going to send to the right in let
of live observer. Okay, now here's the cool thing. This much of it is we're basically going to save as a snippet once
we're done with it, like if the trigger
thing is confusing, you don't worry about it.
We're going to save it. And it's going to work because
this is always the same. This part of it is
always the same. This part you're going to
change every now and then. Let's look at the result. I'm going to look at the
volume of track one. I need a floating
point number for this, because the volume is
going to be 0-1 okay? And that's what I need now. I should be able to see my
volume whenever it's changed. Let's lock it. Let's make sure this path got sent to live path. As soon as I clicked it, you
can see it update there. But let's do this and this now. When I move my volume
of that first track, I see it live. I've successfully gotten
that value from live. Now I've opened a
huge door, right? Because as long as I can figure out how to format this path, I can basically get
anything with this set up. Let's, let's just change
the last word to panning. Okay, everything
else is the same. Live set, track zero,
mixer, device panning. Okay, let's send that to the live path object
by clicking on it. Now, if I change my
panning position, I can see it in live, right? I can get access to
basically anything that I want as long as I know how to figure out
the path to get there. And it doesn't even
need to be The track on this patch that we've
built is on track one. Or as max for live
thinks of it track zero. But what if I wanted
to get the volume of this track right? I could do that.
I got to type in, I got to change
my path live set. What, what do we
want to call that? Track? If you said
three, you're right. Track three, right?
Because this is T zero. This is track 12.3.
Tracks three. I don't know why there's an
on tracks, but whatever. Okay, now I resent
to this message. Every time you
change this message, you have to resend
it to live path, not captured track three. Oh, I'm still on
panning. There we go. I just got to get the panning. Okay. If I want to
get the volume, I got to change this
back to volume. All right. We send it again. And now here's my volume. All right. Live path and
live observer working together to report
information from live. All right, let's go
on to the next one.
9. Live.object: Okay, up next is live object, let's look at the
help file for that. Perform operations
on live objects. Now we're getting into the
realm of controlling live. Let's add to this crazy thing that we have here because
that is how it's best used. Watch this, I'm going
to take live object, Let's see what it
wants inside of it. It says get set, call, get ID, bang, get info, get type, or get path, basically wants the
path in there and the ID in there, okay. So if I put this at the bottom
of this little path here, I need one little message. I just need to say set value $1 dollar sign one, okay? Set. Now this is an interesting
little message. I don't think we've
seen these yet. But what this means is that
when you see dollar sign one, it means I'm going to
send you in something. And you can do this
with a message. This is a weird
way that a message can actually process
things a little bit. I'm going to put
in a number here. It's going to basically replace this dollar sign one
with that number. If I put in a two here, it's going to output
set value two. Okay? And then I can
change that all I want. What I'm going to do,
let's put this into it, then take that out and
into the live object. Now I'm also going to
swing back up here and get this list and put that in there. That's going to help us get the path that we need
out of it, right? Because this list is the path that we're getting for the
volume of track three. In this case, we're sending that path down to this
live object also. Okay, that's it, check it out. Now I've made a double
situation here. These objects are built this
way to be able to do this, let's put this over here
and then this over here. Let's make sure we still
have that message in there. Okay, Now I can move the slider and I see it
showing up in my patch. So I can get it, but
I can also move it here and get it
into patch, right. I can control it from
within the max patch. I can send a number here and
through the live object, it's going to send it there. I can control it in
either place now. Okay, now doing it this way
does have a slight problem. It's giving us some errors. Let's tighty it up
just a little bit. I'm going to get rid
of this number box. I'm going to drop
this down a little bit because I think we're
getting a feedback loop here. In order to prevent that, I'm going to put
this slider in here. And then the set one in and set value out.
That'll make it. So now I can control things because of the way the inputs and outputs are here. It prevents a feedback
loop from happening. Now I can go both
ways, just fine. I've got a nice UI to
boot, okay, Live object.
10. Live.remote~: Okay, the last one of
these tricky objects and then we have two more, but they're really easy,
don't worry about it. This next one is a
little bit different. This is live remote, this is Tilda remote. Tilda. What does that tell you? You know that if it's got a Tilda that it's
working at audio rate, it's sending or receiving audio. It has something to do
with an audio signal. Now, this is not the
object that we want to get the audio signal that's going into live and then
do stuff with it. This has nothing to do
with a live audio signal. What this has to do
with is controlling live with audio rate objects, which is a fancy way
to say LFO's okay. If you want to put an LFO on, something you're going to want
is something that cycles. What better object then cycle. Cycle makes a sine wave, we can give it a
value, let's give it a value of 0.5 Okay? That's super low, and that's
going to be a great LFO. Now I can run that
into live remote, then the only thing I
need is our live path. I'm going to grab our
live path from right here and put that into live
remote on the right side. That's it. Now we're going to control whatever our path is set to up here with this LFO, okay? I'm going to click this
again to get it going. Then it doesn't work right away. Okay, this is another case where we might need to save it before it
starts operating. Let's say save a few times. Now I'm going to send
it the message again. There we go. Now
it's working okay. We can see it's got that
LFO just cruising on it. You could do this without
live remote just with this, but you'd have to do
some funky stuff to get a number to go up and down and up and
down and up and down. This is just a lot easier if you want to do things like this where you're creating
LFO's all over the place. Live remote is a smoother way
to do it than live object. It's relaxing to watch,
actually. Weird. Okay, now let's go
on to the easy ones.
11. Plugin~ and Plugout~: All right, our last two are just going to be the two we need to get a signal from live
and send it back out. Okay, so those are what
are our defaults up here? Plug in and plug out. Let me actually just go back to a default audio effect here. Okay, let's start,
let's get rid of that one for the moment, Okay, When we start audio
effect anyway, we have this from live plug
in audio to live plug out. Okay, so this is our signal. It's going to go
right through there. Let's prove it. Sure. Let's put that on this track
and just get it going. Okay, Our signal is happening. We can see it here.
Let's interrupt it. If I disconnect these, our signal now is stopping
here. It's not doing anything. It's telling us to build your effect in
between these two things. And of course we're
going to do that. This stuff is all just comments. So we can delete
it, but if we want our signal back, we
can put it there. All right, if we want
to do something to it like what ight we do maybe we want to do
some crazy filtering. I think we use
this object in the last but so we could do something to it and
then send it back to live. There it is, right? So cool, right? Getting it in and out is easy as long as what we want in and out
is on the same track. Now, this is going to basically
interrupt this down here. If we want to get audio
from a different track, that's actually quite
difficult to do. I think you can do
it with a send and receive like you saw us do in the other class
doing sends and receives, but that isn't typically
what we want to do. Plug in Tilda just gets the signal from live,
plug out Tilda, sends it back to live on the same track for any audio effect that
you're going to build. These two are
probably going to be at the top and the
bottom of your patch. And then you're going to
do something interesting in between. Pretty simple.
12. Abstractions: Okay, those are six key objects that'll get us talking back and forth to live
really quite easily. Live path, live observer, live object, live remote, plug in and plug out. But there are a whole
bunch of more objects. In order to explain them, I want to talk about this
concept of an abstraction. Now there's a trick we
can do in Max where we might a patch that does a thing, a utility thing, something that we need to do all the time. We could save it as a snippet. That is something
we could do, but there's something
else we could do. We could save it
as its own object. This is a weird idea, but the snippets thing
is relatively new. Before snippets, this is
what we did all the time. You might make
something that you do all the time and then you
save it as an object. And then you can
recall that chunk of max code just by making that object the object
that you named it, right? For example, I could make
an inlet here and say, I don't know that goes
into the whatever. I could make an outlet. Let's just leave
it with one inlet. There's one inlet
here and no outlets. I could save this as its own patch as long as
it's in the right place. As long as I save it
in the right place, then I could name
it like J thing. Right. After I did that, I could just open up
any object and write j thing and hit return and it
would make my object right. And then I could double
click on it to open it. It's turning orange dish here
because that doesn't exist. The reason I'm telling you about abstractions is that there are a bunch for live
already built in. Let's go up to our
menu bar here. Go to Extras, then you should have this Max for Live
API abstractions. Okay, let's open that. If you don't have this, I think this comes built
into Max for live now. But if you don't have
it, search around the Internet for
exactly this and you can install this,
but it should be there. This is giving us a whole bunch of abstractions that we can do. For example, if we
want to launch a clip, let's click on that. Okay, this is what just
opened up over here. What it is is L
fire selected clip. Okay. We could do that and
it's going to launch a clip. I could double click
on this to open it, and we can see the guts of it, how it works, but we
don't really need to. But this will make sense. There's a live path,
there's live object, there's more abstractions in it. If I click on it, there's
more stuff you could make. All of these on your own, but I just want you to
know that these are here. All of these are
really handy things. Select parameter of a
device, select the device, um, save live path, get points, observe
transport, toggle transport. There's tons of fun stuff here. Know about this that
you can grab it and you can use any of these if you
want to use a muse type min, like watch this
fire selected clip. Okay, let's look at that. If I go to Ymax patch and
I make an object called pre selected clip, there it is. And then I can use it and
it just takes a bang, so I just put a bang
on it and it'll work. You can load these
up anytime you want. So keep an eye on that list of abstractions file that's
in your version of, it's got a lot of really cool
time saving things in it. Okay, Let's build some stuff using these things that
we know how to do now.
13. Building the Snippet: Okay, let's get into a whole
bunch of things we can do by getting information from
live or listening to live. So the first thing I want us
to do is build a snippet. I'm going to start from scratch, I'm going to go to Max for
live, max audio effect. I'm going to throw it on a track and I'm going to
open up the editor. I'm going to make
it big. I don't even care about this right now, not even going to use
it. I'll leave it there. Okay, This snippet is a lot like what we already
built itactly the same thing. But let's walk through it again just to make sure we understand it. And then we're
going to save it. Okay, first thing we need
is that message box. And the message is going
to look something like Path Live set tracks
zero or whatever. Mops mix device. And then the parameter volume. Okay, now we're going to
save this as a snippet, but every time we pull it
out, we might be changing this to get a different thing. We'll see the next thing
we need is live path, because it needs to
handle that path. Okay, let's make this a
little bit bigger, okay? All right, now we
need that funky trigger object, Funky trigger. That's funny for
me to say because my mother's maiden name is
funky, it's a funky trigger. Anyway, we're going to go at the middle outlet of live path. If you're wondering
why it's only because what we really need is the ID of the path which I'm not
exactly sure what that is, but this is, it works. Okay. So we've got
trigger bang list list. In fact we really only
need one list here. Let's just do that to
keep things simple. All right, now let's go to a property value because we are asking for the
value of the property. And the property being the
thing we're pointed to here. All right, now we're going to go live observer and we're going to give that
property value. And we're also going
to give it this list. Okay? Then we can do a few
things here to see it. And I'm going to set up a few ways that we're going to see it. Let's do set one for that value, then let's do that slider. We can see it. We'll also throw a flu in here. I'm just trying to
think of how best to look at the data
that's coming in. Okay, so this is two
different ways of looking at that data
that's coming in. All right, let's test it. I click on that, I can
already tell it worked because it got the current
value and jumped right to it. But let's change that value
and make sure it updates. There it goes, really
slick and nice. Okay, this is our
get information from live mini
patch for snippet. Let's save it. I'm going to unlock
it. I'm going to select everything in
this little thing, then control click on it. I say save snippet. Okay, down here it's
asking for a name. Let's say listen to live
return sweet snippet saved. Now if I go over to my snippets, which is here, there it is. Listen to Live. If
I want to use this, I can just click and drag
it and drop it right here. Boom, there it is. And I can change it, I
can play around with it, I can do whatever I want. Okay, cool. Let's do some fun
stuff with this.
14. "Property Value": Okay, hi everyone. This is me from the future. I got done filming this class and then I jumped
backwards because I don't think I've explained very well this
property value bit. Let's talk about that
for just a minute. If we go to live observer, there's a weird little max trick you can do that we
haven't looked at yet. Which is you can delicately hover your mouse over
the left side here, you can get this little greenish lime colored play button. It looks like if
you click on that, you can see all things that this particular
object receive can do. You can change, it's
like the inspector. It gives you a link to
open the inspector, but you can change
the way it looks. But most importantly for now, you can look at the
messages that it can take. We can give it a bang. We can, we can say get ID, which will tell us the ID, which we already know because
we're giving it the ID for the thing we're looking for from the live path object. We can ask it to get property, which I think would
probably list for us the available
properties that we have. We can say get type,
which will tell us what type of thing
we're looking at. We can tell it an ID, which we're doing in the right
inlet where it says ID in, we're giving it the ID already. And then property
variable we can say what we're saying
here is property value. Like what is the value of
the property that we're looking at right later? We're going to have
to change this, we're going to ask live
observer something else. But you can think of
this as a question like what is the value of the property that
we're looking at? The property that we're looking at is at the moment volume. Okay? That's why we
keep sending this. Every time we update
this live path, we're going to shoot out
property value saying like, what is the value
of that property? This is just a question
we keep asking, and then it keeps giving us the answer and setting it here. Hopefully, that explains
it a little better. It's a confusing idea. This whole little segment here is hard to wrap your head around sometimes,
but hopefully that helps. Okay, back to regularly
scheduled programming.
15. The Live Object Model: Okay, so as we go into learning how to get
more information, essentially by
customizing this message, what we need to
know is how do you find what the
parameter is called, like is called pan or
is it called panning? These are important, one is
going to work and one's not. I can't find any documentation that just lists everything
that you might want. However, there is
some documentation called on what's called the live object model that basically gives you
all of that information. It looks like this. What this is telling us is we have tracks, we name the track, and
then mixer, mixer device. And then these are
the parameters in the mix device, right volume. Panning is called panning. We have sends cross fader, song tempo, Q,
volume, et cetera. By setting up different devices like we're using the
mixer device so far, but there are other
devices, right? We can get those parameters. This document can
help clue you in on what the parameter you're
looking for might be called. I'll link you to this
document in the next segment. Keep an eye out for that, okay? If you're really
digging for something, you might want to be
able to pull this up. Maybe bookmark this thing, okay? That being said, we know
how to find volume, right? Let's do another one.
Let's do panning.
16. Getting the Pan Position: Okay, the pan position
is going to be super easy because it's going
to be all the same, except for this last word. We're going to switch
that to panning. Okay, now we've got
the pan position. Let's test it as
my pan position. Oops, I didn't
resend this message. Always got to resend that
message whenever you change it. Okay, great. Now we're
working just fine. What if we wanted
our Pan position to look like it looks in live? Let's try that by
getting a live dial. This might not work
right off the bat because my ranges
might be different. But let's try it. Nope, it's getting zero in one. Okay. So the live
dial, its range. What is its range? Let's ask it. Its range is zero to 127. And we're sending it, we're sending a negative one to one. Okay. Well, that's easy enough. I think in the previous class we looked at the scale object. Let's look at that
again. Scale, scale is a super useful object. This one I just have memorized
takes four arguments. The first one is the
low number coming in, that's going to be negative one. The second one is
the high number coming in, it's going to be one. Third one is the low number coming out, it's
going to be zero. The fourth one is
the high number coming out. That's
going to be 127. So this object is going
to take the range of negative one to one and
map it to zero to 127. Okay, so it's going to do
all the ugly math for us. Okay, let's take that. And now it should just
about match, there it goes. It's got a little more
flexibility than the dial has the dials only
going down to zero. It's not doing my
negative numbers at all. This is a better one
for the panning. But there we go, panning.
17. Getting Tempo: Okay, let's do a little more complicated one and
get the song tempo. There's a whole bunch of reasons you might
want to do this. For this, everything
can stay the same. But we do need to adjust our
message a little bit more. Let's look at the
live object model. Down here is song tempo. We know we need to
format it like that. Okay, song tempo, however, see this diamond here? That's a little clue. If we go all the way up
to the legend up here, that diamond is telling
us master track. Okay, cool. How do we tell it we're
on the master track? Well, you can see here, master track, just
master underscore track. What that means is that
instead of tracks, we need to change that
to underscore just one. Then mix device, we
still want to be on the mixer device for this
because that's where it is in the live object model. Then we need song
underscore tempo. All right, and that should
give us tempo 1205125. Great. If I change the tempo, we should see it
updating down there. Now, not updating the sliders, which is odd because it's
way too high for that. Yeah, this number
is just way too high for these dials.
But that's okay. It's showing it
to us right here. That's how you would
get the tempo.
18. Getting Transport Status: Okay, let's do one that's
a little bit different. Let's figure out if the
transport is running. This can be useful for a
lot of different effects, especially rhythm based things. The transport is running, meaning the track is playing, time is progressing,
or whatever. Then it tells us, it tells us if it stopped. It tells us when we
hit play or stop. Let's start with our snippet. This one, we're going to
have to change a little bit, so much so that we might want to save this as a different
snippet actually. Okay, so for this one, let's
zoom in a little bit here. Okay, We don't need to
know track or device, so we're just going
to say path live set because all we need to know is what is the live
set doing here? Okay? Then we're going to go
into trigger just the same. Now the thing that the trigger asks is a little bit different. We don't want a property value, we want property is playing. We're asking if it's playing
to the live set basically, we're going to send that
into live observer. Now we're also going
to change this a little bit how we report it. Let's say, let's use
the object change, which will get rid of
repetitions of a number. This will only show us the
result when it changes. We could also just look
at the raw result, which in this case won't really look much different since
we're using a number box. Okay, let's see it. Let's send live set. Make sure we send that path. We're not playing now we are playing now. Stopped playing. Stopped playing. So
we get a zero on one. Cool, We could map that
to whatever we wanted. If we wanted it to say yes or no for example, That
would be easy to do. We could do something
like this, if we want to get a little fancy
with our UI stuff, we can say select 0.1 Let's
go right out of that change. It's going to bang
here if it's a zero, and here if it's a one
here we'll say yes. We'll say no, we'll bang that. Then I don't know if
we want to just get even a little bit more
fun. We could do this. Let's do a comment, right, is the transport playing? And then we could fill
a message with this. We could say, all
we'd have to do is say pre pen set, Run
that into there. And then I think on the right side probably
won't matter in this case. Okay. This is a, this is extra stuff that
I'm just doing for fun. But basically when
this gets to zero, it's going to bang
out this outlet. So it's going to get Yes, the transport is playing. That's actually backwards
of what we want here. Let's fix that. No, yes. Okay. When it gets to zero, it's going to say no. Then pre pen set
means it's going to put the word set
before that message. It's going to say set, no. Which I guess I don't
really need to do in this case because the message
can take it in actually, I take that back.
We don't need that. We could just do this I think, and it should just write it. Yeah. Okay. Now we can
move that right there. It's just going to say
no. We're going to put it into the right inlet of another message box
and it's going to set that message to it. Now if I hid all of this stuff, and this was all you saw, and I went and hit
play and stop. Stop. Play, Stop. Now
it says yes or no. You have to do a little bit
of different things for the path and for the message that you're asking of observer. But it's the same basic format.
19. Getting 16th Note: Okay, let's do something
totally different. There is a different way to get some information that doesn't
use our little snippet. And one thing in particular that I want to make
sure you know about, because it's really important for a lot of the
things that I build, the tools that I build, what I want to have
more than anything in the world is a 16th
note from live. Right? I just want to
tete so that I can map that to different things happening and make these glitchy effects
that I like to make. Let's figure out
how to get that. There are some ways we
could do it that would be the same as what
we've been doing. We could build, tell the live path to go
to the transport, get the bars, beats and
16th notes that way. But there's an easier way
actually for this one. What we can do is
take advantage of the transport that's
built into Max. Now the transport is
new thing in Max. If you're using Max by itself, you get this internal transport. If you don't know,
what I'm talking about is the play stop record part. The part that says
play and stop, that's what we
really care about. It also says the tempo, the BPM, all that stuff. If you use the transport object
in a max for live device, it's going to go and talk to the transport transport. Cool. Let's go over how to
do that really quick. Okay, so I'm going to
make a new object called transport Now in order to
get transport running, I need to do strange things. Basically, every time I
send transport a bang, it's going to report and say
what the status of stuff is. If I want to find the 16th note, I need to be like pinging
it like often and fast. I'm going to use a
metro to bang it. Remember, metro is like
a metronome where we can give it like a certain
number of milliseconds. Let's start off by
just saying four n, that means quarter four. I'm probably going to need
to hit it faster than that, but let's go with
that for now four n. Then to give it
an attribute that I'm going to do with ampersand. What I need to do
here is just say, you can see the attributes there that
automatically come up. What I need to do, active, active, and then the number one, what that means is only run this metro when the
transport is active. Okay, so I'm going
to plug that in now. When I start my live transport, it's going to start hitting this every quarter
note, which is great. Transport outputs a
whole bunch of stuff. Let's look at what we got here. We have bars, beats,
units, current resolution. What else do we have
here? Tempo. Let's look at our tempo just for fun. Time signature. Sure, let's
look at our time signature. I'm going to put
a message there. Put that into the right,
in let transport state. That's what we figured
out in the last one. Raw ticks and clock source list of things telling
us what's going on. Okay, let's start it
and see what happens. Here's my transport now. It's running, okay.
What we see here, bars that were on beat. What was this one again? Units. I'm not really
sure what that is. This 480 is current resolution. Tempo is 120, time
signature is 44. Neat, I got all of
that stuff from live. Now if I want to 16th note, I'm going to have to
do a little bit more. I might be able to
just ask it here, but I don't think it's actually
reporting the 16th note. It's giving us ticks here, but that's actually that I
think that is going to work. Okay, here's what's happening, this unit number, I'm
not sure what that is, but that's not the 16th note. However, it is
changing very rapidly. I'm asking for it
every 16th note, which means this number is
changing every 16th note. If I just convert
that to a bang, that's a 16th note. I don't care what
the number says, I just care what that says. In theory, I want to test this and see how
accurate that is. I'm going to take both
those bangs and I'm just going to click here. Okay? And then I'm
going to go to my plug out and
throw that in there. Okay, that's a 16th note. This is sending this number four times for every time
that we see it change. They're actually both sending
16th notes at this point. If I wanted to get just
quarter notes from this one, I could use that change
object we saw a minute ago. Get rid of that only
output when it changes. Now it should give
me a quarter note. Yeah, and it's totally solid 11. If I'm counting it out loud
and it's not lining up, it's because of the delay
in video recording. It sounds lined up to
me, but there we go. Now I have a 16th note
and a quarter note. I could get a whole
note here if I wanted. Cool, that's how you can get a 16th note that'll follow
along with your tempo. This is great for doing any gating or patterning
or something like that, which I like to do a lot.
20. Building the Snippet: Okay, let's go into
controlling live. The opposite of
what we were doing. For this we're going to need
live path and live object. Let's do the same thing.
We're going to build this as a snippet and then save it. So that we can modify it for
any reason that we need. There's actually two
ways we can do this. Let's start with a simple way. First, let's make my window
a little bit bigger here. And zoom in just bigger touch. Okay. First we need live
path to get our path. And then we need a message box. The path messages here
are exactly the same. Let's go to our volume. Okay, I said tracks two
here because I want this one because it's our only audio track that
has a volume fader on it, even though the effect is this is what I'm going to
control that volume, okay? So I'm going to
plug that in there. Okay. Next I need one of
those trigger objects. This is all the same. I just need one list here
though, trigger bang list. Now we're going to put in
our controlling object. Our object that's
actually going to control the thing.
This is a volume. No, I'm going to put a
floating point number. Depending on what
you're controlling, you may want to put
something different here. Now, I need a message
box to do set values, value dollar sign one. Oops, not being able to spell today value dollar sign one,
that's behaving strangely. Okay, and then live object. Then just one more thing. I need to connect this
live path list over to this live object also on
the right inlet. That's it. Let's look at this
one more time. We've got the path
going into live path. This I did wrong, this is
the second one we need. The ID goes into trigger object, then what we're going to send to that object and then
we need to set value one and send that to the live
object that should do it. That's really all it is, It's really similar to our other one. Okay, let's go over here, let's send this message
and then let's control it. We can see it's
working just great. Okay, now you may have seen, earlier we did one where both were watching
it and controlling it. With this one, we
can't watch it. If I change it here, it's not
going to update over there. Okay, let's save this. Select All control,
click save snippet. And let's call it control
live, Save snippet. Okay, now I have that one, Everything we had
just talked about. That'll let us control
basically all the same stuff. Let's do it the other way, where we build a
patch where we can both observe and control.
21. Building the Snippet Another Way: Okay, in order to
modify this so that we're both observing
and controlling, we basically need to do one thing to make sure we
don't get a feedback loop. This top part is the same, our trigger is the same, except we need another list here because we need
one for the observer. Let's get rid of
that for a minute. Let's get rid of that. We need a message box. And here we're
going to go back to that property value thing and
we're going to bang that. And then we're going to send
that into live observer. This is the same
as it was before, but now let's take
a message box here. Set one again. Whatever comes in here is going to be
this dollar sign. One gets replaced with whatever
that is. This says set. That should prevent it
from always outputting. If we put like a slider
of some sort here, let's see, we'll have
to scale these values, but I think it'll be
okay then we take these values out then I'm not sure this type of slider will work, but let's find out. I need to connect
a few more things. So I need this list to
go into this observer and other list to go
into the live object. I think that's it. All
right, so let's test it. I'm going to send my path, let's see if I can control it. Ooh, I get all kinds
of good errors. Look at that. Take the
parameters range, right? Okay, so this is sending a zero to 128 or
something like that, and this wants a zero to one. There's a few different ways
we could deal with that. We could use that
scale object again. Okay, let's use
this slider here. That should work a better, because it's already
in the right range. Okay, Now I can
control the volume. And watch the volume here. Perfect. Let's save this one. Now This one I'm going to save, control and observe,
Observe, live, boom. Okay, so now I have
two ways to do this. That's great. Okay, so now
let's do some stuff with it.
22. Controlling the Pan Position: Okay, let's go through some of the same things
that we listen to, but now control them. Let's go to our
snippets and say, should we do control and
observe, or control? Let's just do control
for the moment. Okay, here's our snippet. Let's change this to panning. Now for each of these, we're going to need to change our value here a little bit. This one I think
will work by value. What I should have said
was the range, right? And maybe even the
UI object sometimes. But I think this one
will work for us. Our panning position
I believe is going to be negative one to positive one. Let's send that there now. We should be able to go, oh, we save this to track two. That's here, there we
are, that one, okay? Getting 1 million errors here. And it's because I
went too high, right? What I need to do is go back to zero and set this to
be a maximum value. Now this is interesting, there's a few different ways
I could do this. I could do that with
the scale object like we did for
the other things, but I could also just
go into the inspector. Let's move this
over a little bit. I believe I can set a minimum and maximum
value right here. Minimum value should
be negative one, maximum value should be one. Now the trick with doing this, now that we've done
it, it's going to work great for panning, right? That is perfect. However, the problem is, if you are in the habit of
doing what I do a lot, which is just, oh, I need another number
box and grab that one. Now this one is going to be at that minimum value
and maximum value. There's nothing in the interface that shows you that you changed the minimum
maximum value. It can cause problems later if you're not paying attention. That's why I like to
use the scale object because it's like you can really just see what it's
doing much easier. But setting the range of an
object like that works too. All right, so now we're
controlling panning.
23. Selecting the Track to Control: Okay, let me show you
another little trick we saw down here. We can do a message
with this dollar sign. One thing what we know
that that does now is if we send a number
into the message, it's going to use that number in place of where
it says dollar sign one. Okay, this is going to output what's going
into live object is set value 0.88 That dollar sign one basically is a placeholder. With that in mind, we could
format this message a little bit more to customize
what we want it to do. Here's what I mean, watch this. What if I replaced the track
number with dollar sign one? Then I put a number box up here. Okay, let's actually just look at what that's sending by putting a print object on it. This is, using print
is just a great way to confirm that things are doing what you think
they're doing. Okay, If I type in nine, here's what happens first,
I'm going to get an error. That error is cool, because what that
error is telling me is that there's no
track nine, right? We don't have that many tracks. That's why that error is there. Let's say track three because remember track three is going
to be the fourth one here. That's as many as I have. I say track three but
then look at what is printed path live set
track three, mixer, device panning With that, what I can do is put that number box
there and modify this message as needed, right? So this is cool, because I could now have a little more
flexibility in this message. If I was doing something
where I wanted to change the panning of track
three, I could do that. But maybe then
while I'm doing it, some event happens that
switches this to track two. Now I'm controlling track two. And then something switches it and moves it to track zero. And now I'm controlling
that, right? So we can use this dollar sign one to
modify this message. Oops, just triggered
a bunch of errors. I could even get crazy with it. Like let's say random three and then put a bang button here. Okay. Now I could do this all day long and I'm
just switching between tracks randomly that are
getting controlled by this pan right on here. Didn't work because that's
this track in its Midi track, doesn't have a panning position. But this will work
with everything, both listening and sending. Whenever you have
something in there, you can just dollar sign one
and replace it with whatever you want handy if you're trying to do something
to multiple tracks on.
24. Controlling Transport Status: Okay, let's control
the transport. Let's start and stop the
track from within max. We need to do a few funky
things to get this to work. Now there's a few different
ways we could do this. This is the more
complicated way, but I'm going to use it to help us learn a
couple more objects. First, we need to set our
path just to be live set, just like we did when we were
listening to the transport before we're going to go
live path into our trigger. I think we're going to
need another list here. Okay, Just hold on to
that for a minute. Okay, Now we're going
to get rid of that because what we really need here is just a button at the top. And we're going to
use that as a toggle. Now we need a message. We saw this before when we were asking live what it's doing because we
still need to ask it. We're going to get rid
of that. Go with that, we're going to go
into our live object. We're going to ask the
transport if it's playing. Now we're going to get
a little fancy here. We're going to use
a route object. Let's look at what route does route selects output
based on input matching. Basically, what you can do
with route here is we can say, take in a whole bunch of different things into
its first inlet and then it'll output them to different outlets
depending on its argument. The first thing in
what we give it, for example here it
says to wash the cat. The second argument
here is a number two. If I click on that, it's going to output wash the
cat out its second outlet. Right. It really lets us
just parse things out. Okay, maybe we'll make
more sense once we do it. What we're going to do
is we're going to say we're going to use route
and then we're going to evaluate the
message is playing. If live object says
something is playing, it's going to say zero or
one. And then is playing. We want to select zero. If it says zero is playing, we need to grab that zero. Then we need to send it a message that says
start playing. We're going to do that with
a message. Start Play. Oops. Let's slide that
up just a little bit. We're almost done, okay. And then that is going to go
into another live object, we're going to say
if it's not playing. So let's go through this
part one more time. We're going to ask
the live object, he is the transport playing. That's what we're
doing here. Get play. Is it playing? Live object
is going to return. Either going to say zero is
playing or one is playing. We're going to look for is playing and we're
going to select it. If it's zero, we're going to say start playing to
the live object. By that same logic, we're going to say
if it is playing, we're going to say stop playing. And we're going to use the
other side of select here. Now this is funny little trick here because what select does
is we can say select zero. If it matches zero, it's going to output a
bang out its left outlet. If it is anything
other than zero, it's going to send it
out its right outlet. Now this is going to
send zeros and ones. This is just a
shorthand I could do. Also select one,
but I don't need to because it's either going
to be zero or not zero. This is just a shorthand way
to isolate the ones Google. Then I'm also going to need
my other list here so that live object knows
what we're talking about, what we're looking at. Okay. Another convoluted
one, but it should work. Let's try it. There's
our transport. I'm going to bang it. And it starts playing, I'm
going to bang it again. And it stops playing
Hurray, it worked. I can start and stop
it all day long.
25. Controlling Track Names: Okay, maybe you remember, way back at the beginning
of part one of this class, I showed a patch that I think it was just
called stupid Max for live tricks or
something like that in it. One thing I did was changed the track names to be funny things in the
middle of the track. Here's how I do that. This
is actually pretty simple. Let's take the
controlling live snippet, zoom in just to touch. All right. All we really need is let's do it to
the first track. We just need that much
live set tracks zero, we need to know live
set and we need to know which track
we're talking about. Okay, then all we
really need here is this live path needs to go
into live object on the right. Then here we just need
to set name space, whatever we want to say
here, let's say Pickles. All right, Then we just
need to click that. Okay. We could put a
button on it if we wanted, but if you want to do
this, we're going to go like that to make sure
it's got the right path. And then we're just going
to click this here. It says track one miti. If I click on this,
it says Pickles. Now another thing I did
was I set up a thing where it started toggling
between two names. Here's how I would
have done that. Two names, let's do sandwiches. Pickle sandwiches. Okay. I need something that's
basically going to bang these like one then the other
than the one and the other. This has nothing to
do with Max for live. This is just some
silly ableton stuff, but maybe it's a
fun little break, silly stuff, but let's
do it really quick. I need a Metro that's going
to go at the speed I want, 60 or so, 200 milliseconds.
That's pretty fast. Then I need to turn that on. Let's organize things
a little bit here. We'll go about that fast.
That's a little fast. Let's go 300 shut, remember this is milliseconds
we're looking at here. Let's go five. Okay, That's
a half a second. Okay? Now, I just needed to alternate the way I always do alternating. I think it's probably an
easier way to do this, but I always do
counter counter one is going to with a maximum of one. It's just going to count
010101 that can go in there. I need one more thing
which is select zero. We can use that same
trick we just use here. If it's a, let's
put it bang there. If it's a zero, bang
that if it's not a zero, which in this case means
it must be a one bank. Now we can see it's
alternating pickle sandwiches. Neat. Now luckily, I've given myself a way to
turn that off this time, which I don't think I did
in the other version. If I just turn that
off, it's doing that. But don't do this.
There's no good reason to do this. It's
just kind of funny. I suppose if you wanted to make the weirdest plug in ever, you could make
some setting where some combination
of notes happened. And then like it started
changing your track names. It'd be like a hidden feature
or something like that. But let's leave that behind. Okay, moving on.
26. Controlling with Abstractions: Okay, last thing in
this section that I want to remind you about, because I don't think
this is new information, we've already talked about it. But look at that. Max for live API abstractions, remember you can find
that by going to extras. And then Max for live API Abstractions give you a lot of cool
things you can do. We'll do a clip in a minute. I want to do processing audio, then we'll go back and
do launching a clip. Some stuff with mities, scenes, devices, global track, a lot of different
things you can do. This is definitely not an exhaustive list of
things you can do. These are just some
standard abstractions. Don't forget about this. This is an awesome
little shortcut to get you doing some stuff
that you might want to do.
27. Controlling Tempo: All right, let's
control the tempo. All right, let's go to controlling
live with our snippet. Zoom in a little bit. Now we remember the message
we need to send here. Instead of track two, we're going to go master
then mixer device. And the tempo is our message, same as when we were monitoring it and everything else
should be the same. Let's give it a shot. So I'm going to send that, okay. It's saying invalid
range because our tempo, our possible tempo
range in lives, I believe it bottoms out at
20 BPM and it goes up to 200. Let's use a fresh number
box, not a floating point, although we could use
a floating point, it certainly can handle that. Sure, let's use a
floating point, but we need one
that has the right. Let's go here. Let's go to our inspector again. All the way at the bottom
and let's change this. Minimum 20 and maximum
I believe is 200. All right, now I shouldn't get any more errors and I should be controlling our
tempo up here. And I am cool. Let's learn another
new trick we could. Let's say we wanted
our tempo to go from a number to another number
over a certain amount of time. There's an object
that would do that. That object is called line. Draw a line between two numbers. What we need to give line is a message that
says starting point, ending point space,
length of time. Let's say our tempo is like 80, but we want to get
up to 160, okay? I need a comma between those. 80 to 160 is what we're going to tell it to do. Then
I'm going to say space. I'm going to say do it
over the course of, I don't know, 2 seconds. Okay? Now, when I hit that, which I could just click
on it by going, put it bang to be fancy. When I hit that, it's going
to generate those numbers. Let's put a number box
on it and just look. Watch. Boom. There goes, okay. Took 2 seconds. Great. Let's just pump
that right into there. Watch our tempo up here. When I click this, our tempo
ramps to the next spot. We can get fancy with formatting this message to make it
then do the opposite. And other things for
musical purposes, we might want this to be longer. We might want to be
over like 10 seconds. Which would be that, see
now it's like slowly going. You could use this
in like a crazy, weird build up where I'm
just basically going double time by
doubling the tempo. That could be a fun effect, but okay, so that's how
we control our tempo. Check out line, you can do
some fun stuff with it. If you look in the help file, there's ways to do a
little bit more with it. It's a fun object.
28. Getting Audio: Okay, we made a
snippet and talked about how to listen to
what live is doing. We've done a snippet where we built a way to control live, to send information
back to live. That's two of our big
three things that we wanted to accomplish
in this class. Our third thing is
getting audio and Midi in and out of live.
Let's start with audio. I'm going to go to
Max Audio effect and put that on an
audio track, Okay. Now like I said before, when I was talking
about the three types of Max for live patches, the audio effect,
instrument and Midi effect. The audio effect by default
is exactly what you want. There's really no snippet to build here, because this is it. What you're supposed to do here is we're going
to open this up. Okay? I'm going to make
this window bigger. I'm going to take this, I'm
going to slam it down there, and then delete these
by clicking on them. Press a delete key. Now I'm going to build my patch. Okay, this plug in object is a very specialized object that gets your audio directly
from live. Right? If we just want to see it, to do something
with it, let's take a audio signal and
we'll be able to see whatever we put
into live here. Right? Let me grab a clip. There's a clip now. It's playing right now, We're not hearing that
because this plug in isn't sending the signal
back to plug out, right? If we look down here, our
sound is coming in here. It's inside the max effect, but then it stops because we
haven't connected it down. If I did this, we're
going to hear it out of left channel here. We're going to hear it
out of the right channel. This really couldn't be simpler. Plug in is just grabbing the audio and plug out is
just sending it right back. Cool. No snippet required.
29. Getting MIDI: Okay, let's do the same
thing for Midi again. Super Simple. No
snippet required. Let's go to a maxi Midi effect and put it on a Midi track. Here, let's open it up. And this Midi in
and Midi out are basically just a piped
directly into live. If I do this, let's get
rid of these comments. I just look at what's
happening here. Let's just print
the raw Midi data. Okay, this is just
going to show us all the Midi data that's
coming in in the max window. Okay, Now I don't
have a Midi keyboard hooked up right now, but
I could just do this. Let's just make a little
clip there, okay? Now, there's a bunch of
Midi data coming in. And there it is, right? Let's go back to, okay, there's our Midi data coming in. We could now, if you remember
from the previous class, part two, when we talked about
doing all of this stuff, we made a Midi delay. We made a whole bunch
of stuff using numbers. One thing that you might
want to know is that the Midi in object is getting
the raw Midi basically. It's a whole bunch
of stuff like see all these numbers that are
just flying through here. That's fun, but not
entirely useful. Sometimes we need
to parse this out a little bit. You can do things. There are a couple other
objects that will go and get the Midi information
too, like Nin. Nodin is just already
piped into live. It already knows what
we're doing with nodin. We can look at only
notes if we want. And look at pitches and
velocity and channel. That might be a
little more useful to you if we're just
looking for notes. You can see that
already coming in. I don't need to connect
note in Midi in or to anything if I want to see
controller information. There's CTL in that's going
to show me just controllers, things like mod
wheels and any dials or anything like
that that you have connected to your computer
or that you're playing with. I don't have any right now that are sending anything.
There's nothing here. If you really just want to get into the weeds with Midi in, there's also an object
called Midi parse that will help you peel out all of
this information from Midi. In I've never had good
luck with this Midi parse. It's just a lot, it's
a lot of information. Usually for my projects, I just need the note info
or the control info. But that's something that you
might want to think about. Now if you want to send
things back to live, you just have to dump
them back into Midi out. Or actually you can just do note out as well that will
do the same thing. That'll send right back to live, any note information that
you made within here. The same thing with control CTL out that will send
controller information out. These three objects just
magically know how to make their way to
the Midi output. You can do whatever
you want with them.
30. Processing an Audio Signal: Okay, let's do some
audio processing now that we know how to do that. Now the way I
thought I'd do this is we did a lot of audio processing in
the second class where we learn real code stuff. Let's take one of those patches and turn them
into a max for live patch. Okay, here's what
I've got going here. This is one of the
patches I gave you in the second class. This is a max pat file that's
not going to open in live. It just gives me the circle
with the line through it. That won't work. But here's what will, right now I have this patch
opened in normal max. This is in Max for live. Okay, Even though I can't
open file in Max for Live, it's still all the same code. What I can do is
just copy all of this and paste it over here. Now I just need to
connect it to live. I don't need all
the selector stuff, the SF play stuff or
even the ADC there. Let's get rid of all
of those things. This is what's going into my level meter
from the selector. That's what I need to come
from my plug in object. Okay, now this deck
in standalone max, we would send everything out. The deck, I don't need that. Instead I need everything
to go into this plug out. Give myself a little more room. I can really see
what I'm doing here. Whenever you're doing
this, I like to do them one at a time. Let's connect those
and then delete those so that we
don't miss them. Move this over here,
just so I can see it. I think this one was left, This one was right,
and this one was both. Maybe. Yeah, Sometimes just moving stuff around
just helps you see it a little bit better. Okay. Now we can delete the deck and everything
works. We don't need that. We can close this patch
and go back to live. And if we play this
through initially, nothing happened,
but it's because I need to give in volume. Hey, there's our dry
signal, the delays. Not the coolest
thing in the world. Now I'm noticing we're not
seeing our level meters here. I must have had those
connected separately. That's okay, we can do that. And that the easiest way to convert something from a max patch to a
max for live patch, just to copy the
code into a Max for live device and
then replace your audio or Midi inputs
with the correct thing. Either the plug in mid in. Then replace your outputs with plug. Then you're good to go.
31. Processing a MIDI Signal: Okay, let's do the
same thing with one of the Midi patches we made
in the second class. We have this Midi delay
here through random notes. Now this is really interesting because I
think when we made this, I told you that what's
going to happen here with this random thing is that we're going to be
making this randomly, moving our pegiator's
quite difficult to limit it to only picking
random notes within a key. That's actually really
quite hard to do. We could do it in
Max by making a list of available pitches that
it could choose from, limit it to a key that way. But there's an easier way now
that we're in Max for live. It's much easier.
It's a lot easier. That's a better way to say that. Let's convert this to
a Max for Live patch. I'm going to copy all of this, then I'm going to go
back to Max for Live. Now this is a Midi effect.
Let's just use Midi. Put that there.
Open her up, okay? I don't need you anymore. Let's make this nice and big, and paste it in there, Okay? So first Midi in. Do we need Midi in, or are we just generating
Midi notes here? I think we're just
generating Midi notes. We don't need a Midi in. Our note out is one of those special objects
I can talk right to. Ableton. It's going
right out and it's going to generate some
notes on its own. Wonderful. This can stay exactly as it
is. I don't even need this. I could leave it here,
but maybe I just want to sever that to make
sure that it doesn't pass through anything
on that Midi channel. Can do that. Then it should start going. If we launch it, let's give it like
something now. We could connect this to the
transport if we wanted to. That's actually
probably a good idea, but let's get some
sound out of it first. We can see notes are happening,
so everything's working. But I don't hear
anything because I don't have an
instrument on here. Let's just throw a good old
fashioned analog default. Okay, cool. Let's stop it. Let's pull that
down for a second. We stopped it before I got a
note off, but that's fine. Let's not worry about it. Okay, let's make this conform
to the key, to any key, and then we'll next connect
it to the transport. The easy way to get this in key is actually
not to do it in Max. There are some things that
Max is really good at, there are other things
that we have tools for that are just as
good, that are better. I'm going to go to our
Midi effects and I'm going to go to scale. Let's select just
like a minor scale. Minor scale, okay. Now what that's going to do if you've used max Midi
effects before, and this one in particular, what it's going to do is
every note that comes out of our Midi effect is going
to run through this. And it's basically
going to quantize the Midi notes to be
something in this scale. In this case, C minor, because I have C right here. Okay, So everything now is
going to be in C minor. Oops, let me turn
my volume back up. It's rather pretty. I can prove to you
that we're in C minor, Let's just duplicate this, and let's maybe just
put a piano on it. I'm just thinking this
might sound nice. Um, give me just plain old
piano, grand piano, cool. Let's see, I don't want that. I'm thinking. Let's just play some big old C minor chords. Let's take, let's go down here. Do that, Let's take longer. Let's go F. Let's go down and we get two or single
core question in C. I want you minor, let's you get the
record flat, flat. Okay? Then maybe we'll
do another C minor. Sure. Okay, so just a little little core
progression just for fun. Okay, slow it down just to
touch and let's try it. So let's launch this. Okay, cool. I heard
two things that I would change is that it not being in perfect
time with the chords, make it a little annoying. So we'll fix that when we
look at the transport. But another thing I
might do just for fun is move everything
down on an octave. I think I could do that
with a midi effect also. So I'm just going to put this pitch Midi effect on here and dial it
into negative 12. I'm just going to take
everything down an octave, make it a little less abrasive. And you know what,
I'll time I do. Let's move the
piano over onto it. Well, that's a whole
lot nicer, isn't it? Okay, let's connect
the transport to it. Let's go to a new
video for that.
32. Connecting the Metro: Okay. We saw not that long ago how to deal
with the transport. Let's do it the easy
way and go transport. Then we need Metro four, let's get a quarter note metro here and we'll go at Active One. What that's going to
tell us is we want a metronome going
at a quarter note. Go to Live and get
all the tempo and all that stuff also start
when Ableton starts. Okay, so here is our
bars, beats, and units. Let's see, do we want this
to be at an eighth note or a quarter note is going
to be probably too slow. Let's do that thing
that we did before. Let's go to an eighth note then. Actually, we don't even
need the transport. All we need is that metro object to replace this metro object, we can just grab that right
there. We'll be good to go. In this case we don't
need the transport. I could use the
transport to connect our metro and make it be the same value as the
transport by converting, figuring out how many
milliseconds each 16th note is at our current tempo and then putting that
into our metro. That's a lot of math though. This should work just fine. We're going to say,
give me an eighth note start when the transport starts. That should do it. Let's try it. Okay? I see one thing we did wrong, and that's that if we
don't have the tempo, then these aren't figuring out their delay
amounts correctly. We need a number
for them to figure out how they should delay. Okay, well, that's just fine, Let's do it the other way then.
33. Connecting the Transport: Okay, So this I think, is going to get a
little cumbersome, so stick with me here. First, I'm going to take my
Metro down to a quarter note. Okay. I'm going to
pull up a transport. Okay. And now I want to get
my tempo Tempo. There it is. So give me a number box hoops, is that the right one? Nope, that's time
signature tempo. Okay, so that's going
to give me my tempo. Let's adjust the tempo just
so that that number updates. There we go. Now that's 18. What I could do here, well, what I have to do is
I have to convert this one oh eight
BPM to milliseconds. Okay, let's see how
could we do that? There's a weird math
way we can do it, or we could count milliseconds
in between beats. Okay. This is a
convoluted way to do it, but I think it'll be
fun for you to see. Here's what I'm
going to do first. I need to isolate
every other beat. You've seen me do this before. Well, okay, let me explain one more time
what we're doing here. We need to convert 18
BPM into milliseconds. We need to figure out how
many milliseconds it is. What I'm going to
do is I'm going to set up a little system that will always be counting milliseconds in
between two beats. Every time we update the tempo, it will continue to count
milliseconds in between beats. And that will keep us
with a current number, that is how many
milliseconds per beat? Okay, trust me. So we've seen this before, counter one, that's
going to count 101010. Okay. Now, let's go select 0.1 I know I showed you before, I
don't need to do the one. I could just say
what's out the other. But this time I want
to do zeros and ones just because it seems
like a good idea. Okay? Now I can already see why this isn't
going to happen, why this isn't going to work. This is just our BPM. There's nothing to count here. What I really need to do is, is to take this number
from this metro object. The metro is going to send
quarter notes and we're going to move every other one is going to bang on
each side of this. Let's make sure that's
working perfect. Okay, now I need to count how many milliseconds
happened between these two. If I remember right, Tim is an object that we want. For that, let's look at
the help file report, Elapsed time between two events. We go this one and
then that one, and it's going to output
how many milliseconds happened between
these two bangs. Perfect. That's
exactly what we want. So we're going to
go there and there, and then we're going to look at how many milliseconds
happen there. Okay, let's start it. 555. Okay. So that means
every quarter note is 555 milliseconds long. We could do the math
on that and figure out if that's actually a
quarter note at this tempo. But yeah, let's
assume it is, okay? Now we have our bang
happening here, so we really don't
need this metro. But I do need this
number box because it is controlling all of
the delay times, right? So I need this to go into that. All right, so let's
set our tempo to 100 and let's launch that
and see if it worked. Did it took a second.
There you have it. This is just counting
the milliseconds between these two and reporting back how many milliseconds. We're using that to derive
all of our delay times. Cool.
34. Launching a Clip: Okay, let's talk about
launching a clip. This is something
that I see a lot of people wanting to
do in Max for live, and there's a couple of
different ways we can do it. First, let's do it the easy way. The easy way is there
is an abstraction. If we pull up this R max for
live list of abstractions, there is a clip, selected clip. Now fire means launch here. If we use this, what that's going to guide us to do is it's going to open
this and it's going to say, here's how you pull it up,
fire the selected clip. Let me put this into my patch. So I'm going to make a new
object and I'm going to make Mf reli fire selected clip. Okay, and then I'm going
to put a bang on it. Okay, This is great and simple. What this is going to do is
whatever clip is selected, meaning let's select that one. I'm just going to click
it to highlight it. That's what this
is going to fire. I click it and it's
going to launch that. Okay, cool. That's easy. Let's look inside
this abstraction now. Any abstraction we can command
click on and see inside. And this is the guts of it. What if I wanted to not
fire a selected clip, but I wanted to say which
clip I want to fire. I really bottom stuff right, here's our path
path to our clip. Live path, trigger
bang list call fire is what we need to say to the object. Let's
build it that way. Instead of saying I want to
fire the selected clip here, I'm going to say I'm
going to tell it which clip to launch, I'm going to go live path. Now I need a message
in this message box. We're going to say live
set Visible Tracks. Then we're going
to say dollar sine one slots. Dollar sine two. What this means is
of the tracks one, we're going to say
which track and that's going to be the first
number that comes into this. And then we're going
to say clip slot, that's going to be the second number
that comes into this. I need to send two numbers in, but not through the
two different inlets. There is a way to do that, but that's not the way
this is set up. I need to say, let's do
it with a message box. Let's say track number 0123, clip number zero,
clips go by zero, also 012. Let's launch that one. Okay, now I need to send both of these numbers into this
thing at the same time. And we have a way to do that. I need to pack, need to pack them up, okay? And then shoot them
into that list in pack. I really should give it an argument of what I'm giving it. It wants to know
what's coming in. I'm going to write 00
just to say there are two numbers coming in, okay. Now that is going to
go into live path. Now the rest of
this is going to be a little familiar
trigger bang list. We've seen this before. We're going to take, oops, now we're going to
make our live object. We're going to take
that list into the right inlet and we need one more message box
where we're going to say, fire, fire that thing. It's kind of funny
that they decided this should be fire for the clip. Okay, let's make sure
our path is right first. So if I do this, oh,
it's already working. It's going great. I think these clips
are a little funny, but it's actually
working, right? So I could bang the use
both at the same time. And it's going to launch
that clip over and over. Now. Let's do something
careful. I'll stop that. What if I wanted it to
launch a random clip? Let's try that.
35. 39 LaunchingARandomClip: Okay, next I've set up a little set here that
just has a bunch of clips. You could do this with
Midi clips or audio clips. What I'm going to
basically do is tell it to pick a random and a random clip and launch it with all that
we have already. This is actually
pretty simple and I bet you can figure
this out on your own. Let's do it now. Our maximum random number
here is going to be three, because this is going
to be for the track. Then each one of
these has four clips. That means our random number for the clips is also
going to be three. Actually, no, there's
only three tracks. Our maximum number here is
going to be two because 012. Okay. Okay. And Okay. That's all we need to do. All right, let me just do this. Pull this down just a hair
and this should work. If we want to get
even weirder with it. Let's, let's launch a new random clip
every downbeat. Okay? So what I need is I need this set up again, and then I'm just going
to look for beats bars. I'm just going to
look for every time this bar changes, right? Every time that changes, we're on a new bar, right? Let's see if that works. It's not because the metro is shooting out a quarter note. Let's change that to change. I want to bang every time
that number an there it goes. Okay, so I don't need that one. I'm just going to
connect that bang to that bang. And then
we're good to go. This is going to randomly
launch one of these clips, the downbeat of every bar, and then it's going to just
keep playing them. Now you might be thinking,
if you're able to, you might be saying,
you know what, I could do this with follow actions. Yeah, you totally could. This is just a fun way to do it
and it gets us live. Okay. Before we start this, does anyone see the problem? There's an error
already that I can see. And it's a simple one, but it's a common one. Let's
walk through this. Random is going to generate
a random number and it's going to put it
into this message, which is then going
to get packed and sent to this message. Now my problem is here is
going to output a number, but then this inlet of a message really wants just a bang to send
that message down. If I want to replace the
contents of this message, oops, I need to go into
the right inlet of it. I need to do that.
Now, I'm going to change the content
of this message, but I need to hit it. What I can do here
is I can then use the same bang to hit it. What that's going to
do, these numbers are going to change
and then the bang is going to hit it the
next time around. One thing I might do
here just to make it easy is in order to hit these, I might make an object
that's just ten, right? This is delay ten milliseconds. Small amount of time, I'm
just going to take this bang. I'm going to delay ten milliseconds and I'm
going to hit it. What that's going to do is
it's going to this bang. Let these numbers let
these messages update. And then this delay is going to come and hit them out and
send them into the pack. Okay, maybe don't
need this delay ten, but I like to put those
in sometimes when I, when I want things to happen in a certain order just to be
super sure that they do. Okay, let's try it now. We put some scents and pads
and stuff in there too just for fun. Cool. Right. It's like AI, kind of, you could set up a big
thing and just have this just generate your music
all day and all night. Cool. So maybe I'll give you
this one if you want. Sure.
36. 41 CartoonExplodingPiano: Okay, in this next
section I thought, let's just do three projects that are not too complicated, kind of fun, kind of silly, but you know, they're
cool little projects. This first one I call the
cartoon exploding piano. Now what this is, I remember when I was a kid
watching some cartoon, maybe it was like Road
Runner or something. It was one of those, like classic Hanna Barbera
cartoons or whatever, where there would be a piano. The one note of the piano would be wired to like a
bunch of explosives. The person would sit
down to play the melody, but they would keep
screwing it up, so they stopped, they didn't play the note that was
wired to explosives. Then the other
character who was, who had set it up would chime in and would
run up and be like, no, you're playing it wrong. And then they play the melody correctly and then
explode themselves. So this is like some old classic cartoon trope
or something like that. There's your piano bit, now let's see you play it. No, that's not it. Try it again. Oh, you stupid rabbit like this. So let's do it. So basically what we're going to do
is we're going to make a Midi piano and we're going
to select a single note. And once you play that note, we're going to t an explosion. Since I don't have
actual explosives on me. We're just going to launch
this clip pretty good, right? Okay, let's do it. I
have a Midi track here. Let's go to Max for live. We could do this really anyway, but let's do it
with a Midi effect, since that's all
we're really going to need. Put that there. What we want to do here first, we need to listen for a note. Let's take note in. All right, let's look
at our notes now. I don't care about velocity, I don't care about channel. I want to leave this Midi
in and Midi out connected. Right? Because I don't
want to interrupt that. I still want to hear the notes. I'm going to leave that
doing what it does. Let's, let's say it's okay. I can see when I play it here, this is note number 64. Okay? Simple enough. Let's select 64. All right. Now let's put a
bang button on it, okay? So now I can play this keyboard
all I want. That's great. And when I play that,
we'll go up to it. Okay, We get that, but if you noticed,
we got it twice. Why is that? It's because
we're getting it at both. A note on and a note off. We're getting it when I push my finger down and then when I lift my finger up off that
note, we're getting it again. Okay. We need to throw out one of
those because we don't want to trigger
this sample twice. We could look for the velocity and say if the
velocity is zero, ignore it. That would be one way.
There's an object that I think might do us
just perfect for this. There's an object
called one bang. What one bang is going to
do is it's like a throttle. If there's a lot of activity going on that's going
to bang through there, then we can tell it. If we give it a bang
in the right inlet, it means reset it. This is only going to let
one bang through until we give it another bang
in the right inlet. Let's do delay. I don't know.
And then we'll bang there. Okay, That means only one every hundred milliseconds
can get through. Let's make it a
little bit longer. Let's go 500 because we really just want
this to happen once. Right, that works. Okay, so now we've isolated
just the note on of that. Okay, cool. Now the next thing we need to do is fire that clip. We already know how to do
this from our last project. I'm going to open
that up because there's no need to do
this all over again. You'll find that once
you make something, it can be really
handy to copy it. Okay. I don't need all of
that, I just need this. Okay. So here is the stuff we
need to trigger this clip. Now, we don't need this fancy stuff here, we
don't need that print. All we need to do is say track 01234 and zero. Okay, That's it.
Now it should work. Let's get rid of that.
Okay, So let's try it. So I'm playing all the notes
around the one I want. Okay, here comes the note here. I'll play a scale up to
it. I did it. It worked. It's silly. But it gets
you practicing, right? Okay. I probably should
have set that not to loop. So all we're doing here
is we're looking for a specific note.
Get that note here. We're going to use
this one bang to throttle it so that
we don't get that. We only get it every
500 milliseconds or so. That's going to throw out
the note off message. Then once we get it, we're going to do this and trigger this clip
which is right here, which is our explosion. Neat.
37. The Random Beat-Based EQ: Okay, this last one, I think this is my
legit secret weapon. I think way at the
beginning I said that a lot of people use Max to make their little secret weapons
that they keep close. I've made this a long time ago and started experimenting
with this idea. I've been using
this all the time. It's a subtle effect, it's way, but it's great on, it's great on pads. I put it guitars. I've even put it on
vocals before when I want there to be
like a little bit of chaos underneath the
surface of the vocal. What we're going to make
here is I'm going to make an EQ that moves
around randomly, on an eighth note or
even a 16th note, and it's just shifting
around, madly. Okay, let's dive in. Okay, first thing I'm going
to need a Maxra live effect, and this is definitely
going to be an audio effect on this track. I've put this
little drum groove. Okay, cool. Let's open this up.
Let's take plug out and pull it all the way to the
bottom because we're going to need it down there later. Let's get rid of the stuff. Okay. First thing
let's set up a filter. I'm going to need
a filter graph. I'm also going to need a, I think we looked at
this are filter graph. But I'm going to go to the
help file for filter graph because they have set up
here this attribute that shows me all this stuff and I just really want to
set it where it is. In fact, I'm going to copy
all of this down here. Okay, So I'm going to delete mine and put that there. Okay. Now I'm going to thin this out. I really just want to
see what these things are because this
cutoff frequency is what I want to get at. That's why I'm going to
start moving around. Okay, let's set it
into a band pass then. If I start adjusting
this cutoff frequency, that's when it's going
to get interesting. I want to shrink down
that cue a little bit, or actually push it up
a little bit. Okay? I'm just going to do
it like that now. I'm going to take my, my filter
graph out and set it into the bi quad, Okay? Should we do this
in mono or stereo? Let's do it in stereo. This whole thing twice. Okay? We're going to take the right channel, put it there. The left channel put it there. And then the right
channel put it there, and the left channel
put it there. Okay. That's all my audio
processing that I need to do. The next thing I need to do is just get this moving
around a whole bunch. First. I need a random number. I need it to really be, I don't want to go
too low or too high. So let's see if it
goes down around here, you're going to
hear like a bump as it hits zero or close to it. I really wanted to
bottom out around, let's say 160, okay 160. And we wanted to peak at about, let's say 2001,
60 to 2000. Okay. So what do I need
my random to say? I basically need
my random to be, the maximum value is
2000 minus 1601840. Yes, I needed a
calculator for that. Come at me. Okay. So
we're going to say random 18 40 and then we're
going to say plus 160. All right. That is
going to end up outputting the value
that I want into there. Okay, if I put a bang on that. That went to the right
spot. All right, now we should see my
filter moving around. Just how I want it. Just going to click at a whole
bunch. That looks great. Okay, and I'm going
to do the same thing again for this one. I want my left and right
channel moving separately. Great. If I now put a single bang
to connect both of those, we see them moving
around independently. Great. The only thing
I have left to do is get that 16th note. So this is super simple. All we need is we've seen
this a whole bunch of times, metro 16 active one, okay? So, stay in time and
should be good to go. All right. Let's hear it. See, that's a cool effect.
Let's open up a little bit. Oops, See, I mean, I like the que really
high for this actually. Because it really gives
it that narrow feeling. Yeah, let's make it stupid high. Okay, so the cool thing
about this is that you can make this as subtle or
extreme as you want. If you change this to low pass, you take your cue
down to a negative. But around there, do
you did it like this? It's going to be a
bit more subtle. Actually, it's still
pretty extreme. If you put like a
little delay on this, it sounds even nicer. It's a quirky weird effect,
but I really like doing it. It's just fun and simple. Make this, keep it in
your little arsenal. In fact, you don't
even need to make it. I'm just going to give this
to you in the next thing. Okay, let's move on.
38. Presenting Your Patch in the Live Window: Okay, there's one major
thing we haven't done yet, and that is how to make your
patches look good in live. Now remember the
idea of this line here means that if we want
to show up good down here, we need everything to
be above that line. Let's get this one
looking nice and pretty. The first step in this is going to be the same as the step before when we did this
in just standalone max. That was to add anything we want to the presentation view. I'm going to take this EQ, I'm just going to control
click on it and say Add to presentation maybe. Yeah, this cutoff frequency. And the okay, I'll do the same thing down here at a presentation, this
cutoff frequency. And the okay, the rest of this, I don't, I don't need that. I don't need that. Yeah, that's actually it. Okay. Now, if I go to presentation mode,
I have just that. Okay, let's make these a little smaller, make identical here. Okay. Now let's add some texts. We'll say, right? The first thing
we can do is give it like a fun, cool name. Let's call it, We Beat based. Q works based. Okay, maybe we'll make that cool by going to the inspector. We can change our fonts here. We can make it bigger. Let's do that. We can change
font if we want, blah, blah. Okay, there's that. Okay. Now, let's, let's do I really need to see that there? Let's do that in. That should work. Now what we have here
is filter type is fine. This I believe is the
no that's cut off. Okay? So let's label that cutoff frequency and the Okay. Now let's double check and make sure we're above that line. I think we are. Okay. Next, let's just
label this, right. I could do something fancier, but this works just fine. Just use text. Make that
nice and big there. Now it says this is
the right channel. Okay, let's do the same
thing with the left channel. Line those up, put the edit
mode, see what this is. This is cut off frequency, which means this must be the E. You can move things
around with arrow keys if you're
getting a little too close to make sure you're grabbing what you
think you're grabbing. All right, cutoff frequency. Now you can go really bananas with making this look really cool if you want to, but I'm not going to right now. But that's pretty good. Okay, now I got to
do one more thing. If I really wanted to look
good in the window here, you'll notice it still
doesn't look good down there. I have to go up to view. Click on Inspector Window. Now this is weird, let me walk through
that one more time. We have an inspector over
here for every object. But what I actually need
is the patch inspector, the inspector for
the whole patch. The easiest way
to get that is to go to view and inspector window. Okay, This is going
to show me some attributes of this patch. Scroll down to the view section and then open in presentation. We're going to click
that. Okay, make sure that open in
presentation is selected. Now when I go back
here and hit Save, you can see it
updated down there. Okay. Now you actually also
see my line came back. You can see that we're
really close to that line. Let's try select everything. And then I'm just
going to use the arrow keys and move up. Even though it's pushing my text above the palettes up here,
I think it'll be okay. Maybe not. It's a little
too high. Let's go. Okay, that's not bad. This left and right
isn't really showing up. I could make it
smaller if I wanted, but there we go.
That looks okay. Okay, now it's saved. I can close this, and
there it is down there. Okay. So the most
important part of that, the part that we'll have
you googling everywhere, trying to figure out what to do is that open and
presentation button. Make sure you get
that just right. Okay. Now that we have
this all cleaned up and cool as a max for live device, I'll give this to you again and then we'll move on to
our very last section.
39. Learning How to Learn Max: There is so much more to go.: Okay. I'm going to say the thing that I've said
many times before, the best way to learn Max is
to learn how to learn Max. I'm really hoping
that I've got you to that point where you have
learned how to learn Max. What we've done in all three of these
classes put together is maybe 1% of how Max works. If this was like a
comprehensive textbook that showed you everything
that was in Max, we've probably covered
the first chapter and the introduction, right? There's a lot more to go.
There's so much more. The best way to learn more is to come up with the project idea and
then try to do it. In the process, you'll
find new objects, you'll find tutorials, you'll find help files
for those objects. You'll learn more that way. You can also be looking
at some of the presets, both the built in ones and ones that you find on Max
for live and other places. Download those and open them. Open them up and try to
read what's happening. Try to read through, Okay, I understand this object is doing this, this
is doing that. Start trying to
understand those things. Pop in a little object if you want to see exactly what something's doing.
If you don't get it. We've learned how to do a lot with Max, but
there's a lot to go. But hopefully at this point
you're able to continue learning on your own with
the tools built into Max.
40. More Resources: Okay. At the very
beginning of part one, I showed you some
extra resources. I just want to remind you
about those one more time. Max for Live.com is a great place to find
all kinds of projects. The Cycling 74 website has
community forums going there, asking questions,
getting answers, reading the forums, other things that people have
asked and gotten answered. That is a really great
place to find help, to find other people trying to solve some of the same
problems that you're solving. One of the best things
about Max is that there's this huge
user community. By and large, that
user community is really interested in
helping each other out. The best entry point
for that community is the cycling 74 forums
on their website. I'd put Max for Live.com
It's a close second. There's also read it, Communities, discord,
communities all over the place. You can check out some of
those too if you really want to immerse yourself in the
max for live communities, don't forget about those
and don't be shy on them. As long as you're
nice and polite, people will help you there. Okay, a few more things
really quick as we wrap up.
41. Bonus Lecture: Hey everyone, want to learn
more about what I'm up to? You can sign up for
my email list here. If you do that,
I'll let you know about when new
courses are released and when I make additions or changes to courses you're
already enrolled in. Also check out on this site. I post a lot of
stuff there and I check into it every day. Please come hang out
with me in one of those two places or both,
and we'll see you there.