💬 In this video we'll see why you want to place your root control correctly in your scene and how to fix it if you did it wrong in the first place. 🔴 DISCLAIMER: sorry if its a bit out of sync had issues with the recording, need to find the right settings.
🎁 Support my channel by buying my products: GUMROAD: https://gumroad.com/lucianomunoz 🟢 get 10% discount with code "lollypopman" in all my products! 🟢
In today's video we're going to talk about the root controller and how to
place it correctly in your scene. I'm Luciano and welcome to the adventures of Lollipop Man.
What's up everyone? Today we're going to talk about placing the root controller in your scene.
This is something that's very important but mostly super overlooked. It can help make your animation
10 times easier than if you put it in the wrong place and most of the time, at least in my case,
I start with the root placed in the wrong place and then as I block out my animation and get a
clear idea where it's going, I need to fix it and put it in the right place again. And so it's
really important not only to know why and how to place it at the beginning but also how to fix it
if you screwed it up before. So we're going to check that out just after a message from our
This episode is sponsored by me. Use the code below to get 10% discount on any of my products.
Before we get into the video, sharing is caring. Remember to like and subscribe and now let's get
on to it. So I'm gonna try to keep it as simple as I can so it actually turns out to be useful.
So why do you want to place your root controller correctly? Well, the reason is because the child
objects of the root controller, meaning the IK hands, the torso controller, the feet IK,
maybe the pole vectors are in the space of that controller, they will inherit their axis from them.
Let me show you what I mean. If we look at this character here that's running,
he obviously we have this controller which is the master of everything and then we have these
controllers that I mentioned before. It doesn't matter. I just selected these ones because with
these ones we can do it. The example could be more, could be less depending on how you set up
your rig. But basically these controllers don't depend on anybody else. They're all free but
they're childs of this controller directly. And so if we select this controller for instance,
you're gonna see that it has its own x and y that in this case it's local x, y, and z.
But if we look at the graph editor, the x, y, and z that we're looking at from the controller
doesn't have anything to do with what we're looking at in the graph editor. For instance,
this is up and down but if this were just up and down, you know, you can see that it's going in
like straight up and this is going up in a diagonal, right? Same with y for instance.
If we look at y, I'm going to look at it from the top and if I move anything here,
you're gonna see that it's moving in that direction but this implies that it should be
moving downwards, right? So why is that? Because it's not about his transforms but about this guy's
transforms. And if we look at now this z and this x and this y, it will make sense. So how can we
show that in our viewport? Well, first we're gonna select this guy and we're going to go here
and press a plus. And that means that we're gonna take that bone as the transform. So we're gonna
call this root. And so now if I select this other control, we're looking at this controller
based on those transforms. And if you select any of the curves and you start moving it,
you see that now it makes a hundred percent sense. I'm going to select x and that makes
complete sense. I'm going to select z and that makes complete sense. Now they are actually
aligned to the transform. So that tool is very nifty. It's useful. It's a bit slow. I'd like
one that just considers the direct parent but this is okay. And so now what this allows me to
understand is that also if I move the y, you're gonna see that only the y controls moving forward
and backwards of the character. Same with the feet, forwards and backwards. And so that is
the correct way of doing it. Let's see what could be the wrong way.
So if I have, for instance, same example, same animation, but the difference is now the root
is aligned in this way. The x goes back, the y goes that way, but the character is still running
exactly the same animation. So how is this bad? Well, if we select the same controllers that we
had selected before, we're going to select that one, that one, that one, those three here,
and then that one, shift H, right? So if I look at these controllers now and I'm going to again do
that, don't need to call it root, but root. And so now I select this. And as you can see,
x and y are pointing different places than before. Now they're not pointing towards the animation,
but against. But if we look at the animation, for instance, here, that makes sense.
Now I'm going to pick this one. And that looks like it makes sense. But if you see,
it's misaligned from the actual animation that we wanted to make. So instead of,
so if the character is running one way, now to be able to work those curves,
I need to actually counter animate the x one, which is moving it like that with the y one.
And that's why they have both a slight slant, which are combined to make that diagonal, right?
And so that is going to be a pain to polish. For instance, say now I would like this foot
to stay longer at that position. So what is the problem with that? Well, if now say I want to,
it's sliding a little bit. If I want to, for instance, make sure that it stays in that place,
not only I need to work in this axis, but also I'm going to need to work in this axis as well
to compensate. And so that they're more or less same here with the, with this. Now,
this is actually making my life a bit of a mess. So let's try to get rid of that slide, right?
And so what, what's going to happen here is that I'm going to grab all of these guys here and
where is my active, oopsie, right? So that aligned them all, but, but that only did it in the x-axis.
And so now I need to go to the y-axis. Select that one last. Now the foot stays on the ground,
but I had to compensate both. If I go back to my other, to the correct route,
you're going to see that in the same moment where the foot is sliding, because it's sliding
in this direction back and forth, right? You can see that the x-axis it's pretty much like
non-existent, like besides the fact that it moves out, the x-axis is pretty much flat.
But then if I go to the y-axis, make sure that this is all aligned, these guys,
it's a matter of selecting that one. And then there we go. And so now it doesn't slide anymore.
And so what the important thing about placing the root control is that you will be able to
do less work in the end. It's easier on the brain because when it's not correctly aligned,
more often than not, we'll have to polish two different curves that are trying to make one move.
So in this case, Y and X are trying to make a diagonal on their own when it could easily be
either Y or either X. And so that's why it's so important to put it in the right place.
And so let's go to the wrong one, this one, and let's try to fix it because there must be a way.
The problem with fixing it, which is very often, is that if I move this in any way,
then I'm screwed because it's moving the entire animation and I want the animation to stay
and be able to realign. So what I'll do is I'm going to do a technique which is called baking
to locators or empties in this case. And so I'm going to just hide a bunch of this stuff here.
Too much ----. I'm going to delete all of this because I don't think I need it
just to clean up my scene a little bit. Right. And good. So I'm going to create a new collection.
Thank you. I'm going to call it locators or empties. So I'm going to create empties. I'm
going to transfer the animation of those empties and then I'm going to bring them back. Why do I
want to do this? Because the empties are not going to be linked to this controller. Basically, what
we have right now is a hierarchy where this guy is a parent and these three guys here and these
two guys here are children of it. And so if we create those locators and constrain those controllers
to those locators, then they'll stay in world space. And so then we're breaking that connection
from the root controller. Then we can move that controller without affecting our animation.
And then once we're set it where we want it, we can bring the animation back and then
the animation will realign those axes correctly. So let's see how it's done.
So root controller, as I said, and all of these guys that we want to change their animation.
Right. As we can see, this is the right file where X and Y are in a weird way. So I'm just
going to take this guy away again. Let's call it root. So if I look at the root axis, this is the
one where we're compensating both axis, axis, access, access. Right. And so I'm going to create
several empties. Empty number one. I wish there was colors for the empties that you could just
run like a color to each one of them. In any case, I'm going to call this guy foot L.
Let's do it more blendery dot L. Duplicate it again. Foot dot R. Duplicate it again. Root torso.
Then what's this guy? Pole vector dot L. Pole vector dot R. There we go. And so with all of this,
I'm going to place them and match them to each of the controllers that they need to. We're going to
select one of them first, and we're going to add a constraint, copy transforms and target the armature.
Right. And so because we targeted the armature, then we need to select the bone. Once you do that,
you're going to select all of the other ones and then keep that one as the active one. I'm going to
copy constraints to selected objects. And so now all go to that same position because they're all
copying the transform of the armature, which is still at zero. But now change the name of the
bone target. And so we want foot dot foot IK dot L. Then we go to the second one, foot IK dot R.
We go to the pole target. I think it's target. Knee target L. And then
knee target R. And then we go and pick the last one and go towards.
So now what we have, it's basically all these empties that we cannot move because they're
constrained. And if we can see the animation, you can see that they're following each one of
the controllers, right? They're following each one of the controllers. And so now we can select
these ones again and we can bake the animation to those controllers. So I'm going to press F3,
bake action, or you can go to object animation, bake action, which will get you this menu.
What we really want to do is because the animation is already a loop, we just want to do the entire
loop, which is 16 frames. We don't have smart baking yet, but it's on the way. So we'll keep it
to step of one. So we don't lose any animation. We're going to do visual keying because we want
these objects to keep the animation in the world space. We want to clear the constraints. So it
gets rid of the constraints. And that should be it. That should be good. So we're going to
press okay. And as you can see, now we got this animation baked in the controllers. So if I move
around the character, these guys still stay animated the same way, right? As if they were
constrained. So now they have the animation. So now what we want to do is do it backwards. Now we want
to constrain the original bones to those empties. For that, we're going to do a similar thing
that we did before. We're going to select all these guys, right? I'm going to add a constraint
to one of them. Constraint, copy transforms. And I'm actually going to copy that to all of them.
And now we'll pick one by one the one we want to add the target we need. So this guy is the torso.
I'm going to go torso. And then this guy needs the foot R, foot R. This guy needs foot L. This guy
needs pole vector L. And then this guy needs pole vector R. So now I cannot move any of those
controllers. But if I go back to object mode and move any of the empties, you can see that I'm
actually moving the controllers through the empties. So far so good. We're getting there.
And so, as you can see that now that we can control all of each one of these controllers
with the empties, we can select the root of the armature and move it around without modifying
anything in the animation. And so this will allow us to realign it to where we want.
So I can, for instance, put it there. So now, considering the fact that we wanted before,
I'm going to change this to local. And I'm going to look at it from the top and say, well,
I want the character's trajectory to be Y and the side to side to be X. So that will make my life
much easier. So I'm just going to rotate this and then place it somewhere that makes sense.
I'm going to just do frame zero. I think I'm going to put it there just below the character.
And let's look at our rotations. And as you can see, the rotation has nothing to do where it
was before. I'm going to do this. If it's not perfect, it's not a big deal because there's
always going to be a little bit of that counter interaction between the two axes. That's a given.
But the closer it is, the better it's going to be for you. The easier it's going to be to handle.
So now, now I'll bake it back. So I'm going to select those controllers, deselect this guy
because I don't need that guy. And now I'm going to again, go to my bake again to 16 frames,
only selected bones, visual keying, clear constraints, override current action,
which is basically keeping the animation in the current animation action. Because if you don't
override it, what it will do is it will create a new action and it will be separate from what
you have, which we don't want. And in this case, we want to bake the data of the pose,
not the objects. So, okay. So we get the same animation. So as you can see,
now we have this animation. And if I select the controller, I'm going to check this one and go
give me the route, actually the route I already have, but that it's the route at that moment in
time. So you need to make it again then. So it doesn't stay connected to that route.
And now that new one, as you can see, X points in this case, forward and Y sideways, instead of what
I said that I wanted to do. But as you can see now, when this one moves forward and it goes in a
straight line and then the feet again, just move, stop, move, stop, move, stop, and so on.
Right. Let's fix it again. I'll just undo until we're back to, with our constraints, I think.
Nope. Okay. We have our constraints back now, right? So I'm going to move this guy again.
I'm going to rotate it 90 degrees and we're going to get minus X. Wait, we want to look at the local.
Yes. That's what we want. I think that's the best way in this case.
Yeah, something like so. And so the direction which my character is going should be pointed by
the Y axis. Yeah, that seems to be it. So it doesn't matter that the animation doesn't continue
doing things correctly because we're only focusing in the part that has the cycle, which then will be
cycled with offset. So it's okay. We just want the live key frames. Those are the ones that we care
about in this case. If it wasn't the case and you have like a full on animation, then you'll do it
for the entire animation, the baking and everything. So now that I have it in the right place, I'm going
to select them all. I'm going to unselect this guy here, bake action, 16 frames. This should kind
of remember what I did last and the rest of it. It's okay. Boom. So now you can see it goes forward.
I can select my controller, look at the root one. Again, the root is not connected to this. So I'm
going to delete that guy, create it again and change this too. So this is a flaw. I would love to
get fixed. Well, the root sounds like a, like a Dutch option. Take a look at the root. In any case,
now, if you look at the root, you have that X and Y. And then if you select this guy here
and look at the Y, the Y is the one moving forward and the X is the one moving sideways.
I know it's a complex process. And so to dumb it down, if your root is wrong,
what you want to do is select all of the controllers that are free floating in space,
directly connected to the root, like the torso. If you have IK hands, the IK hands, in this case,
the hands are FK. So there's no point in doing that. The IK feet normally, the pole vectors,
if they're working on their own as well, and you want to create one locator, you want to create
one empty for each one of them and constrain the empty to each one of them. Once you have all of
the constraints, you bake the animation to those empties and get rid of the constraint that they
have towards the armature, leaving the empties in the space floating around basically with the
animation on their own. Then you constrain the original controllers of bones to those empties.
So now those empties drive them, and that will free those controllers from the root bone or the
root controller. So you can now move freely that root bone around and decide where you want to
place it. Even if you want to animate that one, that is completely possible. Ideally, don't animate
it. And so once you place it where you want it, then you select the bones that are constrained
and bake the action, and then you get the animation back where it was with the correct
orientation of their axis. So yeah, it's not too long of a process, and Adam would make this way,
faster, and I know somebody that's making one of those. And so we'll hopefully get that around to
show you soon. I hope this helps you in your productions in those painful days where everything
is oriented the wrong way, and now you can reorient it so it's less painful to polish animation.
And if you enjoyed this video, like, subscribe, and see me next time!