NATHAN: Hi, my name's Nathan. I'm a senior digital artist
on the special projects team for Weta. I've got about 16
years experience in the film and games industry. Of that, I've probably
spent a good seven or eight years in Weta's models
department doing hair and fur. I've done everything from
complex braided grooms for The Hobbit trilogy
to every kind of ape you can imagine in The
Planet of the Apes series. In recent years, I've moved more
towards the real time world, just looking at how we can
take that film knowledge and push the visual
fidelity as far as possible in a real time workflow, and
how those workflows can work together to benefit both sides. When Unreal came up
with their strand tool I was pretty excited. I thought that was
a great opportunity to apply that skill
set in a different way. And Weta was really
excited as well. And Epic had asked us
to partner with them in the development of
that tool, and take some of that film
knowledge and see how we can improve the tool. This gave us the
great opportunity to do an animated short
with some furry characters. So we started the
meerkat project. [SQUEALS] Our partnership with Epic goes
back a number of years now. We found them to be
really great collaborators in helping us push what we
can be doing in the engine. For this project we opted
for off the shelf tools to see if the gains
that we were getting were truly applicable to
anyone working in the engine. We're happy to see
that they were, as we've seen from
all the people who've downloaded the
full scene and produced something amazing with it. Traditionally in
games hair has been done using cards,
which is basically a polygon strip with a
picture of hair on it. It's a very, very
difficult skill to do. And to do card hair really well
takes a lot of time and work. But ultimately, the
strand based workflow allows you to have
every single strand be individual and unique. And it just offers
a level of fidelity that you can't quite
get from cards. And it also tends to light
a lot better as well. We see in film that we
can pretty much achieve photorealistic hair and fur. So being able to
take that skill set and apply that in a real
time use is pretty exciting. So let's have a
look at how we built the meerkat and the eagle. So I'll just go over
the basic workflow for making a groom for film. If you are groomer
in the film industry, this stuff is pretty familiar. It's pretty standard workflow. If you're new to
strand based grooming, then this is kind of a brief
overview of the process. It's not meant to be a tutorial. The first thing that you're
going to do is get a reference. If you're making something
real world or not real world, you will still ultimately want
to ground your work in reality to some degree. So having a ton
of reference will help you create a more
believable creature. In our case, the meerkat's
pretty straightforward. You just start pulling
reference from Google. Try to find some key,
interesting pieces that you want to match. We were fortunate enough
to be able to go to a zoo, go inside the meerkat enclosure,
and capture some high quality photography. I use PureRef. I find it's a
very, very good way to pull images, organize
them, zoom in and out, and kind of just collate
it into one easy place. So you can see it's a whole
variety of reference images all sort of combined together. And from that, we pick out a
few specific reference images that we want to match that just
sort of encapsulate the shapes and forms of the meerkat. But you can see
through the chest area, there's a certain flow to it. It flows up into the
shoulders and the neck, and then bends around
and flows down. Same thing through the abdomen. It bunches up through
the center line here. So we just select
a few of those, covering most of the angles. Some of them show good
silhouette fur, Some of the bunching that happens. And obviously capturing
the feet, the hands, and some good close
ups of the face. So when building out the
actual model, in this case I was lucky enough to be able
to do the model and the fur. That's not always the case. Sometimes you'll have
a different artist doing your base model and then
another artist doing the fur. But in either case, it's
important to consider the pose that the creature's in. Particularly for an
animal like the meerkat, where it has such an
extreme range of motion, it can be fully up on
its feet, straight up, and also fully down on
all fours, running around. So in this case, I
opted to model it with more of a 45 degree posing. So it's kind of halfway in
between both of those extremes. The same thing with the hands. The hands are bent
sort of halfway, not fully flat,
not fully straight. The main reason for this is
that once you actually groom it and you have it
animating, you kind of want to split the
difference between the poses so that you don't get a
situation where you've modeled it for one extreme, and then
when it bends down and changes into a different
position, you stretch the fur in an unnatural way. So you get big areas of no
fur, or really stretched fur. So in this case, it actually
worked out pretty well having it at that kind
of 45 degree angle. Before we start
grooming, we want to make sure that we've
got a good base from. So we'll take the
main meerkat model. Make sure that it's got
nice, clean topology. And then we'll start
by stripping out all the extra things that
we don't need to go fur on. So you're getting rid of the
toenails, the fingernails, eyes, inside of the
mouth, that kind of stuff. That will leave us with a
simple piece of geometry, which we can call the FurGeo. And that just
represents the area that the fur is
going to grow on. In situations where
you want to paint maps, you'd ideally want to have
that in 0 to 1 UV space. So when we're
happy with the UVs, happy with the base geometry,
we can set to grow fur from it. From there we can
build the groom out. I obviously can't go through
the whole process in this talk. It does take quite a bit of
refinement and back and forth. But I'll go through
the basic approach. This applies across most
grooms, from creatures to human characters. And I'm using Yeti
for this project, but the general principles do
apply to most other grooming tools. Our meerkat was actually
a pretty basic groom. Using the reference we just
start by laying out the guide curves. These guide curves define the
flow or direction of the fur, as well as its initial length. The actual fur is
interpolated from the guides. So one guide could
control hundreds or even thousands of the actual strands. The more guide curves
you use, generally the more control you have
over the shape of the strands. And the guide setup is
pretty vital in creating a good foundation
to build on top of. So spending a lot of time
with getting the guides right will just add to the
believability of your groom. As you can see here, we've got a
subset of Molly's guide curves. From the reference
that we saw, you can see that there's
those distinct flow changes that are quite
characteristic of the meerkat. So when you're building
out your guide curves, it's important to
make sure that you can identify those
unique features and replicate them, as we saw
the bunching towards the center line of the belly, those
directional changes to the chest area, additional
punching on that neck line as it transitions from
the front of the chest through to the back. So just making sure that
you capture all of those is going to be key to making
sure she looks believable. So if I just
quickly start fresh, I'll go over that basic process. If we click on the
FurGeo and go, Add Groom, we'll just copy this for now. And we'll just call this-- now, over in the
[INAUDIBLE] editor when you click Edit
Groom, and you've got the Tool Settings
bar open you'll get all the Yeti
options in here. So this controls
how the brush works. It has some of the
grooming tools here, the attribute paint tools. That's your main sort
of toolset that you'll be using to do guides
and to paint attributes. For the actual
groom node, we want to turn conform strands on. And I'll show how that works. But it basically means that as
you sculpt a few curves, when you click to add new
ones, they will basically conform to the shape of
the existing strands. And that makes the whole
process just a bit faster than having to manually
sculpt every one from scratch. Generally I turn Create
Mesh Vertices off, as we want to be able to just
place them where we click, and not necessarily at the
vertice on the geometry. I probably want initially
five segments for the strands when they go on. So from there, I'll do
that little belly area where the fur kind of bunches
up down that center line, cause it's a little bit
of an interesting area. Over here in the toolset,
we've got plus and minus. The plus simply adds a
guide curve where you click. So I'll just add a couple
of guide curves down here. There's a whole
variety of tools. There's a combing tool, which
is pretty self-explanatory. You're kind of just
brushing that guide in the direction of the comb. The one I tend to use
the most is actually the move tool, which
functions similar, but it's kind of
not super spaced. You can kind of just push the
curves around a little bit more freely. So if we just start to
create that initial shape through here, just getting
sort of a base to start from. And then as you see here,
with the conformed strands on, if you click to
add new ones, they will kind of flow in the
direction of the existing ones. And you can kind
of just tweak them a little bit without having
to completely redo it. So if we get some of that
there, and then we'll add some more on the
other side, they'll initially conform, as well. And you can actually
isolate select some. And then you can brush
them independently without affecting
the other ones. You can get that shape
a bit more accurate where it bunches and
pushes them together. And just checking
all your angles. Turning off this last
[INAUDIBLE] select and get them all. And that's kind of basically
the process for it. If you want to put a larger
volume of them quickly you can just have a
bit of a larger radius, and just paint them in quickly. And then use the comb tool just
to give them a quick shaping. Move tool. You can just flow it and
contour it over the body. And that was pretty
straightforward. It's really easy. It's kind of fun. And then if we
just hide the test, you'll see with many
more hours of work, and the correct
length and things that you build up
the whole shape. You can see, there's
that through there, and the stuff that we sort of
identified in the reference through the shoulders, the
chest, and all that stuff, same kind of bunching. So the exact same principles
apply that I just did then. You're just placing
and brushing. I personally use quite
a lot of guide curves. Just that's how I work. You don't necessarily need to
use nearly as much as that. But I think it's a little
bit of personal preference. There's no real
performance benefit, at least on my workstation. So just use as many as you feel
you need to kind of capture that shape, and try and get a
lot of the unique subtleties and shape transitions. When we have the
guides in a good place, we can generate
the actual strands. From there we add several
layers of clumping and noise, and then spend a lot of
time painting in those attributes to create variation
in those main structures depending on where we see
more or less of that textural break up in the reference. As you can see in the
chest and belly area, it's shorter and smoother. On the back it's longer and
has that large structure with a bit more clumping. We also get that
tighter, bunched up clumping through the lower belly
where the direction changes. So I'll just
quickly show you how the attribute painting works, as
it's quite an important thing. If I just hide the groom and
show the base guide curves, you'll see that each guide
curve also has an attribute value at the bottom of it. You don't have to necessarily
have the two connected. You can create a separate
groom node that is just for attribute paintings. But in my case, I've got so
many curves I just kind of use the same groom node. But if I hide the
strands, you will see there's a bunch
of colored dots on it. And that basically defines a
value for a certain attribute, like the clumping or
the noise, for example. I think it goes from
dark purple to orange. And that's basically 0 to 1. If I turn the heat map off,
you can see black means the effect is nothing. And 1 means the effect is
that 100% based on what you've defined in the node graph. So it's a bit easier to
see with the heat map on. So if I click on some of
these you'll see, for example, there's the small clumps weight. So in this case, I've got
a lot of small clumping through the back. You can see a little bit
of variation through there. And that's what I was kind
of talking about, getting that break up. So we see the green and the
lighter greens, the yellows, the oranges. That's the variation,
and how much and how intense that effect
is from those small clumps. And then I've got much less
through the belly, much less through the arms, where
we saw that smoother fur. So if I go through the
attribute list here, you've got that master scraggle. I've got it pretty
much everywhere. There's a bit of variation
in the master scraggle node. But it applies
almost everywhere, except for those really
short, fine hairs on and around the face. Small clumps, some variation
across the whole body, even where it's mostly
applied across the back. There's a little bit
of variation there. Large clumps, same thing. Master density. I've got a little bit of
change in a couple of areas. Micro scraggle, much less
scraggle through the face. So yeah, just kind
of the bunching, the flow bunching, that was
something that we really identified in the reference. So it's highly applied
through the neck area, obviously through
that center line. There was a bit on
the eyebrow area. And then just a couple
of random spots, like just manually painting
in simple random spots, just to give that
clumping more variation. And I think that's just
pulling the clumps tighter so you don't see the
whole leg through here having the same looking clumps. You've got these patches
where it's a little bit more, a little bit less. So I'll actually
just do a quick, I guess a really exaggerated
example of how that works, as we saw all the
clumping on the back. So if I just click on the small
clumps, set the value to 0.0, and then just paint out
all the fat through here. And quickly, same thing
for the large clumps. I'll just paint
that all out so you can really see how that works. So if we go back to
heat map off, black. So basically the effect
of the small clumps in the large clumps is
nothing in those areas. And then if I turn
the groom back on, we can see that it's
basically removed almost all of the clumping
through the back there, and it's very smooth. So I hadn't entirely
clipped where you see some of that clumping. But you get the idea. This, kind of up here,
is what it looked like. And then as you
paint those values, you change the
effect of that on it. And that's basically what's been
happening over the whole body just to create all that
variation and uniqueness. Up on the face you
can see that there's quite a bit of variation in how
the clumping is done up here. So you can see on the cheek
where it's a bit longer towards the back of the cheek,
you've got some clumping there. As it transitions
forward towards the nose, you have a little
bit less of that. It starts to loosen up. Starts to get a bit shorter. And then it changes direction
through the mouth area and up onto the nose bridge. Within the clumps
themselves there's quite a bit of variation. I think this groom as
a whole actually only has three clump nodes,
and each of those nodes has a little bit of variation
in how the clump's done, and its radius, how
tight it's clumping, where it's clumping along
the strand towards the tip to the base. So combining those
three together, you can kind of get
some larger clumps that are a bit more
broken up towards the end. You can see some of the smaller
sub-clumping that happens inside the larger clumps. You have a few that are a
bit tighter, more pinched up. And all of that variation
is coming from the painted attribute maps. So you paint a little bit
more of the larger clumps, a little bit less than the
larger, a little bit more of the tighter clumps. And then overall you get
a lot more variation. You can see as it comes down and
transitions towards the neck, some of this is a
bit softer where it might be rubbing against
the neck fur as well. Over here towards
the shorter hair, you have very little
clumping, because it's all just very short hair that's
pushed along one direction. Up on the brow line where
it's a little bit longer, again, you see some
of those clump shapes. Through the head, top of the
head, It's still quite uniform. And it's uniform in
the reference as well. But it's all not
exactly the same. So you can see here is
like a small tuft that's a bit different. Here's some shorter ones. Here's some more tufted ones. Like there's just enough
variation in there that it doesn't all
look exactly the same, even though it's actually quite
a smooth surface over the head. And then down through the neck,
same thing sort of happens. And then towards the back
where it's a lot longer. You can see some of those
variations in the direction that we did in the guide curves. So you can see there's some
longer ones through here as it wraps around. Through here is a bit of a shape
change, just that variation of break up. And then the thicker
clumps, the smaller clumps, all that just adds
to the realism of it. You can see through the arms,
it's quite distinct as well. It's actually a bit
smoother through there. And it gets longer as it
goes up towards the elbow. You've got a distinct part line
through where the forearms are, which is breaking off to the
side and wrapping around. And then it's a little bit
shorter on the inside as well. It's quite smooth through
the hands, a little bit more clumping around
the fingernails where it's a little bit longer. As we said, the chest
is relatively smooth, down that center line. On the side you can see
there's some clumping coming through here. And there's actually a bit
of a line, a visual line that you can see, which is
also in the reference that is that transition
from the longer fur on the back to the
shorter fur in the belly. And the tail as well, but
a variation through there. And a lot of that just comes
down to the attribute painting. You don't need a lot of
nodes to create the effect, but it's just how you
blend those nodes together, combining that with a couple
of different variations in the scrag also. It's not all uniform
scraggle and noise. As I say, it can be a very
time consuming process. But it's the attribute
painting that really makes the
difference in creating that more natural variation
and realism that you see in the references. The other thing that
you would have noticed is that I've got
different colors on certain parts of her fur, but
this has been set up in a way that we have different group IDs
for each of the different fur sets. There's a couple of
different benefits to that. So if I show you the graph, you
can see that at the top here I've got the main fur. I've then got the belly fur. I've got some extra
fur on the face. These ones basically
control the clumping. And then this one's
this silhouette fur. And then they are
all merged together. And different effects are
applied as it goes down. So we add the large clumping. We add smaller clumps, scraggle,
some more micro scraggle. And again, they're all painted
with the attribute maps. And the purpose for
that is it gives us extra control,
both in the engine and in here when we're
sculpting the fur. So you can see I've
got those colored. The red fur is the
silhouette fur. The blue fur is that belly fur. The greenish color
is the main fur. And then the pink on
the face is extra fur, just to fill it in a bit more. We noticed in a few cases
it wasn't quite rendering correctly in the engine
how we wanted it to when it was getting very small. So by separating these out,
it gives you specific control over certain parts of the face. If I just isolate some of that-- I'll just take, say,
the fur on the face. Disable the silhouette fur. So you can see here, this is
just the shorter, finer hair on the face. It does blend in with the other
areas, which I think is good. Again, it just adds a little
bit more of that variation. Those finer, smaller,
thinner hairs, they also add in to
some of that clumping structure with the
slightly thicker larger hairs from the body fur. And then as we saw, the
silhouette fur, it's longer. It's scragglier,
a lot more noise. And that's what gives us
that silhouette shape. So if we look at the
silhouette fur, for example, having these separated
out gives us control. So over here, this
section, as I say, is the nodes that control
that silhouette fur. It may be that we get
it into the engine. And we are trying to
achieve a certain lighting look with that backlight. And we just can't quite
get it to look correct. We don't want to apply a
change to the entire meerkat. Because that may then make the
main body fur look incorrect. So just separating those out
where it makes sense to do so means that, for example,
we can increase the width. So just an example,
I'll just make it 2 so it's really obvious. So now you've got
very, very thick hair. And that'll only
apply to that set. As we can see, it didn't have
any effect on the face fur. And it won't on the
main fur either. So it just gives you a
little bit more control. The last little bits are
the eyelashes and whiskers. For those, you just sculpt
a guide curve for each one and then convert the
guides to strands. Pretty straightforward. Basically you just
create your guide curves, generate the strands,
generate your clumping, noise, and other break up, and
then paint in the attributes to match the reference. There's a lot of tweaking
of parameters and things as you sort of
refine it further. But yeah, that's basically
the general workflow. You can see here just the
entire UD graph for meerkat. For the eagle, it wasn't
quite as straightforward. Unreal's strand system
only binds to geometry. So you can't bind a
strand to another strand, for example, which is
sort of what a feather is, and kind of how it
handles feathers. But even then, you can't
rig and animate a strand. So we tried a couple of
ideas, but ultimately what we settled on was
instancing a geometry spine as well as the
strand based feather at every location. And the two overlapped
exactly, meaning that the barbs of
the feather would align to the geometry spine. We then exported
the geometry spine and built that into our rig. This meant that we
could animate and deform any feather we needed
to via its spine. We then exported the feather
barbs as a strand groom, separating out the strand
spine and the barbs. Over in Unreal when we bound
the groom to the eagle, the strand barbs would
align and connect nicely to the geo-spines in our rig. This actually worked
out pretty well. It wasn't foolproof. There were definitely some
issues here and there, but for the most part, they
weren't too noticeable. Once we figured out that
part of the process, the creation of the eagle
follows a similar approach to the meerkat. Of course, we always
start with reference, and then we place guide curves. This involved hand placing
them for the larger flight feathers on the wings to
a more procedural approach for the head and body. Then instead of
generating the strands, we instanced hundreds of copies
of the different feather types over the body. And for each one, a matching
spine geo, as we mentioned. If we have a look at
the [INAUDIBLE] graph for the eagle, there's
a lot more going on, but it's actually pretty simple. It's mostly just a bunch of
separate groups of feathers which have been
broken out to give me more control over each one. I made about 10 different
types of feathers that visually represented
the majority of the feathers on the eagle. So that's the primary,
secondary, tertiary flight feathers, the tail,
the body, the head. And then they kind of
all get merged together to create the overall
feather groom. So this is our eagle
with no feathers. Over here we have
the source feathers. So as I say, we have
multiple different types of feathers that represent the
shape of most of the feathers basically. So if we come down
to here, we can see that these are
the different types. So that's a primary
[INAUDIBLE] and this shape was matched based
off reference that we had for the feather types. P5, slightly different shape. P2, slightly different again. There's obviously variations
between P5 and P10. So there's 6, 7, and 8s,
but they were very similar. So this was a good
approximation between the two. So we just used that for all
those feathers between that on the wings. As an example, here's
the secondary S6 feather. And as we discussed, the
geometry that goes with it will match the same shape. So we could convert the entire
groom into a geometry groom, and you'd have the full card. This is more for
helping creatures to be able to see it as
a whole and to deform it without the use of Yeti. But the main part that was
important is the central spine. So this spine is what the
actual strands get bound to. And this was rigged. And this part of the
feather was discarded. The construction of the feather
is pretty straightforward. Yeti comes with a
feather primitive. And that, as I said
earlier, is basically a strand for the spine
through the middle, and then additional strands
that come off of it. And that's why we
couldn't use it directly, as we can't bind these barbed
ones to the strand spine. But in the property
section for this, we have a lot of control
over the shape of it. You can increase and
decrease the number of barbs that come off it. And there's various controls
for the width, the curvature, the bending, that kind of stuff. All right, so we can
modify the shape of it by moving these vertices
to create the shape to match the reference
for the outer profile. And then change these values. So that's all I've done
for these different ones. And then on the actual eagle
groom itself, if we zoom out, we can see that copies of
that same source feather get instanced over where
we place the guides. So there's that P10. There's that P2, P5, secondary. So you get the different
shapes through there. Doesn't match exactly,
but it's pretty close. And then for the body, just
a bunch of body feathers that are all instanced
across the surface a bit more procedurally and
less hand placed. For the face there's
an additional fur set on here, which is more
of that traditional approach that we did with
the meerkat, just using the guide curves to
create the face hairs that help blend in with the feathers. So what we have here is
the secondary S6 feathers on the wings. And here is the
section of the graph that controls those feathers. So what's actually
happening here is we've got the geometry
card that we built, which matches and
the [INAUDIBLE] feather. And the two of those are
being combined together to ensure they have
the same position and transform the properties. And they match. And then over here we
have a switch node. So I can export the entire
groom as a strand groom, which is what we put into the engine. And then by switching that, we
can convert the entire groom to our geometry card. So the card, which includes
that imported spine, was exported and
sent to creatures. And they discard the
outer part of the feather and keep the spine for rigging. And then we use that in the
engine with our strand groom to do the binding. So that was a very quick
overview of the process. We'd need a ton more
time to go into the ins and outs of the details. But if you have access to Yeti,
you can open those source files and have a deeper look at how
we built Mollie and Martin. This groom was initially
done to a film level. And for the purposes of
being used in real time it was what we considered
a ground truth. And by that, I mean I'm
making the groom that matches real world values. So the number of individual
strands, the thickness, the details along
the strands all have as close to real world
values as we can discern. We just export to Unreal's
ABC format from the Yeti menu. Over in Unreal, we just
import like any other asset. But if you're new
to this, there's actually a couple of
important import settings. With the Maya,
Yeti setup we need to do a negative 1 scale
on x, negative 90 rotation on x, and 180 on z. This simply corrects
for the transform between the applications. And this will give us the
groom as we see it in Maya, but with x forward in Unreal. And that'll match
the orientation of our skeletal mesh, which
is important for binding the assets later. Once the groom is in Unreal, we
can just drop it into a scene and have a look. As I said, we start
with our ground truth, and then we can dial it
back from there if need be. So I'll quickly go
through some of the things that we did with
the meerkat to get it running a bit more smoothly
in the engine, while still matching as much of the
visual fidelity as possible. For the most part, it just comes
down to the number of strands and the number of
points, or vertices, along the length of each
strand, as well as balancing the thickness of the strands. By changing those
three parameters you can take a
ground truth groom and have it run in real
time substantially faster, while still having
it look pretty good. Strands is the obvious one. Fundamentally less strands
equals more performance. But before we start
reducing the strand count, we reduce the vertices. The main thing that will be
affected by changes in verts is the strand noise. That's the amount of frizziness
and small changes in directions along the length of the strand. So we pick an average
viewing distance, which basically means seeing
how close to Molly we get throughout the camera sequence. For the most part, we see
her from chest up or wider, with a couple of closer
shots of her face. So with that in mind, we start
reducing the number of verts, and just visually
look to see where we feel it breaks down
too much, while also keeping an eye on performance. I also have different
fur groups in her groom so that we can refine
that even further. So the belly, the short hairs
on her nose, the longer guard hairs, and the main
body fur, they all have different vert
counts and strand counts to help with
that optimization. The tiny facial hairs might
only have two or three verts, while the longer body hairs
that are a bit more frizzy might have 10 to
15, for example. Once we're happy with the vert
reduction, if we still need to, we can start removing strands. Removing entire strands will
have a bigger visual impact than the verts,
but you can kind of compensate for that
strand loss by increasing the strand thickness a bit. As you can see here,
we reduced the strands and increased the
thickness, and it still looks pretty close
to what it was. But you get a lot
more performance back. So with that said, if I put the
two grooms into the engine side by side, we can
see that they still look quite visually similar. You always lose a
little bit of detail, but our optimized one is
substantially more performant, and it still turned out
great in the final shot. Once we were happy
with the groom's shape, we started shading it. Thelvin Cabezas
did the shading work for the meerkat and the eagle. And he did a phenomenal
job replicating the natural processes
that take place in the fur to give the correct
timing and release mechanisms that create that distinct
meerkat patterning. Meerkat fur, as
it grows, receives different amounts and types
of melanin into the strand. This results in parts of
the strand being lighter and darker, and also
colored in different hues, so when it grows out
to its full length, we get that variation of the
browns, the reds, the whites, and the blond tones that
make up the meerkat patterns. We set up different
shading groups inside Yeti. These are called group IDs. It's the same concept as
material IDs for geometry. So in Unreal, it
separates sets of strands into groups that we can assign
a different material to. So, for example, we have a main
body group and a guard hair group. So we can control the look
of these independently in the engine. The guard hairs
are what gives us that interesting
backlit silhouette. So we can play with
it in the engine within the context
of our lighting setup to get that specific look
right without affecting the other hair groups. The final step is
to attach the fur to the skeletal
mesh of the meerkat so that we can animate it. We do this by creating
a binding asset. The main thing here is that
the groom and the skeletal mesh in Unreal both line up. That's why we do that specific
transform when importing. If the two aren't
aligned, then the fur will be attached to the
wrong part of the skin, and it'll look
incorrect when animated. You can either attach
your groom asset to this cam in the
scene in the outliner or through a blueprint. We just generate the binding
asset from the groom asset and assign the
matching skeletal mesh. Once that's hooked
up, we can just test it out on a walk cycle. We found it pretty helpful
to get it on to animation as soon as possible. That's where we can see
how the groom breaks. Is it moving correctly
around the shoulders? The legs? Does it look good on Molly
when she's standing up versus running on all fours? There was a bit of
back and forth both for the meerkat and the
eagle, tweaking the groom based on the camera angles,
the skin deformation, just to see where
things break down. And this was particularly
challenging for the eagle, as controlling feathers in
a rig is really difficult. We had to constantly add more
feathers in when we saw gaps in the skin. The riggers did an amazing
job turning around the eagle, in particular, who
was not an easy asset. Once all the parts are in, your
models, fur, shading, lighting, animation, that's where the
minute fine tuning comes in for the fur. Fortunately, as we're
making an animated short, this meant that we had fixed
camera angles in animation. So the fine tuning was pretty
straightforward in the sense that you kind of look
at the rendered shot, identify issues, fix the issues. And it mostly ended up
just iterating on some of the optimization stages. Did we lose too much detail
on a particular area? Are the hairs on
the face too thick? That kind of thing. By the end of it, we pushed
it back a little bit more towards the ground truth. And it was still
really performant. By optimizing some of the
other areas in the scene we were able to afford
a higher quality groom, and still have it run at
30 plus frames per second. Even though the final
output of this project was a rendered movie,
part of this test was to explore the performance
of these types of assets for interactive and
fully real time mediums. So having it all running
really well in the editor not only showed that we
could make a pretty picture at the end, but that
the workflow and speed benefits of real time
rendering were there, and that we could
use similar quality assets in different contexts. So that's a quick overview. It is a lot of information
to compact down. If you are new to the
strand based tool, or if you are currently
someone that's using cards to do
hair and fur, this should give you kind of
an idea of the workflows and processes that go into it. If you're a groomer
in the film industry, this is definitely
another way that you can apply your skill set. As the tech moves
forward, I think we're going to see it adopted
more and more as it becomes more performant, we'll see
it in a lot more real time applications. The other thing that
I'm really excited about is to see people
taking our content and reusing it in fun
and creative ways, and sort of exploring the next
step in the Molly and Martin saga. So thanks, everybody. I hope you got something
out of this talk. Cheers. [SCURRYING]
