 The version of Blender can be 3.6, that's what I'm using right now. But 4.1 should also work, but 3.6 is the first version with simulation nodes, and it's also what I'm gonna use here. There is a QR code and a link that you can check out. There's, with a network here to download the files that you can use to follow along. There's also the exact same files that I'm gonna use. And so make sure to get those files now if you wanna follow. And I also have my fantastic helpers here, which are the great people from the Geometry Nodes development team, Jack Luca and the Leifelinto, who are gonna, yes. And if people have problems, because we're gonna have to go a little bit of a fast pace to get through everything, just raise your hand and these fine gentlemen will help you out with everything. Other than that, yes. So in the folder that you can download at this QR code, there's a bunch of stage files as well, which is not just the start and the end point, but something in between. So I'm gonna announce whenever we get to a certain stage, and if you got last summer belong, then you can check out the stage and start from there. Yes, a little something about me. So I'm a, I'm Simon Thomas. I'm an artist at the Blender studio. I work on the open movies there, and I've also been involved with the Geometry Nodes development project from the beginning. So I have a lot of back and forth with the developers also designing the nodes there a little bit, and I use Geometry Nodes all the time. So it's fun. Yes, so for the topic of today, simulation nodes, just recently made it into Blender 3.6. I call it making nodes come to life because it's like a very low level approach of actually using nodes to define your own simulations. Okay. So the topic of simulation is very much linked to physics simulations, as you know it, but it can be anything basically that evolves over time more naturally. Like a classic example is the Game of Life, Conway's Game of Life, which is just a simulation of life in its simplest form. It's a cellular animation that's just evolving over time. And we're gonna talk a little bit before we actually dive into the example about what differentiates simulation and animation. And the main differentiating factor is that you actually have a set of rules that transforms a state over time rather than defining everything in a procedural setup altogether. We're gonna talk a little bit more about what that actually means. Yes, so the way the Game of Life works, it's basically is just taking the current state of dead and alive cells. I can just pause this for a second and then we see like this is the current state. And then there's a set of rules to say, okay, depending on the population of cells around one of those, there's an overpopulation or an underpopulation, we're gonna kill or birth some new cells. And then those are the only rules that define the system and everything evolves naturally from there. Right, before we get a little bit deeper into simulation itself, let's take a look at animation. Maybe I should have pre-compiled these shaders but we'll wait a couple seconds. So this is an example of using similar geometry nodes for something that could be a simulation, but it actually isn't, it's just plain animation. It's the whole system, the entire process of these shards flying around is defined procedurally with a parameter. So rather than actually taking the current state and transforming every single step, if I turn on the overlay, you can see that every trajectory of this system is predetermined. At any point of the animation, wherever I go here on the timeline, I already know where the shards are gonna be later on. The entire trajectory is always known. And then time is just a parameter that I plug into the system to just say, okay, now I wanna be here on the trajectory or here, depending on when I am. And with simulation, it works very differently. Rather than having everything predetermined at all times, things change step by step and I can change the parameters on the fly. Like for example, you have a controller object to give some input on the simulation and change how it evolves as it's already happening. And those are two very different approaches and something that not everybody feels super intuitively about, but it doesn't necessarily have anything to do with physics at all. It's just taking the stage with a certain set of rules and transforming it over time. So that's like the main differences, the difference between simulation and animation. Let's go back a little bit to the Game of Life example and take a quick look at the node setup. So there's a bunch of stuff happening in the beginning and at the end, just to make sure that these things render nicely. But the core functionality of this is this center part here that has this new kind of thing that we added to Blender, which is the simulation zone. We didn't really have something like zones before, but basically what that means is this purple underlaid area here is our confines of the simulation. Everything that happens in there happens progressively for each step of the simulation. What that means is that in the simulation input, in the beginning of the simulation runtime, I retrieve the incoming data. So there's some geometry going in and then some attribute information, some sort of data that I want to operate on going in and inside I get this same data accessible in the confines of the simulation. Do whatever I want with it and then pass it back out in the simulation output. And then this goes back out on the end as well and gets processed further just as we know it in geometry nodes. But then what happens on the next frame, if I just go back to the beginning, this is the first frame, it's running everything once. And then on the next frame rather than passing whatever I have in the front here back into the simulation, it's actually using whatever got into the simulation output on the previous frame and plugging it out here, creating this sort of looping behavior. So whatever information I got from the previous frame out of here, I get back in this input node. And then that way it creates this progression over time for every single frame, performing one simulation step. So one time this setup for every frame. Okay, that's a little bit abstract. That's like the idea of how this works. And the nice thing about having all of this implemented at a very core fundamental level of geometry nodes is that you can really do anything with it. And as I said in the beginning, it's not a physics thing necessarily. Anything that uses data from the previous frame and changes the progression can be built with this. But we're gonna go into a little bit more detail later. And then another nice thing about having all of the tool set of geometry nodes already available in combination with the simulation node setup is that you can just also create assets from it, package it in some sort of way that you can reuse it and then just slap it onto something like for example, here we have a 3D game of life running on Suzanne. Which was just a couple of nodes extra of what I already had and then it just works. Okay, now let's talk a little bit about the example that I'm gonna go over. So this is the target file that we're gonna build. We're gonna start basically from scratch. I've prepared a couple of assets that we can use to make this a little bit easier. But this is already what I showed you a little bit. If I just run the simulation, we can use this controller empty and then the simulation plays and it heats up the mesh wherever the controller empty is. And then you can also see that it affects the material, making it look a little bit more like it's melting. And also after it has been melted, it changes the look of this material to look a little bit more smooth and more golden. And then for the node tree, you can recognize this simulation zone. And there's a bunch of things happening in here, like we have the geometry passing through. We're gonna smooth this a little bit and deform it a little bit. And then at the end pass out the information so we can use it in the shader. But that much just for now, let's go into the details of how this works. Okay, I hope some people managed to find the files and actually set them up so that it can follow along. Otherwise, this will all be uploaded so feel free to do it later. This is the starting file. It's called stage zero in your folders. So you can just start from this. And the first thing that we're gonna do is as always working with geometry nodes, just create a new geometry nodes modifier. So far so good. Same for simulation nodes as anything else. Create a new node tree. And then we find the basically only new thing in terms of nodes that was added for a simulation, just the simulation zone. And that's all we need. Just connect that. And for now everything disappears because we are outside of the bounds of the simulation range, which is just frame zero. So let's go to frame one. And it does nothing, which is exactly what we told it to do. Okay, so the first thing that we need to do to be able to heat up this mesh is to actually track the temperature as an attribute. And for that, we need to be able to add this to the simulation in a way that it is part of this looping behavior. So we need to add it as one of the simulation inputs. Just press N to open the N menu. And on the node tab, with one of the simulation nodes selected, you can just add a new attribute. Well, by default it's a geometry, but let's change this to float and call a temperature. And then this is the data that you can use to track the temperature along the progression of the simulation. So for now, let me just add in another value node. And this is going to define our environment temperature because this is going to be the initial data for the temperature, what we start with before the simulation happens, which is just the environment temperature. And for our American friends, let's not use Celsius. So we're going with Kelvin instead. So 300 Kelvin is our environment temperature. And to be able to keep track of this throughout the simulation because what happens right now is on every single step, we just set the temperature to be zero. But that's not what we want. So we want to keep the temperature from the previous frame, like this, and just connect it. And then let's already take a look at this. I'm just going to change this to be a spreadsheet viewer. And then with Ctrl Shift, click two times, take a look at the output, change this to viewer node. And there you go. It's 300, which is exactly what we want. If we run the simulation, it doesn't change because we just keep it. But an interesting thing here to just point out is that as soon as the simulation runs because we're taking the data from the previous frame, this doesn't matter anymore. This input is not taken into account at all anymore. It's only the initialization. So if now I go back to the first frame because I cut this, everything is gone. But if the simulation already runs, this doesn't change anything anymore because it only takes the data coming out of the simulation input. It does not consider the one going in anymore. Yes, so to actually heat this up, go back. Let's also add another value node, which is going to be our heat source. I set that to 2000 Kelvin. And we're gonna just mix this into the current temperature by just connecting a mix node, plugging that in there, and then connecting our heat source temperature to the B input of the mix node. And if I just play this again, now you can see that the temperature is rising rapidly. So let's crank that down quite a bit and then, now it's rising. This is not very nice in visual so let's actually see something in the viewport, connect the map range node, set the from max to 2000, and now we should see a little bit better what's happening. So now you can actually see that the value is rising more slowly. But of course we don't want to actually just heat up the entire thing as one all the time. We want to be able to control this a bit better. And to do that, I added already in the asset browser a couple of assets that we're just gonna use. And one of those what we're gonna use now is the controller influence node. You can just drag and drop that in here. And then select the controller empty using the eyedropper. And if I now just to preview this, click on the group input and then the controller influence. You can see exactly what that does. It just gives us a mask from zero to one. Exactly with the scale and the dimensions and everything of the controller empty. And then there's some parameters to define the falloff and just the factor of this. And then this is what we're going to use for the heating process. So let's add another value node, which is going to be the heating rate. Plug that into the factor which is going to be the strength of this. And this is going to be 0.05. And then instead of just the single factor for everything we're gonna plug that right into that mix node. And then if I go back to the output here and preview what's happening here, you can see how now we have nice control of what is actually heating up. And that's already a pretty important chunk of the simulation done. This is also completing the first stage. So if anybody got lost somewhere, you can boot up the stage one file. I'm gonna take a sip of water in the meantime if you wanna play around with the thing. Okay, I'm hearing not many people are following along because maybe I did make it clear enough that there's actually some opportunity to do that. But I'm gonna try and go a little bit faster then. Maybe I can take some questions in the end. So I saw for the people at home, you'll have to pause the video. Yes, so this is the first stage. Next thing that we're gonna do is actually use this for the shading information. So for now, let's just select the object, create a new material and then open the shader editor to be able to replace this. We're not gonna use the principle PSDF but instead I just prepared another asset that we can use, let's connect this. Oh yeah, right now we're looking at the previews still. So let's just control shift, click somewhere randomly. And oh yeah, right. We're not actually assigning the material. We need to actually use the set material node and then set this material to be the one that we just created and there we go. Now we can see there's a couple of parameters. One which is the most important one is the temperature which right now just looks like this and then also the attribute to track whether or not something was already molten in the past. And we're gonna use this later on as the information that we get from this simulation. Right, so to actually pass this information out of geometry nodes and into the shading system, we'll need to use the store named attribute node. Well, this is at least one way of doing it, which I'm gonna do now. Call this temperature with a capital T and connect the temperature output that we get from the simulation. So the reason we need to do that is that so far we've just been naming node sockets and pass around the data of these sockets as noodles in the node tree, which is perfectly fine. That's a great way to work with geometry nodes, but we need some way of referencing these attributes outside to be able to read them in the shader. So we need to give it a name. And then we can in the shader network just add the attribute node, also type in temperature and then connect it. There we go. And now we can actually use the information that we're writing in the geometry node system in the shader. But instead of just heating everything up all the time, let's try and make this a little bit more realistic and also cool things down. So I'm gonna just add an additional mix node and then add an overall cooling rate. Set this to 0.01 and then connect that over there. And what we wanna mix into this is the environment temperature because what we're cooling it with is just the environment. So when everything is cooled back down, it's just going to be the environment temperature. And then if I let this run and I move the controller somewhere else, you can see how now it's slowly cooling down again. And then one more thing that I wanna do with this heat attribute is to add a little bit of something like heat distribution. For that, I'm just gonna use the blur attribute node, which is just going to blur the attribute over the topology of the mesh, which kind of simulates this effect of the heat dissipating over the surface rather than sticking in one spot. We can just crank up the iterations of this a little bit and then add another value node. Set this to 0.5 and that's gonna be our heat distribution. And this effect is relatively subtle, but it does make a difference. So this is the second stage complete. So if you're following along, you can check out the stage two file. If you got lost somewhere along the way. So far we only actually considered the effect of the simulation on the shader to make a change in how this actually looks under being heated up. But now let's also actually affect the mesh. And the first thing that we're gonna do is smooth the features out a little bit, which happens when you melt something. And for that, I also prepared a little node group and just drag and drop the smooth mesh node group into the shader node setup, jumpy node setup. And if I just leave that in there, crank up the iterations to five, you can see how everything just gets smoothed out iteratively. But of course, it's not what we want. Let's put down the weight a little bit lower to make this effect happen more slowly. But on top of that, of course we also only want to have this affect the area that is actually in the process of melting because it is heated up. For that, we need to create a mask for things that are melting. So I'm just going to take the current temperature at another map range node. And then we need to decide what things, what temperatures we want to use as our limits for melting. So I'm gonna say that things start melting at 500 Kelvin and then start melting more increasingly strong until 2000 Kelvin. And then we can just simply use this mask. Let me just actually show what the result of that is with the viewer. So you can see how as things cool down, they stop melting and as they heat up, they start melting. And here you can also see a little bit the heat distribution kind of morphing everything a little bit. And then, and then we want to use this mask to influence where things are being smoothed out. So we're just gonna connect this to the blend input of the smooth node. And then we rerun the simulation. You can see how things that are not actually hot currently are sticking to their shape. And then as I move this controller empty over these features of the face, they start melting away. Well, smoothing away for now. And then on top of that, we also want to have this melting effect reflect back on the material. So remember I had this mask that I could use to keep track of things that have molten in the past. And for that, we can't just take the current temperature because that doesn't take into account what happened in the past. It just cools back down and we don't want things to un-melt, basically. So on top of the temperature attribute, we also need to add another attribute to the simulation, which is also going to be a float mask. And I'm gonna call this one molten. And I mean, for now, we can just take this mask of what is currently melting. To be able to see it in the shader, we need to do the same thing again of storing the attribute. And then we can use it over there. Just gonna copy and paste this. But then the thing happens that I mentioned that we don't want, which is that things just un-melt again as they cool down because we're not keeping track of the past. We're only using the current molten attribute and ignoring whatever we got from the previous frame. So what we need to do is actually take that into account and let's use a maximum node to combine this with the current state. So we're gonna use the previous frame and if that is higher than the current one, we'll take that. Otherwise, we take the current one and that way we just increase the molten status but not reduce it anymore. Replace that with the output. And then now as we go over the mesh and melt things away, you can see how the material changes and it does not go back to its initial state anymore. Yeah, and that's the next stage complete. So that's stage three if you have the files. And next time I want to add a little bit more interest to the way that this mesh is deforming because right now it's just kind of smoothing out but it's not very interesting the way that something that melts would like flow down or drag a little bit down. So we're gonna add that. And for that, we're gonna need to deform the mesh and whatever you need to deform a mesh, you're usually gonna want to use the set position node because there we can specify a different offset for all the vertices to make a little bit of space. And then here, let's add a scale node because we're gonna use a vector for the direction but because we're gonna do this every single frame, it should be relatively small. So it's scale this down by 0.1, 0.01 and go negative one on the Z axis. Let's just see what it looks like. Okay, obviously that's not what we want but it's going in the right direction. If we now just add another scale node and then use the mask that we already created for the melting parts of the mesh, you can see how this is kind of working out. Looking great. If I go back to the shaded view, you can also see that there's a little bit of an issue with the texture because this is a procedural texture setup with a 3D noise just creating this. So as the thing is deforming, the coordinates also change, which changes the texture. To avoid that, we can relatively easily just in the data menu of the mesh, click the add rest position toggle in the shape keys panel and that will make sure that the mesh stores an attribute that remembers the resting position before it was deformed. And then instead of using the current coordinates, you can go into the shader network and another attribute node and then type in rest underscore position, all lowercase and use that for the coordinates instead. And then you can see how the texture nicely sticks to the surface. But yeah, there's still some things to be improved about this. So instead of just moving everything straight down, I wanna add one last thing of assets that are prepared, which is the aligned surface tangent node, which will give us a vector that is aligned, well, towards the tangent of the surface so it's always going to flow along the mesh, basically. And it aligns it to a vector that we input, which is, we want to have it move down. So it's just gonna be the negative Z, which is already in here. And then we just plug that in there to see what happens. And you can kind of see that it somewhat keeps the shape because everything is moving around the mesh, but it also creates this weird artifact of the mesh kind of folding in itself. It's a cool effect, but that's not what we want. So instead of just using this straight as it is, let's mix in another vector. And for that, let's just take the negative one on the Z axis. And then you can kind of blend this however you want. I'm just gonna stick to 2.5. So it's gonna do kind of both effects of everything flowing down and along the surface. And then one more thing that I want to change about the direction of this deformation is I also want to add in the normal direction. And if I just leave this mixed value at 0.5, it looks a little bit more like a baking simulation than melting, which if you're going for that, then you do you, but let's go for 0.1. And that makes everything just a little bit more puffy and loses a little bit more of those features and makes things a little bit expand as it's melting down. And yeah, I mean, this is already pretty much most of the setup, let me look at my notes. There's one more thing that I definitely want to do, but oh yeah, I wanted to mention one other thing. So if you've been working with geometry nodes in general, then this is probably nothing new, but all of the stuff that we've been doing in here is happening in the local space of the object. So this vector that we've been defining, negative one on the Z axis, it's not a world space. So whenever I rotate this thing and just run the simulation again, everything is gonna move to the side because it's always gonna just move down in the relation to the object. So just keep that in mind whenever you build these simulation setups. So whenever you actually want to use world space, you need to calculate the vector into the object space. Okay, so as one last thing that I wanted to do with this setup, let's make this a little bit more reusable. So for that, I'm just gonna make this an asset. It's an unpinnedness, so I can name this melting bronze. And then mark it as an asset, right click. And now it already pops up over here in our asset browser. And let's give this a nice thumbnail, which... Oh, look at that, there's already one here. Let's take this one. And now you already have an asset that you can just slap onto anything as a modifier. And it will set up a melting simulation for you. So let's do the classic, add a monkey, add some subsurf, and drag and drop that on there. Add the rest position here as well to make sure that it works with the texture. And now if I go over there, you can see it just works. But this is not how you do it. You do it differently. So there's a big mistake in here. We're actually referencing the controller object inside of the node tree, which, I mean, sometimes that's what you want, but in this case, that means the node tree of this, that we want to make reusable in different contexts, relies on this specific object. If I'm in a different file and I just want to use my own controller empty, I need to be able to set a different empty for each time I use the melting setup because I might not want to use the same empty for everything. So to do that, I'm just going to remove the reference to the controller in the node, and then instead expose the socket to the group input, which makes it pop up here in the modifier settings. And then there we can just select it again. So everything still works perfectly fine. You know that. Everything still works perfectly fine with the controller that we set up. But obviously now Suzanne is missing her controller object. There's nothing in here. But now we have the choice whether or not we want to use the same one or just duplicate it, and then reference that new controller empty to have separate controls for Suzanne and the statue. So usually I would recommend to not create references to data blocks or like specifically objects or collections inside of the node trees. Unless you really know what you're doing, it's usually better to expose it in the modifier and then use it there that saves you from a lot of hassle potentially. And yeah, that's the setup for the workshop already done. This is the simulation all set up. Let's wrap this up a little bit because I have a little bit more time by just giving a little bit of an overview of like the points that I was trying to make with this video. It's not a video, sorry, right? Forza have it. Right, so the idea with the new simulation node system is to integrate in such a fundamental and low level way that people have the tools that they already have accessible with geometry nodes in general to build their own custom simulation setups. And it's important to understand that simulation does not necessarily mean physics. Simulation can mean anything that makes a more natural progression between different states following a certain set of rules. And the great thing is that like this, you can actually make use of all the things that are already in geometry nodes and are being added to the ecosystem of geometry nodes to build simulations. It's just a general addition of access to the progression of data over time to just wrap it in one sentence. And that opens up all sorts of new avenues for procedural setups rather than having to pre-define absolutely everything at once but being able to make a natural progression which can also be a performance thing because you don't need to calculate everything on the spot. And yeah, that's all I wanted to say. If you have questions, we have some more time. Yeah? Right, so the question was if the store rest position option that's here has been added with simulation nodes before. It's been there before. I am trying to remember when exactly. I think it came with the hair tools. 3.5, you're the expert. So the question is what it was for. So, well, anything that requires procedural textures that like for example for charge, I believe we use a lot of procedural texturing and it's a lot easier if you have the information of the resting position. Regardless of simulation, things deform. So it's good to know what the shape was before they deformed to actually use that in your setup. Not only just for shading, but for geometry nodes in general. For example, whenever a mesh deforms and you have a procedural setup on top of that, like for example distributing hair, it can be useful to know the initial distribution to not have hair popping up randomly all over the place. It's a question in the back. Oh, sorry, two people at the same time. The very back. Right, so the question was to, is there a way to consider the world space? There is no like pre-built thing in geometry nodes as of now. Everything happens in local space, but one simple way of getting a reference space is just by using an additional object, like something, oh, wrong node. Something that I do a lot whenever I need to do this is create an anchor empty that gives me a space which if I don't do anything, it's just gonna be a world space and then use that to calculate my space in geometry nodes. It's a little bit finicky, but it works. And then, yeah. So the question is can I have this also run on every second frame or any number of end frames? And sure, I mean, you can do whatever you want. You can add a switch node. I'm not gonna try and do it right now, but you can do it with switch nodes. And then the next version, I think in 4.0 there's gonna be also a toggle to skip frames. And then, yeah. Sub steps, you can, but you have to do it manually right now in here. In the future there's gonna be a more automatic solution. The question was, is there any limitation of what you can expose as parameters in animate? No. No. In the back, yeah. The question was, it's both mesh resolution and time or frame rate resolution, frame rate depend. For the frame rate, there's a delta time parameter that you can use to adjust your individual steps. And for the mesh resolution, I mean, it's the same as for geometry nodes in general, you have to take account, you have to take it into your account in your setup. It's all custom right now, so. Also in the back. Right, so the question is, how do you cast this? In 3.6 right now, there's in the physics tab, there's a simulation of the tab that you can use for baking this. It's right now still very limited, but it's being expanded with more functionality for the upcoming versions. Yeah. Yeah, so the question is the built-in hair nodes assets that we have, is there gonna be something similar for simulation? And yeah, the answer is yes. At some point, there will be. That's the direction that we want to go into in general for geometry nodes to build these more higher level node setups that just any artist can just use it and don't need to think about geometry nodes too much. But same as with the hair setup, the approach is to just build the fundamental functionality of everything. First, in the first release, just make it usable for people that actually know what they're doing. And then build tools on top of that using all the same functionality that is already exposed to the user and make it more user-friendly. That's the idea. Yeah. The question is, does this have the potential to eventually replace the current simulation system entirely? I mean, you have to consider that this is just local simulation. Like, you can't really do interaction between different simulation systems like this right now. You can kind of like hack your way around it if you want to a little bit, but it's gonna require something more complex to do different things. But I mean, the idea is to expand this with more and more functionality and take over outdated areas and simulation for Blender in general. Yeah. I don't know, maybe at the conference here to get inspired and see some random thing on the wall and I don't know. I'm sorry, I don't have it. I don't have great examples right now. Usually I just take whatever we do for the work at the studio and try to figure something out, which is very nice because I don't have to think about use cases too much because they just present themselves to me. Like you were asking for like, how was the workflow usually? As I understand the question correctly, like what's the thought process into like making one of those things? Where do you start or? I mean, usually when I, like personally when I work, I usually have like a specific target in mind and then try to figure that out. And then from experience of course, the more you actually use the system, you get familiar with the tools that you have to use to your advantage and you just get used to the different approaches and that's just, I mean, there's a lot of nodes but there's a certain amount of approaches that you take usually and then you pick one of those that makes sense. That's it for me. Yeah, you've been raising your hand for a while. Yeah, so the question is about performance or simulation with geometry nodes. Of course, because the way that it is built right now, like without these presets that we're gonna add everything is very custom. Of course, you'll have to consider the performance while you're building the system also but the good thing in the way that this is integrated into geometry nodes is that any performance improvement that comes to the core nodes will propagate to anything that you build using them. So any of your setups will benefit from the future improvements to geometry nodes as a whole. And of course to build truly performance simulation setups, there's a certain set of low level nodes that need to be added for certain simulations to make these things a little bit more straightforward and that's gonna happen in the future as we're going to add more and more of the simulation capabilities to geometry nodes. The question is about the game of life on Suzanne. That was just instances of cubes on the surface using the phase area to scale them up and make it look a little bit nicer but it's just instances. Okay, more questions? Yes, the idea, so the question is about the new hair system and simulation for that. So the idea in general with simulation nodes is also to use that for the new hair curves and not like try and rely on the old system and then replace it with this but there's some more groundwork that needs to be set for that but that's the idea. And with that, I think we had enough questions. I'll just wrap this up and thank you for the time and I hope you enjoy the rest of your conference.