---

0:00
In this video, I'm going to talk about some of the recent changes in Unreal Engine 5.6, uh, particularly when it
0:05
comes to control rig. And you've probably seen some things about these features, but I'm going to give you my take on it and some different
0:11
applications of it that you might not have thought of or you might have used it for. So, first thing we need to do is
0:16
if you go to edit plugins, you want to enable what is it? Physics control. So, make
0:23
sure that's ticked. And locomotic
0:28
as well. So in the meshes folder and this is just a third person template but you can use
0:34
third first person template as well. In the meshes folder I'm just going to right click on the SKM man simple. Go to
0:40
create control rig. Open this up. Now what we're going to look at first is
0:46
physics within control rig. So to do that or to enable physics on the
0:52
construction event what we're going to do is we're going to bring in the physics asset. So the
0:59
default mannequin has a physics asset. If you go to the rigs folder, you'll see PA mannequin. If you open this up,
1:06
you'll see the physics asset. So if you simulate, he falls down. So this is basically just proxy meshes
1:12
that sort of approximate the underlying shape of the mesh, but they simplified so that it can run physics simulation on
1:18
it. And basically these are we call them physics bodies and they're connected by
1:24
joints which have constraints. So, for example, the elbow can only move like
1:30
like this angle. So, it can't bend backwards. So, when it
1:35
simulates, you get some kind of realistic mo motion falling down. If you
1:40
hold control and right click, you can drag the guy around. Anyway, so we want to pull this into control rig. So, on
1:47
construction, we're going to search for instantiate from physics asset.
1:53
Connect that to the construction event. And then the physics asset, we need to
2:00
select that. And if you have the mannequin from whatever template you're in, you should also have the PA
2:05
mannequin. So just click on that, compile. And there it goes away. And now what we want to do is tell it to
2:11
actually make all the physics bodies simulate. So we're going to drag out from the physics body component keys and
2:18
do for each. Connect the execution path. For each element, we're going to drag
2:23
out and search for mode. And it's set physics body movement mode. So we select
2:29
that, connect it up to the execution movement type simulated. So now all of
2:35
the bones or all of the bodies, the physics bodies are simulated. But we're not seeing anything happen yet. And
2:41
that's because we need a physics solver. And we need to also tell the physics solver to run in the forward solve. So,
2:48
what I'm going to do is right click on the route, go to new component, and then the bottom one, add rig physics solver
2:55
component, and you'll see this physics solver gets created. And still nothing's happening. But what we need to do on
3:01
forward solve is if you right click, you can do step physics solver. This just
3:07
tells the physics solver to do the next calculation. So, the next step, and just to do something. So, what we're going to
3:14
do is drop down physics or component key item because I right clicked on root. This is a child of the root. So, I'm
3:21
just going to search for the root bone. And now you see that the character just falls through the floor.
3:27
And that's because all of the bones are being simulated and there's no collision with this. This
3:33
is just for visualization. So, there's no actual floor there. So, when you click compile, you just see him fall
3:39
straight down because of gravity. So, what I'm going to do now is just make one bone. And I think I'll use the
3:46
pelvis. I'm going to make that not simulate. So, this is looping through all of the bodies and setting them to
3:52
simulate. What we could do is check what the body is and exclude the pelvis, but
3:58
that's more difficult. So, what I'm going to do is copy this node, paste it here on complete.
4:03
And the item, I'm just going to manually say pelvis. Movement type is kinematic. So, it
4:10
freaks out a bit until we click compile, but you'll see that he's dragged down around except the
4:16
pelvis is locked in place. And these visualizations are a bit much. It's quite difficult to see. So, on the step
4:22
physics over, if you go to visualization settings, I'm just going to turn the line thickness down to 0.1. So, we can
4:28
still see them. Maybe you can't on the video, but um yeah. So, this is just essentially a
4:35
full ragd doll except for the pelvis. He's not trying to retain the original pose at all. He's just falling as if we
4:42
simulated on the physics asset. So if we just did this, except if the pelvis was held in place.
4:49
So what we're going to do now is make it so that the joints retain some kind of rigidity or strength to try and orient
4:56
towards the position they're trying to be in. So the way we're going to do that is we're going to drag out from the physics joint component keys. So this is
5:04
for the body. So the body component keys. And now we're going to do it for the joints. So drag out from this and do
5:09
for each. And what I'm going to do is it's it should be after the complete, but rather
5:15
than just connecting it like this for simplicity, I'm going to add a sequence here. So it does this first because we
5:21
might add some more stuff to this. And then on B, it comes down and does this for each loop.
5:27
So for each one of these joint component keys,
5:32
what we're going to do is drag out from this. And I'll just search physics cuz I forget what it's actually called that
5:38
I'm looking for. We're going to go with set physics joint drive properties and
5:45
connect the execution path. So what you can do is you can manually enter some things in the drive data. So
5:52
the linear drive constraint, angular drive constraint, so on whatever all that is. Or you can
5:58
right click and do make articulation drive data.
6:03
So this is basically just making something that can be plugged into there. So it's just making that strct.
6:09
So I'm going to plug that in. You can see he's moving a little bit differently now. I'm going to change the
6:14
angular strength. So I'll make it low first. So now he's just flopping around completely dead. And then I'll change it
6:20
up to 500. So now he's got some strength to retain the position that he started in. And you can play around with these
6:28
values to try and get something that's matching what you're going for. So the higher the number of the angular
6:34
strength, the more it's going to match the original pose. Whereas if we go to lower numbers, it's weaker.
6:42
So I'll just set this to 100 for now. And what I'll do is I'm going to show
6:49
you what it looks like when the character is actually getting dragged around or moved around. So a simple way to do that, I'm just going to search for
6:57
the pelvis, create a control. So, new element, new control, and then we're going to right
7:03
click constraint. So, we do a parent constraint, connect the execution path.
7:10
So, the child, that's the thing that's being controlled is going to be the pelvis. So, we just select pelvis. And
7:16
the parents, there's already an entry there. So, on zero, the item is going to be a control, and it's going to be our
7:22
pelvis control. So, now if we move our pelvis control, so I've just got that selected still in the rig hierarchy. If
7:29
we move that around, it's just dragging the character around. And because the pelvis is being set to
7:34
kinematic rather than simulated, it means that it will follow the exact position that it should be in. So
7:40
wherever it's getting moved to, it's exactly matching to that. So that's being moved around by this parent
7:46
constraint to the control. It's exactly matching that and then it's solving the physics.
7:52
And we can do this for more bones. And I'm going to just quickly go through that because the next thing I'm going to show you is combining it with the full
7:59
body IK node where we will be using additional bones for that. So what I'll
8:04
do is I've got the pelvis as kinematic. I'm just going to copy and paste that. And I might even remove the pelvis so
8:10
the pelvis isn't kinematic. So what I'll use is hand_r.
8:16
Copy paste hand L. You can see that the hands are
8:22
now locked in place, but the rest of the body isn't. So, he's doing some dips or something. Uh, I'll do the same for the
8:29
feet. So, I'll just copy and paste these two. I'll do foot L
8:37
foot R. So, now you can see that he's kind of retaining his original pause and it's
8:45
not just the default pause or the skeletal meshes pause. what this is whatever is being passed into control
8:51
rig. So just an example on the preview settings on the right. We can tell it to use a specific animation rather than
8:57
just the default reference pose. So I'll just search for walk. So we'll do a walk
9:03
forward. So you can see that it's still doing the physics. You can see his head's bobbing around all over the place,
9:10
but that's because we've set it to. So I'll just turn off the physics sim just so you can see. So this is just the default. But then when we do the parent
9:17
constraint where we've got control over the pelvis and then we're doing the physics solve, you can see things start
9:23
getting wobbly. And maybe what I'll do is I'll make his head kinematic as well.
9:31
No, I'll make his pelvis kinematic. Let's see what that's like.
9:36
Oh, but that's also we've got the parent constraint, so that's locking it in place. Okay. So now the pelvis is
9:44
kinematic and the feet and the hands are and that's starting to look
9:49
more normal. It looks like it basically matches the animation. Maybe his head's bobbing around a bit more than it would
9:54
be, but otherwise it's not too far off the original animation.
10:00
So now what I'm going to do is show you essentially how you can move parts of
10:06
the character around and it will solve it based on that. So, I'm just going to turn off this animation for now for the
10:12
next thing I'm going to show. So, I'll just do reference pause. So, he's just back to normal.
10:18
What I'm going to do is make a control just for his right hand at the moment.
10:24
So, hand R new control and we're just going to do the same as this parent
10:30
constraint. So, I'll just replace this. So, instead of the pelvis,
10:35
I'm going to use the hand R. That's what's being controlled and that's being controlled by the hand eye control.
10:42
So now you'll see that this is dragging around and this is without any full body IK node or any solve like that. It's
10:48
moving the hand kinematically and the rest of the body is sort of figuring itself out based on the physics and this
10:54
is pretty good. It it's it kind of works but you'll notice that you get some
11:01
weird sort of angles and and weird movements. So, so a simple way to test this, if I drag this out far, you'll see
11:08
that it's stretching his hand. And even when it's close, sometimes it can get to some weird angles and it'll look kind of
11:14
stretched out and odd. So, like that, for example. So, this
11:21
isn't an ideal way to control a character. it it happens to work because it's physically simulating it and you've
11:27
got the kinematic controls moving the character around or moving specific bones, but this isn't the way that you
11:33
should be doing things. So, what I like to do is combine this with a full body arc node before we do the physics solve.
11:41
So, you can do either before and after, you can do just after, whichever you want. So, what I'm going to do is show
11:47
you that. So, we don't need this parent constraint anymore. Just skip over that. So, I'm just going to create a control
11:52
for all of the kinematic elements. So, we've got the hands, the feet, and the pelvis. So, we've already done hand R.
12:00
We'll do hand L. Okay, that was strange. It's minimized
12:05
for some reason. I thought he's lost a hand. Uh, we do new element, new control. So, we've got his right hand
12:11
control and then we want foot R. We want foot R and foot L.
12:17
So the foot R we do new element new control foot L new element new control. So I've
12:25
got these controls for the limbs and I'm just going to do one for the pelvis as
12:31
well. Do we still Oh, we've already got one for the pelvis, right? Okay. So instead of this parent constraint before
12:37
the physics solver, what I'm going to do is plug it into a full body IK node.
12:45
So we'll say the root. Let's just use a pelvis as the root. So the aector we're
12:50
going to want actually I use root for this and then we'll do
12:57
one for the pelvis. Two three four five.
13:05
So the first one set to pelvis. Now we'll bring in our pelvis control. just
13:10
plug in the transform. So now our pelvis control is
13:16
controlling where the pelvis is according to the full body IK node. Uh now I'll do the hand R
13:26
and R control get control plug in the transform and L
13:33
get the control plug in the transform
13:38
foot L get the control plug in the transform
13:48
R the the control transform. Okay, so now he's being controlled with all our
13:54
controls using the full body IK node. And I'll just unhook the physics over just so you can see that that's still
14:00
doing what it should be. So you can see that I'm moving the arm around. This is just a regular full body IK node.
14:07
There's no wobbling going on because there's no physics happening here. Some weirdness there because just how this
14:14
works when when you've got the pelvis. Um, but I could remove the pelvis from
14:19
the full body IK node and we probably get better results. But for the sake of just demonstrating, I don't need to do that. So now I'm going to have after the
14:26
full body IK node. It's going to do the physics solve. You can see there's some motion now. And when you drag around,
14:32
it's still solving with the full body IK node first. So you're not getting those weird angles anymore.
14:41
Although you still will be able to get some stretching if you do some crazy stuff. But you can see that it's limited
14:47
by what the full body IK node's doing because we're not directly parenting
14:52
this hand to this point. We're just telling it to try to reach this point using the FBIK solver.
14:59
So what you've got here now is you've got controls where you can move the
15:05
character around and animate them or you could move these procedurally if you wanted to. But it's also got the physics
15:12
applied as well. So, when you move things around, the character is jiggling around due to
15:18
the physics. Now, what I would probably recommend is checking out my other video
15:24
on subchains because the full body IK node works a lot better when you enable subchains. Um, so to do that, let's just
15:31
do sub iterations 20. And just an example. So, I'll do it for
15:37
the hand R. So currently the handle looks like this
15:42
where I move it and you'll see his whole body is sort of dragging around no matter how small the movement. But
15:48
because we've put the sub iterations on, if I set the chain depth to two, you'll see that when I move the hand around,
15:54
it's only controlling the hand until it can't do that anymore. So it's just moving the hand. And then when it goes
16:00
too far, that's when the body starts to kick in and help out with the movement.
16:05
So you can do that for the feet as well. and the obviously the other hands and so on. And what you could do is basically
16:12
use a full body arc node, make some controls. So you've got the head, maybe the hands, maybe get rid of the pelvis
16:17
or include the pelvis, whatever you want. And then you go through the physics solver. And you could use this
16:24
as sort of like a way to animate whilst still having some realism from physics, whether it's procedurally or you just
16:30
bring this into sequencer. So if you just brought this into sequencer now, you'd be able to animate this in sequencer, just moving these controls
16:36
around, but it' still be doing the wobbling stuff. And when you bake the animation, it'll still have that wobbling. So I mean, it's somewhat
16:42
similar to something like cascad cascad, I don't know how you pronounce that, but
16:48
whatever that animation program is where it's got some physics sim going on it, it's kind of like a basic version of
16:54
what that's can do. Um, and you could obviously take it further than just this
16:59
sort of basic setup. So, that's something useful and interesting and it's something worth
17:06
playing around with even if you only use it in small amounts. So, so you might have most of the bones kinematic, but
17:11
you might still want, for example, his shoulders just to wobble around when he moves or maybe some of his head to move
17:17
around. And if you find that it's a little bit too wacky, like you know, his head's
17:22
wobbling all over the place and you can't set the strength high enough to make it actually not look awful,
17:30
then what you can do is when you're doing this step physics solver, you can change the alpha. So this is at one, so
17:36
it's just fully doing the simulations it wants to. If I change it down to like 0.1, it's basically not doing anything
17:43
at all. Now, if you can still see the visualization, so the yellow version,
17:48
you can still see that it's doing it, but we're only blending like 10% of that to the actual character. So, I'll just
17:54
do 0.5 just so you can still see that it is actually physics simulated, but reduced.
18:01
You can see there's some physics going on. It's not as obvious. I'll go down to 2.5 uh 0.25, sorry. So,
18:10
now we get a little bit of physics. And I'll just turn the visualization off now. So, drag it around. You see there's
18:15
still some wobble to his head. I'll just make this bigger just so you can see this clearly.
18:21
I think you probably get the idea now, but just so you can see some use of it.
18:27
So, you can see that is physically simulated. And this is a better example on the the
18:32
right arm because that's where we've got subchains on. So, you can see that you get some realistic motion because you've
18:37
got just a layer of physics. And whether you're doing procedural animation or key framed or whatever you're doing, it
18:44
might be useful to always just have some level of physics in just so when the character moves around in some weird
18:50
unexpected way, you get a little bit of jiggling, bit of motion. So that's a basic example of how you can combine
18:57
physics with something like the full body arc node or use it in an animation workflow or a procedural animation
19:02
workflow. What I'm going to look at next is not just using the bodies that we've
19:08
already created. So the ones that we did from the instantiate from physics asset where it copied in all the bodies. I'll
19:14
show you how you can just add your own physics body. So you could just add a cube or a capsule or whatever you want.
19:20
So what I'll do is select the root, right click, new component. You can do add rig physics body component.
19:28
Compile. And what this is doing, if we go if you click on the physics body and we go to
19:34
the details panel, you'll see that by default there's a capsule with some size
19:40
to it. What I'll do is I'll turn on the visualization. So on the step physics over, turn visualization back on. And
19:47
for now, I'll just turn the line thickness up so you can see it. So when I compile, you'll see there's a uh capsule that just spawns and falls down.
19:55
So the reason it's doing that is because it's kind of spawning inside the character. at some random point and
20:01
intersecting and then just being being fired away because it's being simulated. But what you can do is you can set this
20:07
physics body to be kinematic rather than simulated. So it won't be bouncing
20:12
around with physics or move flying around, let's say. It will be wherever you set it to. So you'll just be able to
20:18
move it manually. So, the first step to doing that, when you've got the physics body selected, if you go to body data,
20:26
movement type, you can change that to kinematic. And and now you can see that he's uh
20:33
he's straddling the invisible capsule. So, because his legs are being
20:40
simulated, you'll see that the they sort of trying to be where the capsule is, and it's
20:45
pushing them away. If we move these controls, it'll it's going to Yeah. So, some weird things are going on here. Um,
20:54
not entirely sure why this capsule is connected to the
20:59
pelvis. Pretty sure it should be the root, but
21:04
let's let's just Can I unparent it? Okay.
21:11
Right. Okay. So, I don't understand what's happening there. If anyone knows, let me know in the comments. But for
21:17
some reason, this capsule is uh well, he's slanging it around, let's say. I don't know why. Um, okay. So, what we're
21:26
going to do is we're going to manually move this capsule. Okay. So, to move the physics body
21:32
around, we're going to do right click and search for set kinematic. So, we've
21:37
got set physics body kinematic target. I'll just connect this in.
21:44
So, the physics body, the item is going to be
21:50
physics body, I think. I think that's correct. Yep. I'll just rename it just so it's clear.
21:56
I re name this to captur
22:07
physics body kinematic target. I'll do it again. Still saying physics body.
22:21
Okay. So, I needed to set the root as the bone. And then under the name, I can
22:27
set capsule, which is what I've just got there. So, now if I plug in a target, so
22:33
transform, it will move this capsule to that transform. So, the way I'll do this
22:38
is I'll just make another control. So just do a new control and this one is going to be called
22:46
rename this to capsule control.
22:52
Drag it in. Get control. Plug the transform into the kinematic target. Compile.
22:59
And now when I move the capsule control, you can see that the capsule is moving around and it can bump into the legs,
23:07
bump into the head. Bonk, bonk, bonk. So, what you could use this for is, for
23:15
example, if you wanted some hit reactions, you could do it within
23:20
control rig where you just move this through the character or pass a character to get it to hit him. Or you
23:27
could map this to something that's in the world where he'll interact with it.
23:32
Ideally, what will happen soon is they'll make this physics simulation that's working in control rig. They'll
23:37
make that also have world collision so that when it's just in the level, the guy can just bump into walls, things
23:43
like that, and it will interact with it. At the moment, I think you have to do that through blueprints and add a
23:48
physics control component to the actual character rather than allowing control rig to do it. But from what I've heard
23:53
on Twitter or X or whatever, it seems like they planning to do that and they're intending to do that. But that's
23:59
obviously no promise and you know they may not be certain themselves if they'll ever do that. But for whatever reason at
24:05
the moment the collision only works sort of internally within control rig and not with the world as far as I know. So what
24:12
you can do is you can kind of fake it by bringing in objects or just the position of objects and having them emulated in
24:19
control rig to add the physics. Another thing that you could do is if this was instead of being a capsule, if it was a
24:26
cube, you could put this on the floor and then rather than having some
24:31
kinematic targets, you could just have him fully simulated and what you do is fall down and ragd doll onto the floor.
24:38
Um, so there's various things that you could use this for and I'm not going to give you too many examples of it. Just
24:43
wanted to show how you can set this up. And you will notice that because we've got these kinematic targets that are
24:50
going to be there no matter what. These are definitely going to be in the position that we set them to. It can
24:55
cause some weirdness when we've got this. So, for example, if I put that there, the hand is forced to be here,
25:01
but there's no way physically that that the arm can reach it because this capsule's in the way. So, you can get
25:07
weirdness with that. It wouldn't be a problem if there was no kinematic targets, but in this case, there is. So,
25:13
we get the weirdness. So you can probably see it better if I
25:18
turn off the visualizations in the step solver. If I just move this control around, you'll see that the invisible
25:25
capsules hitting the character. And you'll see that I can make it go
25:31
weird. If I put it near the pelvis, you'll see that
25:36
it has to kind of solve around it whilst keeping the pelvis in place. So weird things can happen.
25:45
So yeah, you get the idea. And one thing that you could do is you
25:50
could do traces. So you can do world traces within control rig. So if we just
25:55
do sphere trace by trace channel, this can trace and hit things in the world.
26:02
So what you could do is you could make something like a capsule like we've got here. If I turn the visualization on. So
26:08
we've got this capsule. You can make it a cube, whatever shape you want or a sphere or something. But what you could
26:15
do is you could do a trace. So you do a trace above the character and then you could use that as sort of
26:22
something to make sure that he ducks under things. So he's like bending down because there's something above. And I'm
26:28
not sure exactly how you do that, but what you could do is you could do multiple traces. So you could have things at one side so it's pushing his
26:33
arm in if he starts to walk past a wall on his left side or on his right side. The easiest way to do this would just be
26:39
through blueprint and adding the physics control component and figuring that out. And I don't have any videos on that, but
26:44
you can find those. So, if you just search for physics control on YouTube, you'll find some videos on how to use that. But yeah, so don't forget that you
26:52
can do traces to find out where things are in the world and then bring that into control rig. Now, we're going to
26:58
take a look at the locomot. So, once again, make sure in plugins you've got that enabled. So you search for locomot
27:05
then restart the editor. So what this does is basically it generates steps for you. So the character can step and move
27:12
towards a target point. So you've got a target point which has to be a control. You'll move the control around and he'll
27:18
try to walk towards that. So I'll just show you what it looks like and you've probably seen this before but again
27:24
you've not heard me talk about it. So locomot plug that into the execution path. root control is going to be in my
27:31
case I'll just use capture control because that's in the right place. So it's trying to move towards this target.
27:38
So what we want is to add a new foot set and within the foot set then we're going to add two feet. So the ankle bone is
27:46
essentially the footbone we're going to select. Make sure you're on type bone.
27:51
We'll do foot R first. You can see that one foot's trying to move. And then the
27:57
ankle bone for one. Make sure it's set to bone. This is going to be foot L.
28:03
Okay. So, when we move this control, you can see that it's trying to solve for
28:09
where the feet should go to reach this target. Nothing's happening with the actual
28:14
character because we have to do that manually. We have to basically tell the character to move his feet towards these
28:19
points. All this is doing is generating some transforms for us to use. So, it's it's outputting these feet transforms,
28:25
which is an array, and it's in the same order. So it will be this one first and then this. So it be foot R then foot L
28:30
which will be important when we start applying it to the character. So for this you could plug this into a basic IK
28:36
node to control the feet or you could plug it into whatever you want. But in this case I'm going to use a full body
28:42
IK node just to make it simpler. So we plug into a full body IK node. I'll set the route to pelvis
28:49
andectors. I'm going to add two. So remember the order matters here. So we want foot R and then foot L. I mean
28:58
technically the order doesn't matter in this but when I'm going to do this if drag out from the feet transforms do at
29:04
I'm going to put zero into the top one. So the order does matter that it needs to be foot R there. So you can see that he's already moving with one foot.
29:12
Then drag out again do at this going to be index one. Put this transform into the transform that goes into foot L. And
29:18
you can see now that when I move the capsule control, he's walking around.
29:24
And he's walking like he's himself, but he's still moving around. So what I'm going to do is firstly we'll
29:32
on the settings I'll do pin to input. So now the pelvis is pinned to the input.
29:38
What you'll see here is that his feet are trying to move, but his pelvis isn't moving at all. So within the locomotive
29:45
node, you'll see the pelvis drop down. If we tell it what the pelvis bone is, the locomotive node itself will be
29:52
updating the pelvis position. So we just tell it that it's pelvis. And now you can see that it's moving the character.
30:00
So this node is moving the pelvis and then this is moving the feet from the
30:05
output feet transforms. So now it'll just move towards this target point. And
30:11
you can see that he's making very small steps. So to adjust that to make him able to
30:17
make longer steps, there's a movement drop down here. So we've got the speed max, speed min. Let's say the speed max,
30:24
we'll change that to 150. So now he's able to make longer steps.
30:30
And I'll turn it up even more. We'll go to 350 as the maximum.
30:35
So now you can make quite long steps. We've got the phase speed, max, and min.
30:40
And I've not played around with this too much, so I'm kind of just testing it myself here.
30:46
So, I'll try changing that higher.
30:51
So, now he seems to be taking steps more frequently or at least able to. I think the acceleration is just how
30:58
fast it'll take to get up to the initial speed that he's moving at. But you can see it's moving around. So, currently
31:05
the locomotive node is quite simple. It's good to get something going. So, if you just need to get something moving,
31:11
you can just quite easily set this up with however many legs you want or how however many feet you want to control. I
31:18
don't think it's currently great for procedural animation at runtime. And the
31:23
main reason for that is firstly because it's quite simple. It's just outputting the feet transforms and you can't really
31:29
see much under the hood. It's a little bit difficult to control. So, you can't
31:34
do exactly what you want to do. Like if you had a custom setup like I've shown before how to make on this channel or in
31:40
my courses, you can tweak every little thing that you want. So how the legs rotate, the exact path that they take
31:46
when they interpolate from one place to another and so on. There's a lot more that you could do if you do it manually.
31:52
And the other main issue with this is currently this is basically in rig space
31:57
it's targeting this capsule control. So wherever we move this to he walks towards it. I'd prefer a version that
32:03
was inversed where it's wherever the character moves the feet compensate for. So if the character's in the level
32:09
moving this way or whatever he's just moving some direction, the feet will be
32:15
walking based on how fast he's moving, but it's not trying to target a specific point. So currently this is just moving
32:23
towards a specific point. And you can see he's always behind that point. So where have we moved this to? He's
32:29
delayed. It takes me a while to actually get to that point. Whereas I'd rather it be more like how I set up with
32:35
procedural animations where wherever the world's moving to or however the world's moving relative to the character, the
32:41
feet are just doing what they can to compensate. So he just walks to compensate for the movement of the floor.
32:47
And internally, this seems to be doing something quite similar to what I would usually do and what would work in that
32:54
case. So, it's doing the same phasing for the feet and it's got one offset
33:00
from the other and so on. I think essentially this could work as the
33:06
inverse and I think it' be pretty good. It'd be a good starting point at least, especially if rather than just the feet
33:11
transforms being output, there was more being output that you could deal with. So if it were telling you the cycle, so
33:17
the actual phase that it's using to calculate the foot transforms, you could do a lot with that if you knew what
33:24
those were and maybe a few other things being output that are just calculated
33:30
internally just for the sake of being able to apply it in your own way in a unique way, not just in sort of a magic
33:36
black box where you can't really make any changes, but if it was outputting some of the values, the internal calculations, you could do more with
33:42
that. So, that's what I'm hoping to see at some point for the locomotive node. Um, for the time being, I'm just going
33:49
to stick with doing these manually because essentially what you could do is you could create a system where you just
33:56
make it in some separate control rig where you just make all the functions that you need or you could do it through
34:02
C++ I believe where you essentially make the equivalent of this except you'd be
34:08
able to customize it. So, what you could do is you could make your own custom solution. You could make that in just
34:13
some separate control rig and you can make the functions public so that you can access them wherever you want. So
34:19
rather than using the locomot you just use you know whatever custom locomot you just search for it and you'd have the
34:24
functionality of it. There's a few caveats to that some difficulties with
34:30
it. I think maybe doing it through C++ would be ideal. So you can just add your own node which would have internal
34:36
calculations that some variables can be persistent and so on or static or
34:41
whatever. Um, so yeah, there's different approaches. What I prefer to do is just
34:48
make a generic control rig class for procedural animations or for movement
34:53
animations and then just migrate that to different projects and modify it as I need. But it's worth checking out. It's
35:00
interesting. And try out some of the stuff with the physics cuz that's all fun playing with physics. And maybe you
35:07
could combine both. So you've got the locomot and then you could also do what we were doing before with the physics
35:12
simulation. I may have deleted too much of it for that to work at the moment. Let me just see. So construction event
35:18
we instantiate from physics da da. Okay. And then we're going to do all
35:25
this and and we'll do the physics solver. I
35:30
forgot that the capsule is still there. But yeah, you can see that. So, I've got the locomotive going on, but you can see
35:36
the physics is still being applied. And I don't know why I was showing that. I just wanted to see if it was what it
35:43
would look like, I guess.
35:48
But yeah, so that's some of the 5.6 features of Control Rig. And there's
35:54
probably some more that I've not looked at