Getting Max to remember the values of all your user interface objects
on your screen is extremely important and potentially confusing.
There's a lot of different ways to deal with this situation,
but the one that I recommend to electronic musicians is to use the snapshots feature.
The reason I use the snapshots feature is because in
addition to all these parameters of your sliders, and dials,
and buttons and everything,
it also can remember the internal state of plug-ins like Audio Units and VSTs.
For that reason, I recommend using the snapshots feature.
It's also really powerful.
But let's take a look at how it operates.
In basic operation, I'm going to use a patcher snapshot.
Now, I'm going to set these sliders to various positions.
Open up the snapshot sidebar by clicking the little camera icon here.
Then when it's time to create a new snapshot,
I click the New button or the plus button.
Now, if you are following along and you do not see a New button,
that might be because you have an object selected.
What we want to do is make a patcher snapshot.
This snapshots feature is context-sensitive,
it depends on what is selected,
and you can't create a snapshot of this particular object.
But if nothing is selected,
then we're going to create a patcher snapshot,
and that's the first potential source of confusion.
Now, I'm going to lock the patcher which ensures that I don't have anything selected.
So by default, I'm going to be going into a patcher snapshot.
I can create a new snapshot by clicking the New button or this plus button down here,
they both do the same thing.
Now, I've created a snapshot.
Now, to demonstrate this,
I'm going to alter these parameters
and generate another snapshot. This time, I'll click "New".
Now, to recall the snapshot,
I have to click on the snapshot,
but where you click on it is also potentially confusing because if I click over here,
I've selected the snapshot without making it current.
The current snapshot is this filled-in triangle.
This is a selected snapshot,
and a selected snapshot allows me to delete and rename the snapshot,
and perform operations on that snapshot.
That's a powerful feature,
but if you're expecting to recall that snapshot by
clicking up here, that's potentially confusing.
So to recall the snapshot,
either click here or on the play button itself,
and that will recall the snapshot.
A third point of confusion results from the idea of parameterized objects.
I'm using live.UI objects here for a reason,
and that is because live.UI objects are inherently parameterized.
They are defaulted to remember their position.
Therefore, when you add a snapshot, they'll remember it.
If you try to do this with Max UI objects,
I'm going to unlock my patcher,
and create a number and a slider,
and then maybe a dial.
These are Max UI objects,
not Live UI objects.
I created a couple of sliders.
Let's do the same thing.
Let's set these values,
and create a snapshot,
and see if it remembers them.
Create a new snapshot. Let's set it to something else.
Create another snapshot.
Now, when I change which snapshot is current,
you can see that these are not remembered,
whereas the Live UI objects are remembered.
That is because by default,
Max UI objects are not parameterized.
There's a lot of different UI objects you can have in Max,
the Live UI objects are parameterized by default and the Max UI objects are not.
That doesn't mean you're out of luck if you want to use Max UI objects,
there's definitely Max UI objects that do things that Live UI objects do not do.
I'm going to select all three of these objects.
One of the things I like about Max is that the inspector can
operate on multiple objects selected simultaneously,
provided that they all share that same parameter,
and these three objects all share the ability to turn on parameter mode.
That exposes the values of these UI objects to the snapshots system.
So now, they're parameterized.
Now, I can go back to my snapshots and
create a snapshot that's going to remember their current state.
There's one, let's change all of these,
and then let's add another one,
and then we can switch between them.
Now, you can see even the Max UI objects are remembered by the parameter system.
You can also remember the inside state of an Audio Unit or VST,
as I mentioned earlier,
you can also remember the state of beep modules.
Then the last thing I want to mention about snapshots is that
you can script them by sending messages to this patcher.
You don't even need to have the snapshots window open. They're numbered from zero.
So if I wanted to recall the 0,
1, 2, 3, 4,
the fourth snapshot here, I would say,
restore 4, and there it goes.
The delete and add operations,
you can do this all with scripting.
But the great thing about snapshots is that it remembers Max UI objects,
Live UI objects, Audio Units,
VSTs, BEAP modules and it's completely scriptable.