Hello, everyone! My name is Iago Mota, and
before we get started, I want to emphasize that this video is directed to somewhat advanced
users. I'll be skipping over most technical elements here. The more "tutorial" part of this
video will be less of a step-by-step guide, as it'll mostly focus on my general
process and approach. So, the most important part of the video is right here,
with these three pieces of technical advice. So, with that out of the way, let's begin on
attaching texture coordinates to particles. Unfortunately, there's no tool in Blender (as
far as I know) that is specifically meant for this sort of thing. So we need to improvise. To do
that, let's look in the Particle Info node to find something useful. So, we need 3-dimensional
coordinates, gradients that describe the X, Y, and Z axes. And these coordinates need to be
attached to the particles, so that, no matter where they move, the texture will follow. In other
words, here, we need to find at least 3 attributes (assigned at birth to each particle) that do not
change over time or location. Well, we have Index, Random, Lifetime, and Size. Since Random is
assigned, well, randomly to each particle, without any way to control it, it's not
useful in this case. Particle Index is the order in which they're born; this way, the first
particle to be emitted has the value of zero, the second has the value of one, and so on.
Lifetime is a value that describes the number of frames that a specific particle will exist for.
And, Size is, well, the size of each particle. So, all these are static values assigned at
birth to each particle. To create the X, Y, and Z gradients, let's just start with particle Size
(that's the easiest property to visualize). So, to create the X gradient, let's give the particles
a gradient texture. We want it to only influence the size of the particles. And you can leave the
coordinates at Generated or set them to an already existing UV map. Now, I don't want there to be a
notable size difference between them like this, so I'll lower the influence to 0.1; this way, the
smallest particles are only 10% smaller than the biggest ones. No visible size difference, but
enough for us to easily use a Map Range node to remap the maximum and minimum particle
sizes into one and zero. This way, in the shading process, we'll be operating on a much
fuller gradient than just a tiny portion of it. Now, we just need to do the same thing with
Lifetime, except with a vertical orientation, to make the Y-axis. I'll make sure to update the
maximum and minimum values on the new Map Range node to correspond with the maximum and minimum
Lifetime. And now, we've got X and Y coordinates. Fortunately, particle Index is a bit easier. The
particles are moving in a stream, which means that the value is already growing in a steady
gradient. Now, this simulation has about [20000] particles in total. Knowing how the particle
Index increases by 1 for each new particle, in the end, our last particles are going
to have the brightness of [20000-1]. That's a bit much; we only need a gradient that
goes from 0 to 1 or 2, so let's add another Map Range node to squish that this into something
more workable. Now, all that's left to do, is to combine these gradients into a Combine XYZ node
and boom. Textures that stick to the particles! But wait! What if my particles are being emitted
all at once? How do I turn the Index value into a gradient then? Well, I'm glad you asked because,
as far as I know, it's impossible. (pause) Yeah, I'm really hoping for particle
nodes to make this video obsolete. Moving on to secondary particles. The idea
is to copy an object onto all the particles, and then use those copies as geometry from
which to emit new particles. This isn't possible by going into the particle settings and
rendering the particles as an object. The way that works is it visualizes and renders the current
particles as another object, but doesn't actually create any real geometry in their place.
The practical way to do this is through the particle instance modifier. What this does is
duplicate the selected object onto particles. This time, however, it produces
usable geometry that we can add modifiers to, including a new Particle System.
These are the settings that are usually useful in this modifier. They're pretty straightforward.
I tend to disable "Dead" and "Unborn" so that the object is only duplicated onto particles
that are currently alive. And it's also good to enable "Size" so that they take on whatever
scale is set to them in the particle settings. So, there it is. All we need to do
now is add a new particle system. Now, it's behaving a little weird because
it doesn't actually recognize the Particle Instance modifier. So, to change that, let's
just enable "Use Modifier Stack" and that's about all you need there. By the way, a quick
thing to note is that secondary particles are incredibly buggy with Object Velocity, so
that's a combo you might want to avoid. By the way, if you've ever wondered if it's
possible to duplicate force fields onto particles, yes, it actually is. This is something that I
really wonder about how particle nodes might handle it, really interesting. This can be
done in the Force Field Settings panel. Just set one of the Types into any force field in the
list, and boom, there it is. "Effector Amount" controls how many of the particles act as force
fields (zero just makes all of them have this effect). And, "Self Effect" enables the
force-fields to influence each other or the current simulation. I usually use this
method by having a separate particle system specifically meant for this, so that I can
have a bit more control over everything. And I also tend to increase Falloff, to keep
their area of influence relatively small. So, with these little nuggets of
technical info out of the way, let me show you my general process
in making particle simulations. Firstly, this is the reference that I'm
looking at, by the incredible MatthiasM. A link to his page is in the description,
along with links to several other artists I think are fantastic sources of
inspiration for these kinds of effects. For the initial part, I'm essentially stealing
this nebula effect that Matthias made here. Now, just by looking at this reference, let's
try to think of a way to replicate it in Blender. For me, it's rather tempting to look at
all these shimmering details and color variations. But that's never a good idea. Focusing on
the details just leaves us overwhelmed, along with distracting from the most
important elements. The details, as a whole, can only look good if the general structure
does. So, if we zoom out, for now, we can see that the particles do follow an overall form. Now,
I don't know how Matthias approached this effect, but one possible way to do this in Blender might
be by just creating a mesh with a similar shape and emitting the particles from its volume.
Now, usually, there are multiple ways to create the same kind of effect. This one,
for example, was created with a flat emitter going up and leaving this sort of tube of
particles. So, just because this is the idea that I got from looking at the reference, doesn't mean
it's the only correct approach. Anything that gets you to the end result is a technically correct and
valid approach. So, if you came up with something different, then try it; see its advantages
and disadvantages, and see where it takes you. The way I created the emitter was quite
fun, but not particularly important, so I'll skip over most of it. The plan was to
create a path of vertices in an interesting shape and add some dimension with a Skin modifier.
After that, I transformed it into a volume object, so I could add some really wild displacement,
that'd be impossible to do in a mesh. Lastly, I converted the volume back into a mesh,
so now we have something useful for an emitter. A good thing to note is that Blender has a really
hard time calculating the particle simulation if the geometry is highly detailed, so I gave
it a Decimate modifier to simplify it a bit. So, let's go ahead and add the particle
system. Now, I don't tend to organize my projects ever. But despite my immensely
rebellious spirit, I have to concede that this is going to be a really complicated
scene. I'll be naming everything and moving things into collections quite often. Because I
want the particles to just appear all at once, I'll set the End frame to 1. And, of course, I
need to get rid of Normal velocity and Gravity, since I want these particles to remain
unmoving for most of the time. Also, right now, they're only populated on the surface of the mesh.
Since I want them to appear inside the emitter, I'll change the emission source from "Faces" to
"Volume". However, you can see it's processing a lot slower than when we were emitting them
from just the faces, so I'll change it back for now. I'll switch it to "Volume" again when
we start getting into shading and rendering it. Since this will become useful in the
future, I'm adding a particle object, a small mesh that these particles will be
rendered as. For this, I usually use a cone with a total of 4 vertices because that's the
least complex 3-dimensional object. So, it won't be too difficult to render when we finally end up
with millions of particles like this. I'll just name it, throw it into a new collection, and set
the particles to be rendered as this new cone we added. And there it is. Now, of course, we need
to randomize their rotation, and I'll just turn on "Dynamic" so that they'll rotate according
to changes in movement. For this simulation, I won't add any angular velocity. Otherwise,
with the slightest movement, the rotation of the particles would change quite drastically,
and that's not what I'm looking for here. Alright, I think I'll just get whacky and give
these particles texture coordinates already. Usually, I'd leave these sorts of things for
later. It's always best to ensure that all the basic shapes and movements are there first
before you get into any of the fancy stuff. But, in this case, this is such a technical
thing, that I just want to finish it already. Since we're emitting all particles at once, we
won't be able to use particle Index on this one. We're going to have to work with
two axes, X and Y. For the Z-axis, I'll just use the global Z-axis coordinates.
This means that the textures won't follow the particles at all if they move in the Z-axis,
but, at least there'll be some depth in them. So, let's get to work on the X-axis.
As we saw in the beginning, we add a texture to the particle system; in this case,
a Blend texture, to create an even gradient. And, we're going to have it
influence the size. And, again, I turn the Size influence to 0.1 so that
the particles all look the same size. So, working on the Y-axis, we're
going to do basically the same thing. The only differences are that the orientation
of the gradient should be vertical and that the influence is set to "Lifetime".
I had it at "Scale" up until now, just because it's easier to visualize. So, of course, I'll
again set the influence to 0.1, and increase the Lifetime in the particle settings to prevent any
of them from disappearing during the animation. Now, this part is a little subjective. So,
not at all necessary for you to follow. I just didn't like how even the whole thing looked, so
I wanted to add a Turbulence force-field that'd only influence the simulation for the first second
or two. That way, we'd have a bit more detail in here. After animating the strength to zero after
40 frames, I went to the particle settings and increased the Dampening so that they'd slow down
to a halt soon after. That way, I'd be able to start rendering from frame 50 or 60 without seeing
any weird turbulent movements in the particles. Anyway, let's check out the reference again. In
terms of basic structure, I don't think we've missed anything. However, there are these particle
trails here and there that add an interesting level of detail to the render. I feel like we can
replicate that by having a few particles moving in these fun patterns, and have them emit secondary
particles. Those being the ones to be rendered. Before we can have those secondary particles,
we first need to deal with the primary ones. Again, I want these particles to be emitted all
at once and, of course, without falling down. We can already see something rather
inconvenient. This second particle system is being influenced by the Turbulence
force-field I made only for the first one. So the best way to deal with this is by creating a
force-field collection for each particle system. This way, different particle simulations will
only be affected by the force-fields in their respective collections. All we need to do
now is go to the "Field Weights" panel and set the "Effector Collection" to be
the one we made for this simulation. And finally, the second particle simulation isn't
affected by the force-fields of the first one. So, let's start making the force fields
for this second system. For this, I'm looking for an almost smoke-like motion.
How about a Turbulence force field? Well, using this hair particle setup, we can see how it
doesn't produce interesting patterns, so instead, I'll try something else, namely, a Texture
force field. I don't want anything too fancy, so I'll settle for a simple Cloud texture. Every
time you make a change in here, you'll need to go all the way back to the physics settings for the
viewport to update, which is a little annoying. That's why I'm splitting the screen, so I
can go back and forth quickly. And here, I'm just aimlessly changing the settings to
see if I can get something that looks cool. I don't even know what "Nabla" does; other
than make the result somewhat less turbulent. Finally, the "Curl" texture mode bought the kind
of motion I was looking for. You can already see some twisting here. And yeah, that's pretty much
it, really. Let's move this test subject into another collection and get back to the particles.
So, the movement is already much more interesting than what we had before, but there's one
crucial thing to note here. These particles are, in essence, going to emit more particles in each
frame. That's important to note because if one of the primary particles takes a leap from one frame
to another, the secondary particles won't be able to form a proper trail, creating gaps between each
location. So, we need to make sure these particles are moving slowly. For that, I mainly reduced
the strength of the Texture force field. And, well, it got to a point where I had to
push the start of the render to frame 80 to give the particles time to have a
more complete motion. Which is really not a big deal. We can extend the end of the
animation later if it becomes necessary. Alright, so let's get to the Particle Instance
arc of the manga. For the instance object, I'll just add a cone. There aren't many primary
particles, so I could've safely added a sphere, but I went with a cone nevertheless. I recommend
you also number the objects and simulations to remind yourself of the order in which
everything should be cached. Now, after that, I gave the cone a Particle Instance modifier. And,
of course, selected the intended particle system. To clear things up, I disabled unborn and
dead particles, although, in this case, we'll actually want to leave "Dead" enabled. I'm
turning it off, though, so that it can become relevant later. We're not adding any UVs to the
primary particles (only to the secondary ones). So we can freely give these some size randomness.
And, while I was at it, I decided to randomize the rotation as well. Which isn't necessary, but eh.
Anyway, let's move on to the secondary particles. Let me cache this second simulation first, just to
avoid any funky behavior later on. And, as we went over at the start, Blender doesn't automatically
identify the modifiers. So we need to enable "Use Modifier Stack" to fix that. And, as usual, I'll
go ahead and minimize Normal velocity and Gravity. In fact, I don't want these particles to have any
movement before that splashing effect towards the end. But, I'll already create a force-field
collection for this guy just to keep things organized. I'll change the End frame to 80
because that's when the primary particles vanish. In fact, no, I'll change that to 79, which
isn't really necessary. Blender just has a weird tendency to almost emit extra particles
right after the primary particles have died, so I feel like setting the End frame to right
before that would counteract it. Now, I'm just changing the (viewport) particle size and their
amount to get a better view of what's going on. I think it's already time for us to give this
guy a particle object for it to render as. So, I'll add another low-res cone
and do all the organizing business. A lot of this stuff is kind of a grind, so I
want to emphasize that if you're following along, don't try to copy the settings here. It's
a lot better to experiment with the values until you get something that you personally find
appealing. Which is what I did. It took me a week to record all the screencap content for this
video because most of my time spent here was in experimentation. So, don't see this part of the
video as an exact recipe for this specific render. Alright. It's time for us to
make the UVs again. Same process, and whoops, we already find an issue. The gradient
doesn't reach the boundaries of the simulation. Now, can you guess why this is? I do
actually recommend that you pause the video to think of this because that's usually
the best way to solve these tiny problems. The diagnosis is that the bounds of this
object don't encompass the whole simulation. They only apply to the original instance object.
Here's one way to solve this. See, the bounds of a mesh only extend as far as its vertices go.
So, all we need to do to make completely custom boundaries is to place two vertices opposite
each other. To determine where to put them, I just added a cube and scaled it around the
particles. Now, any two vertices opposite of each other can be used to describe the bounds of
this box. So, just copy and paste them into the instance object, and boom, the gradient's already
covering a much wider area. For whatever reason, this isn't very accurate, so I'm just using the
Color Ramp feature to compress the gradient a bit. Moving to the Y-axis, the same story as before.
What really matters now is what happens when I move around the timeline. You can see that,
right after frame 80, this effect disappears. There's no defined gradient. Since we set the
primary particles to all have a lifetime of 80, this instance object pretty much vanishes
after frame 80. Leaving nothing for any texture coordinates to be generated from. If you
remember from a few minutes ago, there is a way to keep the instance object still visible in the
places of the particles that have died. Over here in the Particle Instance modifier. The nostalgia
is extraordinary. Anyway, let me finish up this texture, and increase the Lifetime (I don't
know why I had it so low to begin with). Alright, so far, this is what we've created.
As you can see, I've rendered a preview, which is crucial. Even though there isn't much
movement going on here, getting an idea of how everything will be like in the end is vital.
Unless you have a really unfortunate time limit, it's best not to speedrun towards the final
result. Make sure everything looks correct before we complicate things by moving to
more advanced steps. Having to change the shape of the emitter after you're already
done with the shading would hurt. (A lot.) Anyway, there's a second part to this simulation
I want to create: a sort of transition into this red, intimidating look. During that, the particles
would splash in a liquid-like motion. Which means I'll have to create a liquid simulation
and make the particles follow it. Now, this force field here used to be called
Smoke Flow. It allowed for particles to follow the movements of a smoke simulation.
Recently, it's been changed to "Fluid Flow" because, as you might've guessed, it also
allows particles to follow liquid simulations. I know it's really annoying when I do this, but
I have to, as these are pretty extensive topics. I'll skip over most of my fluid simulation
process. It's just not what this video is about. Boom! In a new collection, I'll add a domain
object. I made this mesh a liquid emitter. That's because I wanted a medium that the splashes
could propagate and ripple through. Now, this irregular-looking object here will be
doing the splish-splashing. I'll animate it to have some wacky moves (making sure to add some
Initial Velocity). Alright, I have everything set up for the simulation, so boom! Test bake.
Gee willikers, it's going wild! Guess I can add some viscosity. Oh yeah, and a Drag force field
to slow things down to a halt. I didn't want the simulation to just keep flinging itself forever.
Boom, bake again! Dang it, that's not what I wanted. Changing settings, and
gosh golly, let's bake this bonkus! Eventually, after messing around for long enough,
I got a result that looked pretty interesting. These spheres, by the way, are collision
effectors. I just added them there to break up the movement of the liquid a bit. Just
to prevent these parts from moving too much in straight lines. Also, I really liked this
unexpected interaction here, where this splash slams through a part of the simulation. It was an
accident I wasn't looking for, but I welcome it. I suppose it's time to make the particles follow
in that movement now. I'll do this with the Main Particle System first. So, I'll add a Fluid
Flow force field into the proper collection. My starting values for Strength and Flow are 5 and
2, respectively. They're only good values to start with; I'll come back to change them later. Make
sure to select the proper Domain object. To avoid any possible glitchy behavior, I'll animate the
Smoke Flow to only start having an effect when the liquid simulation begins, which is at frame 180.
Frames before that would be before anything has been cached in the Liquid Domain. So, it doesn't
make sense to have the Fluid Flow influence the particles then. Alright, now I'll just bake
the simulation to know what settings to change. After the first test bake, we can clearly see
that the force field only has a tiny effect on the particles before they slow down. This could
be due to the "Flow" factor being too high, but then I remembered how much we increased
the Dampening in the particle settings. We did that to only slow down the initial
turbulence. We don't need it to stay this high for the rest of the simulation, so I'll just
animate it to go back to 0 in a few frames. Things are already looking a lot more interesting,
but it's still clearly being held back a bit. It does look like the "Flow" factor
was a bit too high, after all, so I'll just decrease it. Once again,
it'll be this back and forth of baking and changing settings. The inescapable
truth of computer simulations, I suppose. For the Main Particle Simulation, I ended up
with this result, which I think works quite well, so I'll just move on to the secondary particles.
I'll duplicate the Fluid Flow force field, move it into the effector collection of the
secondary particles, and bake the simulation to see if we need to change any settings there.
So yeah, this is what we got now. Moving around the timeline, we can see some
really cool details all around. Alright, that was a lot. It's time to finish this
up by briefly talking about shading. Why, though? I mean, half of my time on this project was
spent on shading. So, why am I summarizing this? Well, when it comes to particles, shading is
pretty subjective. Sure, if you're doing some more high-level stuff, there are right and wrong ways
to deal with all the technical and mathematical problems. But when it comes to most of my particle
projects, their shading is not so advanced. Time-consuming, for sure. But, to really explain
all of this, they're just combinations of textures with different values and colors. Who's to decide
on what's the right way to combine these textures; on what the correct values and colors are?
Besides, If I were to explain all of the trial and error I did here, I wouldn't
just obfuscate the point of this chapter, I'd also be requiring myself to put effort
into writing it, which is a big nono for me. So, while setting everything up, I gave the
first particle object a new material and brought that same material to the emitter. It's nothing
crucial; it just makes everything a bit easier to work with since I won't have to go back and
forth between the emitter and particle object. Alright, let's get the technical stuff out
of the way. Let's actually create the UVs, the texture coordinates. With this Particle
Info node, I'll use the Lifetime and Size outputs to generate the X and Y coordinates.
Let's look at Lifetime first. You can see here, it's set to 500 frames. Keep that in mind; it's
the maximum Lifetime the particles can have. And remember what we did with the
particle textures; they only have a 10% influence on these attributes, meaning that
the minimum value for Lifetime is 450 frames. So, I'll just type these values into a Map range
Node, and It'll remap them into the values that we have down here: 0 and 1. As you can see in this
top view, we have a pretty neat Y-axis gradient. Moving on to Size. Let's take a look at the
maximum scale the particles can have. Which is over here, 0.005. And since particle size is
something that I end up messing around with a lot, I decided to use a Math node, so I won't have
to Multiply these numbers in my unreliable flesh brain. So, now it's multiplying the
maximum particle size by 0.9 to generate the minimum size. And, if we take a look at
this here: boom, an X-axis gradient. Dope. Remember, we couldn't generate a Z-axis gradient,
so we have to rely on global coordinates. In other words, the current location of each
particle around the scene. If we separate the X Y and Z coordinates of the "Location" output,
then we'll be able to specifically focus on the Z-axis information. As you can see, it's a little
different from the other gradients we've made. Its Zero value is centered a bit better so that above
it, there are positive values, and below it, there are negative values. Now, I apologize for
the stupidity and pointless inefficiency you're about to witness. I could've just changed the
lower minimum and maximum values of the Map Range to -2 and 2, giving us a range similar to what
we saw in the Z-axis. But, for whatever reason, I didn't notice that it was an option, so,
instead, I decided to do the same thing, but with a whole new Math node.
Alright, to finish the UV creation, let's just combine the X, Y, and Z gradients into
something that we can use for actual textures. And, on the topic of actual textures, let's do
that. The first texture I'm focusing on would be for these large blue zones. I decided to
start with a Noise texture, and some assisting nodes to help visualize it. I wished to move the
texture around to get different variations of it, so I added a Vector Math node. No fancy math
went into this; all I did was grab one of these values and cranked it randomly, which moved the
texture and gave me a new pattern. That's what I spent my next 20 minutes on, mostly just messing
around with the scale and location of the texture until I got something that looked interesting. And
every time I got a result I wasn't entirely sure about, I duplicated that node setup for later use.
Alright, so after a while, this is what it looks like. I've taken some liberties and added this
second part. So, just to summarize, this first part is the large-scale pattern. And this second
part adds some finer details to it. They're both combined here, with this "Overlay" Mix node.
With the foundational elements out of the way, I started working on the colors and the
brightness. So, I went ahead and added an Emission shader already, along with a couple
Color Ramp nodes for the strength and color. When I got that to look okay, I moved on to
these orange details that we can find around the reference. The textures of these details
seemed pretty interesting, so I decided to change my workflow a bit. I do this a lot
when dealing with bigger texture setups. My computer is way too slow at previewing this on
hundreds of thousands of particles, so instead, I'll use a simple plane for now. I found a Voronoi
texture to be a good starting point here. And, by the way, this Texture Coordinates node is
temporary. After I'm done looking at the plane, I'll connect all this to the UVs we made before.
For those who don't know, this is a funny thing you can do with textures. I used the color
information of the Noise and overlayed it onto the texture coordinates, causing it to distort
them, which is a fun thing to play around with. I used these excess nodes to create finer
details throughout. I hope you can notice the process of first focusing on the most
striking patterns and only moving on to lower scales when there's a good foundation. In
fact, I'm putting way less thought into these tiny details than I was when regarding the
blue patterns. The way the minute forms look in and of themselves doesn't really matter that
much. In the end, they'll only look good if the basic structure does. So pay more attention to
all the stuff one would notice from a distance. I had the idea of switching the nebula from
colorful to pure red once the splashes appeared. So, I decided to work on those new red colors and
thought about how I'd deal with the transition itself. I left this for the end because it's
not a meaningful change to the structure we've already made. It's just a shift in the colors,
nothing that requires any special priority. A tiny thing I did was use the particle Velocity
to generate these bright zones as they moved. I felt like that made things a bit more dynamic by
emphasizing the splashing. Also, when you're doing shading work, don't feel hesitant to use the help
of separate external objects. Here, I'm adding two Empties: one is static, and the other, animated.
Their positions and scales would be used to guide the transition pattern. So I put them into
Texture Coordinate nodes, which I used to make these spherical gradients in their places.
After adjusting and combining those gradients, I connected this transition mask to all
these red Mix nodes. Those were the nodes responsible for mixing between blue and red.
Alright, the shading process is pretty much done. Of course, the secondary
particles also need their material, but I'm speeding past that because
it uses the same concepts as the last shader. Though, since the swirls and
trails in this secondary system could already be considered as small details, I didn't go very far
into creating tiny textures for it. Also, setups like the transition mask and the fake UVs
were essentially copied and pasted from the previous shader. However, in the case of
the UVs, I had to change the maximum and minimum values for Size and Lifetime to match
the ones of the secondary particle system. After the shading, everything was essentially
complete. Before I created a final render, though, I first made a shorter test render to know if
there's anything I should change before committing to massive waiting times. I highly recommend
low-res test rendering like this, even if it is a bit annoying. The viewport preview can only go so
far. It doesn't show you any of the shading, which is a pretty important element. Everything works in
context. If the textures imply that the nebula is massive, then having the camera wooshing around
it like this would make it a bit inconsistent. Eventually, I rendered out this final animation,
with a few changes made to it, like slowing down the camera and making a few tweaks in the shading.
You know, aside from increasing the particle number to 6 million. Another thing about this
is that I rendered it in 4k, despite this video being in 1080p. The reason is that rendering in
higher resolutions really helps the particles look smaller. For instance, both of these images
have a resolution of 1080p, but this one was rendered in 4k (before being scaled down).
Just a quick little idea I thought I'd share. Anyway, that's the end of this video. I
know a lot of this might be confusing. So if you have any questions, feel free to ask.
The project files for this tutorial and all the other particle systems you see right now are
available for free in the description. Do note, however, that a lot of these have multiple
simulations that need to be cached in specific orders. I've also lowered the particle
count for some of the heavier ones. I'd like to thank everyone for watching and
give a huge thanks to all of my patrons!
