Controlling Physics With Geometry Nodes — BCON26

Um but yeah, this is the next presentation about uh controlling physics with geometry notes. There's a QR code in the bottom right you can see with some files. Um there's also the link so you don't have to scan it with your phone. Uh I would recommend to maybe also check that out later at home if you want to uh take a closer look. Uh this is not going to be like a fully follow along right now uh kind of workshop. I think because it's relatively densely packed and also not super uh focused on being beginner friendly. I'll try to explain as much as I can, but the idea is really digging in a little bit more onto the new physics framework that's shipping with uh Blender 5.2 for geometry nodes. Um yeah, that's pretty much all I wanted to say. Okay. Oh, yeah. And is this also in this link you can find uh in the another link to an experimental bender version which I'm going to be using for this. It's not necessary for most of the presentation. Just at the very end there's going to be a little extra uh that requires an experimental version. But yeah, B conference 76 uh controlling physics with geometry nodes. Let's go. uh fun. Well, I had some slides prepared, but I'll go over that a little bit later. It's going to be a little bit of theory. Uh for now, let's start with uh just going over the basics. So, since Blender 5.2, two, there's going to be a bunch or there is a bunch of built-in uh physics assets that are fully using geometry nodes to do uh simulation physics simulation. And uh to just get started with that, I'll just show you a simple example uh on a plane. Actually, let's get rid of that in a new plane just so it's proven that this is nothing more than just a plane subdivided a couple of times. and then jump straight into geometry nodes. And in there, just add the cloth dynamics uh note group, which just ships with Blender. And when I press play, you can see there's already stuff happening. Nothing super interesting because it's just gravity doing its thing. Uh but then it's quite easy to go from there and add some settings here and there that you can see there's sliders and stuff. For now, let's make a new uh weight map to add some pinning very easily. Just call this group pin and pop it into the node tree as a named attribute. And then it's as simple as that. Plug it in uh plugging that in here. And then you can see we have our class simulation. a little bit of a way to move this cloth around. So, not a lot of noding really necessary to get some some basics done. And then you have some settings that you can control here that we'll go over a little bit more later. Uh, but yeah, as you can see, it's not too hard to use the system already to get some basics. Uh, the next thing I wanted to show is adding uh interaction to this with a uh collider. So for that I'm going to add a new collection where I'm going to add a sphere. And the way this works in this physics framework is that the information from the different objects is passed uh via geometry nodes. So uh to make this into an actual collider that can interact with the cloth uh we need to add a modifier. Uh, and there's a built-in collider modifier that you can use for that. And, uh, by default, it doesn't do anything yet because the cloth doesn't know anything specifically about this uh, collider yet. So, we need to pass it in uh, as an aector, which is a new term of just anything that can yeah affect the simulation. Just search for this. Ignore the other collection that's from a demo that I'll show later. And then, oh, where am I right now? There you go. Oh, yeah. Another thing I wanted to show was that you can also interact with this and actually adjust the inputs while the simulation is running. This is pretty neat. That's something that wasn't really possible before uh to get a bit more interactivity. Okay, so far so good. That's like the basic setup of uh yeah, not diving too much into the details of how things work, but we're going to go a bit more complex from here. Um so let's look a bit more of uh how you can customize these things. Here on the cloth dynamics node group, you see the uhectors here. I just pass in as a collection but instead you can also pass them in directly as a socket and this is a yeah a new socket type called a bundle. So let me just quickly show you how you can do that. So instead of using just the object collection you can also add the collider node in the node tree itself. Drag the collection in here directly like this. and then instead of just the geometry output here, use the collider bundle and pop it in there and has the same effect. So essentially what the modifier on the sphere is doing can actually look at it here is it's setting theector on the uh geometry that's being output and then uh by assigning it to the collection the uh simulation can go over all the differentectors and then read out the information from the bundle which is essentially the same thing as what I've done now here uh and we can also inspect the bundle here with the viewer node. Taking a look, we can see that the bundle is basically just a container of data can be anything. In this case, you can see it's a whole bunch of properties of the uh collider uh that the simulation uh uses and one of those properties or one of the data uh is the geometry itself. So yeah, you can really nest a bundle, put all sorts of information in there, and that's what this uh system is using. Um, you can also have multipleectors and you can just simply do that by putting them into yet another bundle with the combine bundle node. And then you can just put as many factors as you want in there basically and the physics system will just deal with it. So another thing that I want to put here is a custom force and then you can just add a new input here. You can give them a name so that later when you look at the bundle you can see okay these are my entries that are part of the collider these are the entries for the force and can really get like a little bit of a structure like that. Uh, right. Get rid of the viewer. And now when I run the simulation, you can see I can just add like a custom force like this. Change it as it's running how I want. But right now, that's just a single yeah directional value. Uh, it can also be something that depends on the geometry like for example the normal. And then when I plug that in there, maybe scale it up a little bit because it's not strong enough. You can see how the direction of the force changes based on the orientation. This basically like applies some kind of pressure uh on the on the surface of the cloth. Uh yeah, and then this is already like one way of you how you can customize setups relatively easily without really having to know too much about the setup itself, how it works. Uh let me just add a couple more nodes to play around with this a little bit more to show you how how easily you can build some stuff together. So just uh multiply this with some some value the the group that I'm painting in and use that for the stretchiness and the bendiness to actually get some more interesting results. invert the pin group and you can get some really fun like interesting results like this. And just play around uh to see what kind of effects you can achieve like this. Uh yeah, I mean that's pretty much what I wanted to show for this first section. Just a small little introduction to get everybody up to speed. Um so let me just quickly talk over a little bit of theory of like what this uh system is based on. Go back to my presentation view. Uh there's basically two different ways of approaching a system like this. um where like the like what's been previously kind of been the default for how geometry nodes works is an imperative workflow where you just have different operations running one after the other and that just defined where they are running. So you have like something going in being processed by different steps and then coming out. But as soon as you try to kind of encapsulate this functionality like when you want to ship this as a system that people can use and customize in Blender, uh you need to put it like into a box and then it becomes very hard to uh to adjust because then for any little change that the user might want to make, they really need to like dig deep into this nested uh structure of operations to just make small little changes. and it's not great for like the architecture of a framework like this. Uh so the other approach which is how this system was actually built now which you've already seen also uh is a declarative approach where you just have uh this black box that is processing stuff uh where stuff data goes in and out uh but you can pass in the instructions of how the processing is supposed to work from the outside uh and is very well scalable like this and highly customizable. So this is already what you've seen with the bundles. You really pass in what the solver actually does from the outside. And the setup itself is built like this too. We're going to see that in just a bit. All right. So let's go to a bit more of an advanced use case. Oh, it's already running. So this is what we're going to build. Uh I'm not going to model this again. Maybe you recognize what's going on here. Uh, I don't know if you already picked up your shirt at the store. Little bit of a uh a little bit of an advertisement here in the middle. Um, so yeah, we're going to build a system that basically can do, let me enable this. It can do this kind of sewing. So you can start with like a pattern like a garment pattern uh to put it on a character uh and then also do other funky stuff like ripping it and having a simulation of individual threads that are kind of popping up on the tears uh and also are being simulated. So you have like physics on top of physics and that's not really something that you could really do before with the old system, but that's something that the new system very much allows. And yeah, this is what we're going to build. All right, but I'm not going to do the modeling for this again. Uh so we're starting with this as a base. There's nothing on there, no geodes or anything. We're going to build everything now. Uh, and we're first going to start with the sewing. So, the idea that's also something that was already in the previous uh, system, but that doesn't currently um, natively come with the new cloth system is this kind of idea of sewing where you can have these loose edges to connected individual parts of the garment that are supposed to be sewn together. And then as the simulation runs, it uh, those kind of pull together to really uh, create the shape. Uh, so that's not currently natively in there. It's going to be at some point, but it's already customizable enough so you can quite easily add it yourself. And I'm going to show you how. So, we're going to start with the new geometry nodes uh note tree. And same thing as before, add the cloth dynamics uh note group. Okay, just checking that gravity still works. And then right I need to I need to uh still make it uh collide with the collider here. For now I'm just going to uh very simply do the same thing as what I did before. Just select my collider collection. Just check that that works. Uh does it work? Yeah, works. Uh and then I'm going to do something else than what I showed you before. So the declarative approach allows us to uh passeectors from the outside. But of course, this setup itself is also still just a node group that we can edit. So another option with this system is that you can also go inside of the node group and see how the system is defined. And you will see that very much like what we've done from the outside also in the inside it's using this declarative approach to uh to set up the framework. So you can have all of these different uh factors here that the base setup already has set up for you and those are all passed as a bundle into the simulation. Uh and that's what the simulation is based on. So it's really just collecting gathering all the information together and then solving it in a different place. Uh so yeah, let me also quickly go over a slide for that to just quickly go over like the general concept of how the solver works. So uh essentially the physics simulation is uh based around the idea that you have just a bunch of constraints like based on actual math right for physics uh and the and the geometry itself and everything like the edges that two points should stay at a certain distance or pinning constraints where a point should stay at a certain location and other things like that. Those are all constraints that the solution that you're looking for that's physical movement uh should satisfy that all gets uh collected into this container as a bundle and then you just pass it into the solver which uh is currently in go nodes just a node that's built into Blender and the solver just does a bunch of math. It does like iterative stuff to kind of try and satisfy all the constraints to more or less the same degree and uh it fails because there's no perfect solution usually but it gives you some kind of solution plus an error and then you can see how well the solution actually works. Uh and that's the and that's the solver. So it's really based on all of these constraints and that's what we're looking at here when we uh look at the note tree here. So there's all these constraints going in to the system and uh one of these constraints I mentioned it already is an edge length constraint and that's actually exactly the one that we need to hook up to to make the suing work. To actually make changes though we need to uh show the node options and make this local because by default it comes as a packed asset. And now I can actually adjust this node group. So the edge length constraint already has an option to pass in a custom length. If I just click that, you'll see it's a big mess because now all of a sudden all the edges think they're supposed to be zero length and they're trying their best, but they're not really getting there. Uh obviously we don't want to do that with all edges, just with the loose ones. So I can easily just take the is lose edge uh is edge loose node pass it in there. There you go. That's that's basically already what we wanted. Uh I'll make it a little bit fancier because right now it's extremely snappy, which can be nice, but it's not really how sewing works. It's a bit fast. Uh and it might be nicer for some effects to have it a bit more of a slow progression rather than just immediately snapping everything, which makes the cloth go haywire potentially. Uh so it's better to have something that progressively like over like a second or something uh goes there. So I'm going to make some some changes. Uh I get the edge length node and then multiply it. So it's basically taking the current length of the edge then multiplying it by a factor that's less than one. And in this case I want to do it over the progression of a second. And uh to get that I can quite easily use a simulation zone which is not maybe the most intuitive way to do it but it's if you think about it makes a lot of sense. And I just add up the delta time between all the steps. So every every simulation step I get how much time has passed. Just add that up and that's the total time that's passed. And then with a map range node, I can just say, okay, from zero to one second, I want this multiplier to go from one to zero. And then over the progression of a second, they slowly pull together and tighten up, which makes it less snappy. I mean, you can change the timing also here if maybe it doesn't work, maybe gravity is too strong. uh and then you get a bit more of a natural uh result in some cases. Here it doesn't really make a difference, right? Uh and that's the sewing already. That was pretty quick. And then you can do all sorts of uh fun stuff like uh for example, let's grab some of these. Is this the right ones? No, I don't think so. grab these faces and then delete them. So, we basically create new seams like this. You can just grab these and kind of scale them up. Create different types of fabric effects like ruffles like this. Pretty fun to play around with. Uh anyways, it's not actually what I want to do. Okay. Uh right. So the next thing then is to uh add these threads that I was talking about. For that we still uh or first of all need tearing and that is built into the new system. There's just a Oh, there's quite quite a lot of tearing going on here. Wasn't that much maybe uh to to create rips like to to split the edges basically when there's too much strain uh going on the uh on the geometry. So like this for example all falls apart. Doesn't look very natural right now. So there's a couple of things we need to do. Uh, one thing is there's usually like on a t-shirt there's some support around the neck to actually uh make it a bit more uh durable. So to simulate that I'll just create a my shortcuts are different. Create a vertex group. around the neck. And there I just want to uh use a different threshold for the tearing. So I'll use a switch node. And then around those areas there's going to be a uh higher threshold. So the tearing is less likely. I'll just use 10. And here I just need the named attribute node. the neck. Oh, well, one is maybe a bit low because if the if the edge becomes longer than it was at all, it's it's a bit sensitive, maybe. And now you see it doesn't rip around the neck. So, that's already nice. But then there's some other things that you can enable to make it look better. like there's a built-in option to uh basically have a different tearing pattern because right now just everything might or might not tear depending on the simulation and there's an option to choose voronoi which is quite nice uh it gives a lot nicer results usually uh kind of like this and then on top of that I want to do one more thing because it's still a little bit symmetrical and unnatural in my opinion so instead of just having a flat value uh for all the other edges and not on the neck. I'm just going to use a random value. That just adds a little bit more natural randomization to everything. Uh between one and two. Well, maybe 1.1. Oh. I remember this working better in my testing. Oh yeah. Uh I need to also because right now the uh fabric is basically, as you can tell, not bendy or stretchy at all. Well, it's a little bit of a lie. It's naturally still going to be a bit bendy even if this is on zero, which is just how uh it works kind of because the uh information of the bending needs to kind of propagate throughout the mesh. So, it's a bit tricky for a solver to really make something super stiff, at least in the iteration that it is right now. So, things are always going to be a bit bendy, but this one we want to actually be bendy because it's fabric. Uh, so let's cranked it a bit higher and then we get some nice tearing like this. Great. Looks a lot more natural. And then uh the next thing I wanted to do is on top of these tears spawn the individual threads. And for that we need to first of all find out uh which of the edges are actually part of the tear. And uh well one easy way to kind of do that is use boundary selection. So there's the is edge boundary node. uh and you can see okay this gives us a pretty clear idea of what the boundary edges are which the tears are boundary edges problem is just uh that currently it's all boundary edges including the ones that were already there in the beginning so not just the tears and uh for that we need to figure out only uh the tears themselves uh well actually let me let me do one step before which is spawning on the individual threads. We just act like this is already great. Um to convert this to a curve around these edges like this, we get an curve representation of the uh torn edges like that because that's where we're going to spawn the threads. And uh then on this I can just do uh subdivision of the curve instance on points to put uh a little thread on all of these individual points that I'm creating. And that's just going to be a curved line. a bit long right now, but do like negative 2 cmters or something. And then you get this. Now, I do want physics on top of them. So, I need to first realize them because right now they're still instances. And then also throw a hair dynamics notebook on there, which is also new shipping with Blender 5.2. And it already does something like without any more changes. You can see that it actually does like wiggle around a little bit. So actually I need to resample this a little bit so we get more points because right now it's just two points per curve. But yeah, you can see there is already physics acting on these. So without too much work, we actually have like a system of physics that's working on top of another one. Uh there's just a little bit of a problem right now with the setup, which is when there's tears being created, everything goes crazy. Uh which is not what I want. Uh I'll also crank down the amount of points to three for the sake of performance. And the problem that we're facing now is that the hair dynamics is not really made for the amount of hair changing during the simulation. And the the problem right now is that the uh the order of the curves is kind of random. Like the new ones that are being created that the physics system doesn't know about yet are kind of inserted somewhere in the middle. Uh but for the physics system to not freak out, it needs to uh basically only have them added at the end. Uh and for that we need to uh make some changes here. But the nice thing is that the the system really allows us for some really custom changes. So that shouldn't be too hard to do. Uh first of all uh what I want to do is basically identify which edge is new on each frame like is a new tear and then add that to a cache. So I just collect all of the new ones, add them all together, and that way I can really ensure that the new ones are at the end. And yeah, that I can just do with a simulation zone which starts out with nothing and then joins in the new uh edges on every step. But now I need to find out what those are. Uh and that's going to be the next setup. Uh and for that we're going to do a custom aector which uh is another way of really on a pretty low level hooking up to the uh simulation system to to get information about it or yeah make changes to the geometry. So going from here I just type in customtor and there you go. This is a pretty small node. Just has two uh menus, a filter, and then this interesting socket, a the geometry factor sockets, which is a closure socket. Uh and a closure is also relatively new in bender and it's a very nice way to enable this kind of declarative workflow. uh to add a closure zone like this can just type in closure and then because I dragged from here and then searched it already comes uh prepopulated with the correct in and outputs and uh a closure is essentially like a function that uh gets some inputs and sends some outputs uh but doesn't actually here process any data yet it's used somewhere else for the evaluation which is really enabling that system that I was talking about earlier for the declarative uh nature where you have uh processes uh that you instructions that you pass in from the outside and that's done via a closure for example. Uh and this is very neat because here we actually have access to the data from the simulation. the geometry that's being simulated on that is basically only accessible within the simulation but without having to go inside. Uh and then we just need to choose at what stage this is supposed to be evaluated because like it makes a big difference if you do something at the beginning or at the end and there's a bunch of different options. Uh and you can basically see when those are happening in the note tree. Like if you dig a little bit deeper, you can see, okay, there's a pre-solve, posts solve step. There's a bunch of other stuff going on. So I made a little uh breakdown that is a bit easier to uh look at maybe. Nope, it's just like this. Where's the different uh stages that you can hook up to? And there's uh the geometry going in. And then before the simulation starts, there's the presim stage which is just uh useful if you want to initialize some data or something that you then use later on. And then for each step of the simulation uh that gets repeated in a loop, there's then the pre-solve stage, then the solver does its thing and then there's the posts solve stage which is pretty intuitive I would say. uh but these are going to be all of these we're going to use uh throughout. Now first of all we need to initialize some information because we need to remember which of these tears were there in the very beginning. So first of all, I'm going to use the pre-simulation stage that only runs once in the beginning to store the uh information about the boundary edges like this as an attribute. Call it boundary edge uh like this. And then we can use it as a named attribute later on uh yeah you can you can see that's the original boundary edges. So even now if I start creating the tears those don't uh become part of the selection because we just made it once in the beginning and then stored that information. Uh, okay. So, we basically need a selection of the opposite, but more than that because we really want to get the information of each tear that was created for each frame. So, I'm going to create another custom uh in the presolve stage. Let me think about that for a second. uh posts solve sorry in the posts solve stage to really because the the tearing happens in the solver uh and then afterwards we want to check what changed. Add a combine bundle node here to get these all in there. Create a new closure. And then in here I'm going to create some new attributes. One of them is going to be called torn edge new. That's only going to be the newly added torn edges. And to get the information of that, I'm just going to use the boundary edge attribute that I initialized in the very beginning and subtract it should be a boolean. uh subtract it from the edges that are currently a boundary and then that becomes my uh my uh new torn edge and uh then I just need to add that to the uh current boundary edges. So I just take that new torn edge and update my selection. So every single frame first the new torn edge is identified and then it's added to the selection of the boundary edges. And then this way I really should get uh information about the currently new torn edge as it pops up. Oh, this is still the wrong one. Um, this is not right. Okay, let me let me shuffle the setup around a little bit. Not sure what I did wrong here. Okay, this is basically I thought this is doing the same thing. Ah, tricked myself. There's one more thing that we need to do. Uh, which is this is just going to magically work. uh type in boundary edge in here and this should fix it for some reason. Although I'm going to explain why. There you go. So now only the new edges actually just pop up. They like flash that they're currently new and then they become black again because the selection is gone. And the reason it didn't work before uh it's something that you can very easily fall into. But uh I'm going to show with another little graphic. M I thought I was going to show it. Wait. Uh I don't know where the graphic selection >> ah I was on frame negative one. Sorry about that. That was my bad. Uh anyways uh what's happening in the simulation system is that there is a cache transfer that happens. So we get the data in the geometry that you're simulating on and instead of just doing all of the processing on there directly uh the system creates a copy basically which is then uh processed and the simulation happens on it and there's a bunch of attributes that are generated for the simulation specifically to happen. Uh and then everything that needs to uh make its way back onto the original geometry uh is then merged together basically to uh yeah to update the geometry that you passed in. And the reason this works like this is that this way it allows you to still after your simulation is baked make changes uh to the input geometry like add attributes, change colors, whatever like make do vertex painting on the cloth basically. uh after the bake is done and it still updates properly and only the actual stuff that needs to update for the simulation like position attribute and stuff like that only that is really used from the bake. So it's really the information is transferred from the cache and uh that's the reason why it didn't work because that attribute was not known to the simulation system as something that's relevant to be transferred. So uh that's why we needed to add it here for the simulation to be aware of this being a property that needs to be taken care of. So any attribute that you want to propagate uh from one step to another basically needs to be added here and then it just magically works. Okay. Few um where was I here? Okay. Okay, so we have information about the new edge on every frame. So now we can use that to uh populate the edges in the correct order. And uh I'm going to try and do that relatively quickly here. So this was already the setup we had, but instead of just using the boundary edge to create the curves, we need to use the uh named attribute that we just gained. on the torn edges. Uh, and then that only creates these uh, well, this is not the best way of previewing it maybe. So, I'm going to add those into uh, like join them together here every single frame. Okay. Select the viewer. There you go. And then they pop up. But uh this doesn't look quite right because now they're just static there. They're just baked in the frame when they were created. So we need to actually update the position of the ones that are still there. Use a set position node. Sample index node. Uh and then we can sample the uh position of the deformed mesh to update the uh curves. Uh and to make this properly work, I'm going to use the face corner domain because if you if you think about it, when the cloth tears, one edge turns into two, right? So it's not enough to know about like the uh uh the indices of the points. you really need to do it per face corner uh like for each individual phase that has been separated. Uh so there I'm going to sample the position but now we just need to know which face corner the points correspond to that I'm just going to use the same trick again of initializing some data in the beginning of the simulation. So I just store the uh index of the face co that's not it of the face corners in the beginning corner index uh and then use it later on to really know which point corresponded to which corner before the tearing happened. But for this to properly work, I also need to uh still do one more thing, which is splitting all the faces to individuals. Do that with a duplicate elements node set to face. This just makes sure that all the faces are split because I only really want the split edges anyways. And then this keeps it indices coherent and everything. I need to worry about uh weird uh interpolation stuff. So now in theory, yeah, this gives us a live updating result of just the torn edges deformed with the original geometry. Great. So now can just pop that in there and in theory it should just work. Okay, let me add a join node. Okay. And there you go. So now the threads are really spawned on the right places and they're not going crazy anymore when new ones are added because the new ones are only added at the end that don't confuse the simulation system. Uh that's already the well already it's been 45 minutes but uh that's the core of what I wanted to show done. Now we have a little bit of an extra and I am not very confident I can do it in five minutes but I'm going to try uh which is a look into the future of Blender. You've seen it in the keynote maybe like this was pretty much this exact demo uh with some real-time interaction uh using model node tools where you can actually in real time uh yeah with your mouse interact with the geometry and uh okay I'm going to try to build this real quick. Okay, this is based on the experimental version that I'm linking to in the QR linked from the QR code and uh this adds the functionality to node tools which have been there already in Blender uh to run as a modal tool which means that they basically update in a loop uh and wait for your uh key inputs. So first of all I'm just going to enable this to run as a tool which means I can select it here geometry nodes.003 003. Um, and then I just need to make sure that I can run it for meshes in object mode. Give it a an amazing identifier. There we go. Um, and now it's here. I click it, nothing happens. Okay. So, the problem is not now it's not running modal at all. Uh for that just full disclosure design of this might still change of how the exact workflows are but in general it's going to work something like this. I can add a modal timer node and then all of a sudden now it does the simulation just as a tool. Uh so I don't have the modifier on it at all or anything. And uh in theory it's a bit unfortunate that now everything fell down but uh I don't need to run the scene time at all. This is just the tool running on its own clock and that allows a lot of uh things like implementing brushes and stuff with geometry nodes which hasn't been possible before. Uh oh. Uh, okay. I have four minutes left. I'm wondering how much sense it makes for me to actually attempt to Well, auto save works. That's great. Um, well, it didn't save the things I did. Okay, I'm going to fast forward and act like I just did everything now, but I'm going to show you the result because I don't think I have the time and it's not fair to the next speaker to bleed into their time. Uh, but there's this, which looks pretty much the same as what I just built, plus this stuff at the bottom here, uh, which does some cool stuff. So, I'm just going to explain what these nodes do instead of building everything. Uh, so there's a pinning constraint which is basically the same as the one that's already built in up here with the pin group that we already used before, but this is a custom pinning constraint. Uh, which just means we can pass in a custom position. So it's not just going to pin it where it originally was, but instead it's going to pin it where I tell it to pin it, which is very powerful because then I can drag the cloth around with my mouse cursor, for example. Uh and the way that's done is by there's the modal timer uh adding events that the tool can react to. So here this is also a new node the uh you can see the modal event node which makes a key map uh pop up here that can be customized. So we have an event defined as click down, an event as click up, and this is mapped to the left mouse cursor pressing down and pressing up. And then with a simulation uh we can keep track of whether or not the mouse is uh held down right now. uh with this kind of setup and that just uh gives me the information of whether or not the cursor is pressed and then this can be used to do different operations as the modal loop is running. It's basically just evaluating the simulation over that modal clock. And uh what this is doing here is using information about the viewport and the cursor position to do a raycast on the cloth. So we can basically do selection. Uh and then here it's basically using the information from the raycast to then find the closest point here by checking the position of all of the uh points to the raycast hit position. Finding the closest one and making a selection that is then captured to pin the point and also writing the uh hit point as the pin position. So, this happens when the click is held. You can see here with the switch node. Uh, if the click doesn't just happen, but if it's still being held down, for example, the pin position is just updated. So, the same vertex stays pinned, but the position is changed uh to be within the view plane. And if neither is happening, the mouse isn't pressed down. The pin attribute is just cleared. And uh the way that looks in here is that then you can actually interact with the cloth like this. And uh if I if I just tear hard enough, I can actually tear off pieces of this. This is just really using the same simulation system that we had. And uh yeah, I mean this is still uh in development. The design might still change a little bit here and there, but this is uh something that's very exciting for the future of uh geometry nodes and blender in general. And uh yeah, that's what I wanted to show.