 Thank you for coming. I'm Daniel Salazar on IRC and those geeky things. I'm a little bit sick today because of this awesome weather. So this talk is about explaining a simple technique that I'm using for the character rigs that we animate in Patas. Patas Studio is a very small studio in Costa Rica where I work with Sara. We started this about six years ago. I was more of a generalist at the time. I thought I'd like it to do everything. I guess lots of us start like that. We can pick something that we like the most so we just think we are going to be great at everything. This is the first thing we did. We still like it very much. It's a simple but probably means a lot to us. No sound, sorry. You've probably seen it already. Just to show the kind of style that we were developing from the beginning. Very cartoony. Lots of herbs. You can see the head. I don't think there's a straight line anywhere except from the background maybe. They were speaking French so you're not missing anything anyway. I don't think this one was ever released. I mean on any Blender site but this is probably newish. It's the same deal. Also interesting in this project was the need to constantly change whatever they had in their hands. Some of you might know that that is harder than it should. I want to show you a little bit of this character rigs. For example, this is the little cooker guy. I basically started doing what I knew I could do and rigged the whole body and it moved nothing special. I gave it to the animator. Then I started discovering the truth about rigging. You need to comply with lots and lots of feature requests from the animators. They are a good animator. The animator has a vision and he makes drawings and sketches. You somehow need to be able to produce that. For me, this was actually the first time that I made a rig for somebody else. She started to ask for things. For example, we decided to render the scene in an orthogonal camera which is weird but it worked nicely and allowed for weird tricks. For example, there is a scene here. You can see in lots of scenes from the shot that nothing makes sense except for when you look from the camera point of view. He is standing maybe half in between the table and then I look at him. He is mixing air because the pot is over here. It was funny but when you look at it from the correct angle, you never saw it. The first thing that we needed for this is stretchy arms and limbs. For these shots, we didn't do stretchy legs because they were always below the table. We didn't see them much but the limbs needed to be stretchy. The first thing that maybe some of us think about stretchy is using the stretchy tools in Blender. Big mistake. This is a stretchy tool, a stretchy IK in Blender. Add the inverse kinematics and then there's a couple of bone parameters with stretchy values. In the firm, I think, yep, the stiffness thing. You added almost one stiffness, which means it will have just a little stretchiness but here too. Something like that. I don't want to lose time. If you configure it correctly, basically you kind of have an IK behavior but when it reaches the maximum angle of the arms, it starts to stretch and that is completely useless because when do you need a character that has very long arms but only in this position? Only if you wanted to reach for the door at five meters of distance. That's not a stretch IK behavior. So what we did at the time is that I started trying different approaches. So this guy has an IK arm, like you can see, and I can scale the individual. This has a book. This rig is horrible because the first time I did this kind of stuff, so there's many problems. Basically, you could scale each segment, the arm and the forearm and ideally also the leg and the below and above the knee. Basically, you can define exactly the length of each segment and then the IK behavior still works. So you have a bent arm with IK behavior no matter how long it is. Also, another difference is that maybe as rigors we think it would be a great idea to preserve the volume because it's physically correct. When I'm doing a stretchy, then I shrink the girth of the arm or when I'm making it smaller, I'm making it better. But that is not correct. I mean we can add that functionality to control the girth of the arms and everything, but that should not be the default because we were using this to trick poses. So if I go back to here, you will see that this guy has very little arms. They don't even allow him to reach or the front of his belly, but that's what worked in the design phase. So that is the purpose of a stretchy. It's like allowing stuff that looks good, but is totally not physically correct. So if Sara did a pose like this, like she was cooking something, then the arm needs to grow like two or three times, but you don't notice. That's the purpose. It's growing all the time. Guy here has a long hand, etc. Next, there were more requests. For example, if you remember the shirts, we had plenty of deformation in the head and curvy, bendy things. In this rig, that was totally hackish because it's not so nice if you build a rig thinking that you have it all solved and then you have to add stuff on top. Ideally, everything has to be taught from the designing stage. So that was really a problem, but this is the simple UI. So I had to add a couple of top level deformations, for example, the bendiness, the rotation, and the squash and stretch for the head. But since the rig wasn't designed for this at the very beginning, you can see annoyances like now the bone controls do not fit anymore. They are left away from the deformation and you have to kind of animate blindly. It feels like a remote control of something else, weird, but we managed. Before leaving this rig file, I just wanted to show you something cool, which has nothing to do with spreadsheet, but I told you that we had lots of interchanging objects in the hands. So there are at least two ways of doing that. One is using childoff constraints with trying to imitate what parenting does, but it can be switched from one to another. Now there is a script called dynamic parent, which you should probably check out if you haven't. It's very useful and it uses that approach, but we had so many props. I don't think I can see them here, but it's okay. But we tested something different and the rig, the character file has a very small empty here. Do you see it? That empty is a duplicator and it has one for the left and right. So this model, this object has duply group enabled, but it has no group accessible yet. So the UI script defines an enum property, which is something that you use to select between different options in a drop-down menu. And this now can be accessed in the Python UI. You define this and these are all the props that belong to these enum properties. This number was also added for this project, this capability, because before the enum properties, of course, they needed to be animated. For example, left will hold the fork. Now it's there. Is it? Or now it will hold the spatula, but it will be animated, which was great. Or the cutting board. And you had this, oops, this bone that you could, this one, orient and position it to fix the offset in between different objects. So all this can be animated, but Campbell I think added a feature to add a specific ID so that if you change this list later, it won't offset the animation because this goes to a curve that goes from zero to, in steps like zero, one, two, three. And each of those are related to the list in order of, in natural order. But now, if we wanted to add something else, everything changed. So with these numbers now it's fixed. And we have a stable animation capability. That was cool. Okay. So these techniques, simplified them actually. It's cool to see that you can end up with something really simple that works even better than the complicated setups. This is what I have now. This is using the Victor rig for the gooseberry. And I have to mention that this is a layout rig. So it's not like anything fancy. It's, it needs to work for, you know, like the animatic, but a little step beyond that with 3D. That's the layout to reset it. But this is the basic pose. I learned in this project that it is kind of nice to have the hands pointed forward because there is no twist already in the pose. Pretty much all the rigs I have done had the hands like this. But there is a twist fixed already in the model. And it's weird because you have to counter twist it to the other side. It doesn't make sense. If you have, you have it like this, you have pretty much the same range of motion to one side or the other. So that's cool. So the capabilities of this rig are stretchy capabilities are. The UI is really simple. So you have IK, the pole targets, of course. And in the feet, it's a good idea to parent the pole target to the feet base. So that when it rotates, the knee is always pointing where the foot with the foot. And these are all stretchy. And stretchy is just a matter of scaling these bones. Very controllable. And they do not move the feet or Nordic hands. The IK remains static. Okay, let's make this way smaller, for example. And on top of that, you get basically for free a bendy behavior. She is like this. This stuff is lovely. And it looks, of course, better with sub-div, oh no. Could use a white paper. Okay. Where was I? Yeah. So see, these are the basic stretchy capabilities. And I will show you how to do this. It's very easy. I have prepared a couple of diagrams here to explain how it all basically works. I did the diagram backwards. So from the final deformed mesh, what we render, actually, backwards to the control setup, you know, what the animator does. This is the character mesh. And we deform it with the formation armature. All of these are different objects, which has currently very strong implications in blender because of the infamous dependency graph. But the system is designed to be okay with that. So this is the deformation armature, which is deformed. Actually, there's an arrow missing here. It's deformed partly by a set of curves, which are just a NURBS path I will demonstrate it. And these NURBS paths are deformed via hooks by the control bones. This armature is different from that one. And it serves two purposes, like its control and mechanism. Some people call it like that. It's like where you set up the behavior, all the dynamics, all the IKs, everything. Also, some parts of the deformation armature are linked directly to the control armature. But, and I have another version that I will also show you that is slightly different because it uses MDEV. MDEV is fantastic. You know the mesh cache modifier? It's like a lattice, but way more powerful because you model a mesh however you want it. Of course, you try to make it simple. And this mesh volume will deform whatever is inside it. So it's great. And it not only offers smooth deformation, but also a wide array of possibilities to be applied, for example, directly to the MDEV. If you apply a bendy modifier or something like that, something crazy to this, it will work fast and easy. And the effect will get transferred very nicely to the mesh. In this case, we have the mesh. And the mesh is deformed by two things. The MDEV modifier and the deformation armature at the same time. It works. We will probably get back to these diagrams. So as Spline IK is like this, it's a chain of any number of bones. I like to do four like this. On top of that, you have a second object which I like to use NERP's path. This has some advantages. For example, it doesn't need control points like handles. You know the regular BCS that have handles, things. That's annoying for animation. So I like to start each curb. So that the pivot is located where the first bone of the IK chain is. So here. And also, you can actually delete vertices without breaking anything. Okay. So for most of my stuff, I do only one vertex in between. And the important thing with curbs is the order. The order is how many vertices does it take into account, neighbor vertices to achieve the final curvy effect of the spline. So with three vertices, we can only do three tops, of course. And Blender actually does a trick so that this one does need neighbor vertices, which is this endpoint thing. If you do the curbs differently, like you add maybe a spline or something, you may have to check this thing or you would need duplicate vertices here because if you want to use order of three, every vertex needs at least two neighbors. So since this chain only represents a small part, for example, the forearm or the arm, I use only one bendy control. It can be two, it can be five, depending on the length of the feature you are deforming. It doesn't change a thing on the rig. It does not need any special constraints. Very simple. So that's why I will do it with only one. Okay. So when you have this, you add the IK, spline IK thing and point it to the nerve spot and set the chain length to the correct number of bones that it has to affect. And that's it. You do not want to affect the scaling or use even divisions. Really, it's that simple. And now you have this spline IK effect. So this is one segment. Let's do the other. Let's say we have the arm. Let's make the forearm. So I'll duplicate this in the same armature. We are creating a deformation armature. And I'll duplicate the curve too. It's this nerve's path 01 now. And this guy, I will reset it to the new curve. So now by controlling two curves, I have both segments. Great. This would be the deformation part. Now the IK. The IK is, as I show it, a different armature that goes all the way. Of course, any IK needs a slight bending thing. So it doesn't have problems with initial direction. Okay. So add the IK constraint. And that should be it. Of course, it needs the pulse target, but I won't add that for now. Okay. So now control. For control, it's extremely easy. You need to add a new bone for the bending control. I mean a new bone in the middle of each of this disappearance. So, for example, shift as the fourth option. Add a bone there. This will be the bendy. And another one here. This will be the forearm bendy. And if I use the IK, they are left behind. But this is extremely easy to solve. As a general tip, avoid using constraints when you don't have to. If you can use parent to define the first layer of transformation, parents are absolutely safe, of course, but because of how they are done. And constraints are extremely dangerous because they get flipped all the time because of how they treat rotations. So I actually found that you can do this without any constraints. Parent, offset, parent, offset. Now you have them lying there. And you can scale them. And the scale of the parent bone, I mean, it is scaling the bendy bone, but it doesn't matter because this will just drive a point in the curve. The scales are lost there. However, it's good to disable inherent scale so that your bone doesn't visually grow on the animator. Just disable inherent scale. Never use this. This option should be taken away and locked in a dungeon because basically it does what it says. And that's terrible in this case. Rotations are lost, but you cannot define a parent. So you don't want to lose all rotations in a rig. You always need a base bone. Usually like a big circle that figures put below. You need pretty much everything to respect that as the main source of rotation and transformation for the entire rig. And with this, that's lost. I will show you a way to fix it. Also, there's a little problem here. If I scale this, I get a great behavior. But if I scale this, it's inheriting the behavior to this one. So let's disable that one too. Not necessary here, but okay. So with this, that's all we need. With this, we are taking advantage of something that Blender does very well. And it's scaling the bones inside an IK chain. It works great, but it only can be done if you scale the three axes at once. In other programs, this might fail or if you use these weird IK modes, it tasks or some disfails. But with the standard mode, it works flawlessly, no problem. So you can scale bones with IK chains. But let's see what happens if I scale only one axis. The IK suddenly fails. And since, I mean, we don't want the animator to either have to animate three values. And if he makes a mistake, it's a terrible problem. Everything breaks. So I'd like to drive this with a single value. So that's possible. Even when in Blender, this is dependency cycle. But there's a trick I want to show. So we want to drive the x and set with the y. So we lock this. And we lock this. And I'm adding a driver here, a single driver. So the way you add a driver is go into driver mode. And you already have a nice property there. And you put it here. And then you find the armature, which is armature one. And then the bone, which is bone one, the same. And then, holy, yeah, dependencies, exactly. So this is, I'm going to do it in the other thing too. Oh, well, of course, I have to change scale. So why scale? There it is. You see the problem? The values are having a cycle. So if I scale it, it is behind. Like, I don't know how many frames, but they have different values. And if I escape a transformation or undo it, it will fail miserably. So this is why transform channel property is most of the time not useful, sadly. Unless you are like copying from another bone or another armature. The trick to do this is kind of a brute force approach. So you do this with single property. And you will go and find the entire path from the object to the post bone channel. So that updates on every refresh cow. And it will work. But it's like a brute force approach. To do this easily, you put single property, find the armature. And from there, it's a path, RNA path. Copy that path, put it here. Maybe control B. There it is. And there's one thing missing, which this is actually the entire vector of three values. So you can do the old, you know, zero, one, two. But there's a nice trick that you can do dot y. And that's slightly nicer. So copy this driver, paste it on set. And now you have perfect updates. This is very stable. It will work. So let's quickly do this for this bone to just paste and change the hello here. Okay, and change the bone to just bone. And we solved that problem. Now the animator cannot do this wrong. It is great. So with that, let's hook it to the curves. If we do that, we have the IK, the stretchy bendy IK thing finished pretty much. So to make hooks, I'd like to first see the names of everything, which are quite confusing at the moment, but I mean, it's fine for a test. Let's switch layers a bit. So to do this, hooks, I used to do like curve empties for a hook and empties parted to the bones. But I found that direct bone hooks work perfect. So use that hook. Let's select armature one. I just might go ahead and name this, you know, def control. Good. So select the armature control. And we need this one more time. So copy. And because I'm so smart, I copied after I put control here, so I don't have to do it again. Same for this guy. And you only need two hooks, but there are three points. But that's how the hooks work, which is nice. So see, enter a dead mode. Wait, what? Enter a dead mode. Then select the two vertices at the end. And now we pick the bone called bone, which is the main IK thing. Assign, reset. Then we pick the center one and assign it to the bendy thing. It is bone three. Assign, reset. Let's get out and test this. Yes, working and nice. Okay, we do this exact same thing with the other curb. The only one, one and two hooks needed. This would be bone one, assign, reset. And then like the other vertex, bone four, assign, reset. It would be automated somehow. And perfect. IK behavior, scaling, and let's enable the other armature. Hey, wake up. Okay. Good. I also did a mistake at first of using a single IK, like in this case, it would be an eight bone, spline IK thing from here to here. And that should be fine. But there are two problems with Okay, there are a couple of problems with that. And it's basically this, the way the spline IK is designed to work. And that's the cool thing is that it slides. So if I grab this control, you see that I am not actually changing the sizes of the bones too much. They remain like in the same length as long as they possibly can. And the curb just makes them slide like this. So what this means is that with the bendy behavior and the different scales, imagine it, imagine that the elbow is here. And I make this bone larger. And the curb just slides. So I have the elbow here, which is a problem. So the approach of doing it with two segments solves that the elbow will always be there. And I have also independent control of, of bendies. It could be very useful to do two bendies. I just haven't done it. Okay. So this is the basics. Now there's a trick in blender, which is called Pesiebon, which was added by Tom, I think a long time ago. Yeah, Pesiebon. They stand for Pesiebon, which, yeah. Okay. So there are a couple of nice things. At first I was like, oh, too many objects, you know, two armatures. I don't like that. Or I like that. But in blender it's messy because after you do that, you are completely limited between, to not hit a dependency cycle. This graph basically means that these arrow directions cannot be, I cannot have an arrow going this way. If you have a direction, you can never ever go the other way. Even if it's for a single UI thing, like if I wanted to place a bone where these splines are, but I want to do that here, I would need this direction. And that's a cycle. So it's totally not allowed for now, but the blender developers are working hard on this. It's a really complex issue. So yeah, using curves and two armatures was at first a workaround, but I found it very useful now. You can set the entire armature to Bebons. This is, that's nothing. This is just a display type, but it's needed to see what I'm going to do next. So you set Bebons basically just subdividing the bones here under the form. Set them to, I don't know, four segments depending on the length of them. I encourage everyone to use this addon called copy something by Basam. Copy attributes is great because you can then copy lots of stuff like Bebons settings, constraints, really useful. And now let's try the IK chain. I'm missing my pole target there. Oh well. So you see there's a kind of a disconnection between these two segments, but the cool thing is that we can actually parent them, even connected parenting. And connected parenting is, what is that? There's a, there's an error there, yeah. I don't know what it is. Connected parenting is what you need to achieve Bezier bones being totally smooth because if they don't have a parent, a connected parent, they don't know how to smooth the start position. Or if they don't have a connected child, they don't know how to smooth the end position. So you need that. So with this technique you can do all the bones connected. There must be a problem somewhere. So I'm running out of this file and switching to a better one. Yeah. Since that's basically the whole technique, I'm going to show it here. The weight paint for this is terrible. It's working first. Okay. There's a slowdown here at the moment, which is caused by vertex parenting, sadly, when using subdev. I'm going to have to get rid of this for now. So now it's, it's fast again. Okay. This rig has everything and also has IK and FK switch, which basically switches layers here. IK is a different chain than FK, and then there's a third bone, a third chain that is actually, yeah. Cessence, DVD has all of this. So this is the deformation, the control armature. And I can show you here the full deformation armature. So here's when it all starts to make sense because if you check closely, you see that almost the entire armature is made of a single or actually very long chains of bones. The entire legs up to the pit are a single chain. And the entire arms from the clavicle to the hands are also a single chain. And that's also only possible same with the head from here to the head single chain. That gives us a lot of advantages with Bezier bones. You know, you see this slight bendy behavior that we get basically for free. This is only possible because we are using two armatures. So the spline effects are copying, are using the curves for the formation. But the other bones, for example, these ones do not have a spline. No, it doesn't matter. I still duplicate them from the control armature and put the duplicates in here. And all of them are green because they are using copy transform constraint to basically just mirror whatever this same bone is doing in the control armature. So this is chest bone. And here I have chest bone. Copy transform was made to do this. It is almost like parenting because it copies the entire matrix of transformation or yada yada. And it avoids any rotation flip. You can use it safely. Yeah, I think rigging in blender is knowing what is safe and what is not. Because so many things break. For example, the child off will flip. There's no way that you can make it not flip. Copy transforms does not flip unless you use influence lower than one. So this is not safe, yes? Yeah, the constraint system is based on it works internally with the matrix transform. But the problem is that to make the constraint work, they constantly switch between different rotation models. And switching between different rotation models creates a loss of information. And this is what causes the flips. So yeah, well, what I can tell you is copy transforms is very safe as long as you don't lower the influence. So leave it at one. Oh, yes. Yeah. Oh, yeah, they will start. I will, okay. Yeah, that is something I have to show you in this demo. Just a second. He was asking about, if some of you didn't hear, he was asking about the splines are at the beginning only affected by the curve shape. So that looks fine if you do a simple test like this. But when you rotate the character like this, they aren't getting rotation values from anywhere. I mean, the hooks from the control armature are just changing the positions of the points in the curve. And the curve is changing the positions of the bone in the spline IK. So rotations are nowhere to be found there. So you have to do something. Yes. Okay. So to end this, all of these are straight from the curve. And these are copies from with copy transform. But in this, in this armature, you join everything. Yes. When you pull it more than you should. Yeah. Okay. Yeah, that would be, yeah, this, this feature is not implemented here. So that would be another thing to consider. But we've never, I mean, for, I guess, for manual animation, the animator tries to not hit that point. I'm not so used to that. Yeah, maybe, yeah, because if the animation is done by, by someone directly, you just don't, don't do that. Yeah. But I guess you're right. For mocap, you need a stronger. Okay. Let's, let's just finish this because there's something interesting that I haven't gone about the, how to mix the measure catch my fire. Oh, that's the last thing. Okay. The orientation. Let's answer the, this guy's question. You see here, you see here, the entire armature is made. It consists only of the formation bonds, which is great. And it has performance benefits and all because this, this armature only deforms and does not need any mechanism bond. You don't need to select which of those bones are for the formation, which are not, which are just for looks. This armature is whatever, what deforms the mesh, except for this guy. And this guy is precisely added here to solve the rotation issue. It's very simple. This is a copy of the base bone. The base one actually has the same shape, just a custom shape makes it look a bit different. But you see how this vertical bone moves exactly the same. But this guy has a copy transform pointing to the base. And that's it. Since I remember, I told you this is totally safe, no flips. Basically you have a copy of the bone. And then you parent the start of every loose chain to there. So for example, this guy is parented. I don't know if you can see the lines there. Well, this guy is simply parented to this, to this. And this guy should be two. And this guy too. There are lines from all over the rig to this guy. And since the parent goes first, the constraints come on top of the, well, on top and I do below. Yeah, because blender is like the other way around. But parenting is first and then go the constraints one by one. So if you parent something and you have to move it, doesn't matter because example, if the spline moves it or the IK moves it or something or like this. Remember that this was parented to this. So it's a strange that it follows, you know, something else, but it's just at the order of the constraints. This one is overwritten by the splines and stuff like that. But that initial orientation still remains. And that is what makes it safe to do any crazy rotations. I recommend don't do the same error that I did when I was testing rigs. I was like, yeah, it works. Sure, no flips. Very careful not to do like even a 180 degree thing because I knew something was wrong. Well, no, there's no way around it. I mean, you have to flip it around and rotate it and move it one kilometer over there and see if the MDF, it's accumulating an error of precision and stuff like that. Okay, so that's, that's clear. Because we're entering something a little weird. Yeah, this rig for for gooseberry is basically that's it. But I have another version here, which uses MDF. And MDF poses a different challenge. So as this diagram shows, MDF is deforming, sorry, this mesh, but also the deformation armature is deforming this mesh. Why? Because MDF works for big pieces, big chunks of polygons. If you have, it works even better with like, but characters, because that's what it's made for. It gives great deformation. But then you get to the fingers. And there's no way sometimes because sometimes they are just so close. It's just uncomfortable to create a mesh, a deforming mesh that goes all over the details so we can, you know, move them independently. So Riggers started to do a technique, which is a blend, a weight paint blend between the two of them. So this, this works. It's like this. If you have the character with a mesh deformer over, thank you, with a mesh deformer ending here, then you can rig the hand directly with the armature. And this part, you blend it. It's like a fade. Okay, so you use the same vertex group and then invert it on the other modifier. And this way you get, thank you, only one transform Polish vertices. Because if you get more than one or less than one, you, these vertices will go crazy. So this is one way. But what I like to use is, what I like to do is use this guy and apply crazy effects on top of it, because it's an opportunity that you shouldn't miss. Just a second. With this approach, you cannot just add a wave modifier on top of this guy and then you have the character doing this. You can't do that because everything breaks. So what I did is using the dynamic approach and instead enclosing those parts with a cage. So it's like a box that it basically gives up here. It says, okay, I want to do the details here. So I will just enclose it. It's like big cage. The position of this cage is very important. It has to go after the IK target. Otherwise, I did that mistake on the caterpillar for this very teaser. It didn't matter much because it was like four seconds. But I did that mistake and making a huge cage for the entire sets of feet. So that made it impossible to create IKs for feet and Sarah had to counter animate a bit. So reach the IK point and then make the cage. And what's happening here is it's very cool. If you see it here, it works. The hands work. Everything is nice. You can go crazy here. And until here, this is all M depth, mesh modifier. But this is direct armature transformation. This is direct armature transform. And the bones are there. It seems kind of logical, but it's not because if you perform, I told you that I am moving the entire hand with this cage. So what happens if I move the entire hand with this cage, but I also move it, move some parts of it with a bone. And this bone was moving to this position. I'm not sure if I need to explain that again. The bones that move the fingers also have to move with the entire hand, right? So they are in this location, but I already moved the hand there. It's already there. It's a double transformation. That's the problem. So these fingers would go explode and go a kilometer on top of him. So what is it doing is, again, making use of the fact that we have anyway a copy of the armature. So we have it for free. We have the copy here. And the hand we left it behind. And it's like a remote control. So it is just slightly different. This is using world transformation constraint, but not in world space, just local space. And that's it. We copy this guys. And you see that the finger below, it just moves there. This is the formation armature. No, this one is the control armature. So it's a copy, but the transfer is slightly different so that they are left behind. So this is easy to understand when you see one step at a time. This guy has two modifiers working on top. So first armature. Armature does only the fingers. And like that, perfect. And on top of that, we move it however the pose it is. I don't care if he's doing this. I move all of that to another position with the arm def. And this way it has the advantage that since the control armature is in the correct position, it looks like they match, even if the fingers are there because of the arm def and not because of the arm def. Yes. Sorry? No, no, no. In this case, I'm using the dynamic. I forgot to mention that. This is a dynamic bind. So a dynamic bind is essential for this use case because you see that the end def is below the armature. So this means that the effect is added on top of whatever the first armature deformation is giving it. And only dynamic allows that. If not, static M def is slightly faster, but it needs a base position that is kept like that. If I were to do this, like change the pose of the hand, then the deformation will do something weird. Yeah, because it expects the pose to be fixed. How it works is that the weighting, this calculates a kind of weighting, but it's volumetric and it's awesome and it's fancy, but basically the fixed version calculates it all statically. It is almost like if you have a thousand bones and regular weight painting and this one doesn't. It keeps this volumetric deformation field. It behaves more like a lattice, which is great. So you can do all kinds of stuff and as long as the fingers do not leave this enclosure space, it's safe. So you see that I don't even use vertex groups to mix between both, because it's not necessary. As long as you don't do double transformation, that's it. I think that's the technique. Yes. Before armature. Sure, absolutely. Yes, yes. And what's the mesh case? Do you see better for nicer deforms? Yeah, this entire part is deformed by this single hand bone. So the chain is, the actual chain is kind of simple. It goes with the arm and then one bone for this case. The advantages are many. As I said, you can, well it's like this. I wish I could draw with a pilot there, but I would get in problems. Anyone can go. I mean, I think I'm over the hour or... No, it has many advantages. Imagine if you have this character, a character that has maybe a spine. So we will represent this spine with cubes. So little cubes here and here. And we will parent them object parenting. So if the cubes were to be very slim like this, this could work. But you see there is a slight interpenetration on the borders. So what if the cubes were just a bit thicker? Whoa. Now the interpenetration distance grows with distance. So if you think it this way, that is the problem with a chain of bones that is made from the center of a character. Because it's basically parenting vertices. That's all. Of course it has blending and all, but it's basically parenting vertices. And it's moving them like this. And sadly the armature modifier lacks any way of simulating the collisions that are in our body. No, this doesn't happen in our body, because it's physically impossible, but in 3D it does. So the way that the cage does it is that it will deform the cage. It is big like this. So now you have a deformation field that has a volume. And from this volume you deform what's inside. And there is a smoothing implied in here. If you think about it, if I move these two vertices and the final mesh is very close to the edge, they will pretty much follow whatever I do here. But if the deformation mesh is just a little bit inside, they will not follow exactly what I do here. But if the deformation field starts to smooth, it's like a heat thing. Imagine if each of these vertices glowed red or glowed heat. So if you are inside here, you feel the heat of many little points. And if you are right next to the vertex, you only feel that. So there is a smoothing implied in how you use this. And that is why you can control the type of bending effect that you get with MDF just by varying the distance between the cage and the final mesh. So if you want, for example, a very not smooth elbow movement, you make the cage there very tight. But then on the belly, you might want to leave some space, leave a gap. And you have this smoothing implied. And of course, this is what everyone uses, but I've come to like very much to use effects on top of MDF. So it is, oh, also, just a second, the volumetric thing is just so important because characters are not like a single smooth mesh, sadly. They have buttons and they have something hanging. And they have, yeah, I want to forget. They have sleeves and maybe just like this. This is nightmare to weight paint because you will never make it so perfect that whatever you do, they remain the same. It starts to offset. With a volumetric approach, this is not a problem. You can have even buttons or whatever object there. And since the deformation field is so simple, the deformation field is smooth and doesn't have any of these problems. So whatever it deforms, it follows perfectly. But that's the second huge advantage of this approach. Yes. Uh-huh. Like for the twist effect, it will flip. Yeah, oh, there are so many reasons for that. If you try to, as I said, if you try to use constraints with less than 100% effect, there's a flip there implied. So if you use the constraint approach of just blending to 50%, so it goes midway, that's the safest way would be to use drivers as I showed in the beginning. The full path and accessing the oiler, set them all to oiler, and access the oiler value directly. That's an access in radiance, so you can do a simple math division by two or something, and you get it. But that only works with FK chains, because IK is more problematic. There is another problem with blender constraints. Terrible. The drivers do not have access to the constrained value. So if you're driving things according to the rotation of an arm, and this rotation was given to it by IK, you cannot have access to that. That's a problem. So it can be problematic with the rotation of the hand. We've had lots of issues with that, and we end up solving it differently each time. So if you see the, actually we did the tricks on this guy, these guys have a twist bone with no flips, because it is just one axis in oiler, and basically they rotate indefinitely, since they are so cartoonish, and Zara actually used this in animation. There's a part when, I'm not sure I can show it here, I don't have it. Oh no, yeah, yeah, maybe I have it. There's a funny part where she used this in the second video. Oh, yeah, there it is. You see the hand of this guy? Wait, wait, wait. Yeah, all the time is used, and of course you don't see it. But it was used all the time, just not so visible. Yeah, I've done many variations, and I have to say rotations are a problem, where they are always difficult, but in Blender, with the constraint system, that you can't rely on the use, it's even more difficult. So I'd say try to use it only with drivers, set everything to oiler, and try to solve it that way, more direct. You were talking about adding deformers for effects to the deformation mesh, could you give an example of one? Sure, yeah, I have some here. Yeah, it's always useful to have this secondary level of deformation possible, for example here, or actually in here. Okay, this rig has, what? Oh no, oh great, that was easy. This, maybe I pressed the wrong button. This character has the mesh, then the control, then the cage, then some lattices, and then the hand, this was a slightly different approach. But for example, I'm using a lattice to deform this guy. So it's like 20 levels of the, I don't know, but the lattice deforms the cage, and the cage deforms the mesh. Exactly, that's what they do, yeah. And this is actually a shape key, that the shape key is added to the lattice, and this lattice, no, it runs fast, especially it runs fast, because the slow part is this. That's why I'm trying to speed up MDEF, because if, but applying effects to the MDEF, it's almost free, because the MDEF is so simple. If you wanted to apply this lattice to the mesh, and you end up adding so many, like a curve modifier, or a simple deform modifier, and all of that goes directly to this mesh, that's heavy. But when you have already this simplified mesh, and you add effects to it, it's fast, it's reliable, it's smooth, and it works together with the entire rig, that's a great advantage. It also, yeah, you see that it also has the simple deform modifier, which is being used by the Bendy effect. To the lattice in this case, the lattice had a couple of question and stretch things. I mean, this was a hack, as I said, this rig, I didn't thought of all of this before, it was just that Sarah started asking things, but the MDEF saved the day in this case, because it's so easy to deform it. And even if you add shape keys, direct shape keys to this guy to achieve a very special effect, it all works with the entire rig. No, because you add the shape keys to this guy, and it's impossible to, I mean, after they are binded, everything you do to this guy deforms whatever is inside, so you can't go outside or inside, like a lattice. Yeah, also another great thing of this is that you can make changes, heavy changes to this character, even after the rig is, I mean, 100% done, and I'm like, sure, give it to me, and I'll re-bind, that's it, because all the heavy weight painting work is done here, not here, so another very good thing. Okay, you don't weight paint the whole body besides the fingers. Exactly, yeah, only the fingers, yes. Yeah, of course, there is if you don't follow the rule of arrows only in one direction. So actually I wanted to do something cool that I couldn't. For example, here I wanted to have a bone, only for display, like this armature had some kind of shape here that gives me the final shape of the bone chain, but that's not possible, that would be a cycle, because I would need to get that information from the deformation rig, which is this one. Oh, yeah, oh, sure, no, no, that's, of course, yeah, that problem is because you did it all in a single armature, so you are creating the cycle like this. What you did is have these planes, and then they deform the armature, but this armature is the same as this one, so you have arrows going both ways. Okay, because even if you have different bones, like the control armatures have some bones that deform the splines, and the splines deform other bones, but these two are the same armature, so Blender is stupid and says that there's a cycle, because, well, for Blender there is, but shouldn't, but there is for now, and that this is, that is what I explained at the beginning, I used two armatures just because of that problem, but then I started to discover nice things about having a separate armature, so this is the whole thing. Okay, thank you very much.