DARYL OBERT: Hello, everybody. My name is Daryl Obert. Welcome to our next webinar
on animation workflows using Maya in Unreal. Today I have the pleasure of
presenting with my buddy Harvey Newman and Steven
Roselle from Autodesk. Our webinars are designed to be
high level product demonstrations and are not deep dive
training or pure tutorials. They move pretty quickly and cover a
wide range of topics and workflows. In the end, I hope you all
leave inspired and ready to jump into Maya in Unreal to
make your own animations. The topics we'll cover today
are universal scene description and alembic for data transfer
and collaboration, HumanIK for animation, look
development in Unreal, and we're going to spend a
bit of time using Maya's MASH and Blueprint to create
this animated marquee light that you're currently seeing. So we'll begin with
universal scene description. For those of you not
familiar with USD, it's an extensible scene
description and file format. Maya and Unreal's open
source USD solutions both let users create, edit,
work, and collaborate on USD data. There are many reasons
why to use USD. It's fast to load large data sets,
it allows for s collaboration, and USD is a common
language allowing data to seamlessly move between
a variety of applications. So here we are and the Maya
scene of the first shot of the little animated
short that I made. And as you can see, this has
a lot of standard Maya assets already loaded into the scene. So there's geometry,
light, cameras, as well as this character that's currently
being driven by a HumanIK rig. So what we want to do
is we want to start to export out some of
these assets to USD so that we can begin working
with them at a higher level and more collaboratively with Unreal. So this is a very straightforward
process inside of Unreal. We're basically going to select
the geometry we want to export. So for this example, we'll
use the Happy Halloween logo and we'll go to File,
Export Selected. And I'm going to bring
up the Option box. So as you can see, I have the file
type already set to do a USD export. And our subdivision
method, we're going to switch from Catmull-Clark over
to just Polygon Mesh, because we're going to Unreal, and I'm not too
concerned about the subdivision. So everything else is turned off. These are just static meshes. So no animation is
going to be going out. We'll go ahead and we'll
click the Export Selected and we'll just overwrite that logo. And we'll save this out. So now that we've saved that Happy
Halloween logo out as a USD file, the next thing that
we want to do is we want to start to re-import into
Maya the USD assets to begin building a more complex scene. Now, you would think,
OK, cool, I'll just go up to the File menu and
re-import that used data. And you can do this, but if
you do it in that manner, you're not going to be getting
the benefit that USD brings to the table, because it's going
to bring it into Maya just like it would import it in
FBX file or an OBJ. It's just going to bring it in
and make it a native Maya piece of geometry at that point. Really what we want to do is we
want to utilize the USD stage. And the USD stage is
really a key concept. Unlike importing in
the USD file directly, if you import in a USD stage, it
lets you reference the USD data without converting it into the
core applications file format. So it won't make it into a native
Maya file format or a native Unreal format. You're bringing in
the USD data directly and it allows you to
work with it directly. So let's go ahead and
see what that looks like. Let's go to Create. And we'll go to the
Universal Scene Description. And I'm going to say
Stage From A File and we're going to grab
this environment dance. So this is going to be
a single asset that's got a complex representation
of multiple USD files inside of it that lives on the disk. So we're going to go ahead
we're going to open this up. And when we do that, you can see
that directly in the outliner, we now have a representation
of this data living alongside of the native Maya
attributes or the native Maya file types. So you can work with this
just like native Maya objects even though it's USD data that was
brought in and still lives on disk. So it shows up in the outliner and
it shows up in the attribute editor. It's here. You can do stuff with it,
which is super, super cool. Now, another thing to keep
in mind is what we just imported in is the USD root file. It includes all of the
layers and sublayers that make up that USD asset. So if you right click on top of this
in the outliner and say show shapes and we start to expand
this out, you're going to see that
there's a root file. Here's all the materials. Those materials are going
to have all the textures. If you scroll down further,
you're going to see things like geometry and bones, cameras. All of this information
lives in that USD stage file, which is super, super cool. So the next thing
that we want to do is we want to start to further
manage this and work with it in another way,
which is using the layers. So if we right click on top of it
and we bring up the USD layer editor, this allows you to
nondestructively make edits, work with different departments in
the same pipeline to collaborate and update the asset without
interfering with each other's work. So it's a whole
management system that allows you to, at a very high
level, work with this USD data. So you can see that I've already
got it kind of set up here where I have an animation asset. I've got some layout assets
that have some geometry already inside of here. So if we turned off the
USD house, those houses will basically disappear. And then we have
kind of a placeholder for lighting and material overrides. So you can go through this
and turn things on and off, drag and drop to reorganize things. There's a lot of control and
flexibility inside of here. We can also create layers
and sublayers directly inside of the layer editor. So what we're going to do is
we're going to actually bring in that Happy Halloween logo. So let's go ahead and
hide the original one. And let's just on top of
our environment dance root, we're going to basically
tell it to load a sublayer. We're going to browse
out to the disk and we're going to just grab
that logo USD file. So we'll load that guy in. And you can see that we
now have the logo USD file that's been
loaded in as a layer, and it shows up directly
in the viewport. So that is basically what it's like
working with USD inside of Maya. So let's go ahead and jump
over and see what this looks like in another application. The next thing that
we're going to do is look at that USD stage and
USD view, which is part of the USD libraries from Pixar. If you get them directly
from Pixar, you'd have to compile them,
their source code. Or you can just get some
pre-built libraries off of Nvidia's developer
site, which is what I did. Additionally, you need
to install Python 3.6. And once you get that done, there's
a couple of steps to get it running. So there is a help
file that is included in the directory of the USD 2105. So let's check that out. So what you need to do is after
you unzip everything and have Python installed, you
need to set some paths. Now, I recommend not setting these
paths in the system environment variables, because it will
wreak havoc on your machine and you'll just save
yourself a world of pain by setting the paths
in the command prompt and running them uniquely
each time, because it won't mess up Maya's Python
installation or Unreal's Python installation. So for me, the paths look like this. So it's just kind of
setting path to the bin, then setting path to the lib. And I obviously unzipped
this on my D drive. One additional step is after
you get Python installed, you do need to install
PySide2 and OpenPyGL. That's done by running the
PIP, which you will only do this the first time. So you basically unzip
everything, get Python installed, run Python with this PIP
command to install those guys after you've set the paths, and then
everything will basically just work. And then, of course, the
last line of my command here is USD view, loading
the command for that, and then just pointing
myself to that file. So I'm just going to copy this. And we'll jump over to a command
prompt and I'll just paste it in. And we'll run that guy. And you can see it's going to load up
the USD view really, really quickly. So if you look on the left hand
side here in the navigator, obviously this root has
all those different layers that we saw inside of Maya. Same exact thing. All the textures, all the
cameras, all the lights. Everything's in there. And then in the viewport,
you can see actually the size of the scale of the scene. So there's the moon, which
is really, really big. And then there's this massive
star field behind the moon. Actually made that with MASH. MASH is super, super cool. And then up here in the foreground is
actually where the character dancing thing is happening. So to get to that, I'm just going
to right click on this logo cam and activate that. And then you can see if we
kind of move around here, that is the USD stage that we
literally just made inside of Maya. And all that information is there. It comes across in
whatever application you open that stage in now. It's going to have the exact
same representation of that data. So this is really the
beautiful thing about it is it's just an awesome
pipeline tool for collaborating. So let's go ahead and check
this out in Unreal now. OK, cool. So here we are in Unreal 4.27.1. And we want to basically do the same
thing that we just did in USD view. We want to open that stage file. So this is super fast and easy. Just go to the Windows dropdown
and bring up the USD stage editor. I have it docked on the
right hand side here. So this USD stage
editor will allow me to open stage files very similar
to what we saw inside of Maya. So we'll just say File, Open. We'll grab that environment dance
USD and we'll bring that in. So as this opens, keep
in mind this is not importing this data into Unreal. It's just opening up a
reference to that data. It's still pure USD data. We just have the ability to
view it, manipulate it, and work with it inside of Unreal. So it hasn't been imported
into my content browser. It's not native Uassets
inside of Unreal, which is kind of similar to
what we saw inside of Maya. So it's the same workflow everywhere
you go with USD, basically. So it comes in really dark. The reason it's really
dark is there's no lights. We haven't done the look
development work yet. But there are some materials
that had incandescent. So you can see the moon kind of
glowing and the little stars. I'm going to switch
over to an unlit mode just so that you can see that,
yes, there is all of the data. And in the USD view,
just like we saw in Maya, we have the ability to
work with this, view that root folder, all the textures,
all the geometry, the cameras, all that information is
going to be in the root. If we jump down to
layers, this is going to be very similar to what we
saw in the editor inside of Maya. And you can see that logo USD,
which was one of the layers that we made when we were working
on this in Maya comes across. And of course, that layout layer
that had some sublevels inside of it for the house, the ground,
and the moon and stars. So it's the exact same data
represented the exact same way regardless of what application
you open the stage file in. I guess that's the key concept and
the reason why this is so cool. And again, it opens really quick. You don't have to import it in. It's just you're working
directly with the USD data. Now also like in Maya where
we could view this and work with this in the outliner, if
we go to the world outliner, there's going to be a representation
of this data in the world outliner also. And you can see that they
have these little lightning bolts next to them to
give you that visual cue that these aren't standard actors. These are USD stage assets. And of course, if you
grab something in here, it shows up in the Details panel. You can actually do stuff with this. It's here and you can kind
of play around with it and work with it a bit. And like I said, this isn't imported
in, but you can still go in here and start to do all the things
that you would normally do inside of Unreal even though it's just a
USD file, which is ridiculously cool. So that is the USD workflow. I hope that makes sense to you guys. Let's go ahead and start
doing some look development. OK, so this next section is fun. I'm going to be going
over how I lit the scene. I'll talk a bit about
the look development. And I'll give a quick overview
of how the ray tracing works inside of Unreal and how you can
fine tune a few of those parameters. So the first thing I want to do
is make a few changes to the moon. He's not looking
exactly the way I want. So when the USD stage came in,
all the eyes were turned on. So I'm going to just turn
off a few pieces of geometry to get just one set
of eyes turned on. The eyes were actually
really easy to do. I drew them with a marker
and then scanned those in, made a mass material, and
then in the sequencer, I just animate between
these to kind of give you that sort of hand drawn hoppy tune
look and feel to the moon and to his eyes. So with that done, the next
thing we're going to do is just modify a couple
of attributes on the moon. Now, this moon came in
through the USD stage. So he actually is a USD asset. But if you look in the Details
panel and we select this, it looks very similar
to a static mesh. It actually has all the
same things that you could do to a standard
Uasset instead of Unreal you can do to this USD asset. So that's really powerful. So what I want to do is I'm
just going to search for shadow. We're going to turn off
the shadows, because he's kind of the main light source. I don't need him casting
shadows into my environment. And we're also going to
search out for channel. And what light channels are in
Unreal, if you haven't used them, they're a light linking tool. They allow you to isolate
light from certain objects. So for this example, I don't want
my moon being hit by any lights. He's going to be driven by
the incandescents completely. So we're going to turn
off channel 0, which is on by default for all objects
and all lights when you create them in Unreal. So we'll just turn that off. Sweet. So let's go ahead
and jump over to lit. So when we go to lit, this
seems really, really dark. There's no lights in the scene. So the only thing
that's visible right now are the objects that had
incandescents in the material. So the moon and the stars. So to fix that, we're going
to go to Place Actors. And we'll just drag and
drop in a directional light. So that directional light comes in. Now, it's worth mentioning that we're
going to be dynamically lighting this scene. So you can see that
that shadow over there has kind of this word preview
coming across it right there. We're going to switch this
from stationery to moveable, and that's going to go away. So everything in this
environment is dynamically lit. There's no back lighting. It's worth mentioning that I
already have ray tracing turned on as well as DX12 in
my project settings. So what we have now is we've got
a pretty basic lighting model. We have a directional
light and that's it. So we're going to kind of
fly over here, frame up on these houses a
little bit, and let's start to modify the way
this ray tracer is working. So to do that there's
a couple of ways. We're going to be using a
post process volume today for this project to fine tune some
of those ray tracing attributes. So we're going to go to
Place Actors one more time. We'll search for post, and I'll
drag in this post process volume. And we'll just kind of
place it right there. Now, post process
volumes in Unreal are-- they're crazy powerful. They do so much. So you can see in the
Details panel here, you can use them to dial in
the overall look and feel. What bloom do you have? What exposure? Does the camera have depth of
field or is there dirt on the lens? Are you using any grading or is
there a lookup table being used? In addition to all of that,
it also has the ability to adjust many of the
ray tracing attributes. Now, it's worth mentioning that post
process volumes are actual volumes. So you can have more
than one in your scene. And as you move through the
environment, you can change the look and feel. So maybe you have one for the
outside and one that changes the look and feel when you go in
the interior of the house. For this example, I want one post
process volume to cover everywhere. So I'm going to toggle on the
infinite extend or the unbound check switch. So by doing that, this one
volume covers my whole world. So with that done, let's go
and start to play with some of the ray tracing attributes. So I'm going to scroll up
here to rendering features. We'll expand that out. And the first thing
that we're going to do is we're going to go
to global illumination. Ray trace global illumination. And we're going to turn that on. So as soon as I switch my type
from disable to brute force, you're going to see that
we immediately get light bouncing underneath those porches. It starts to have this
secondary lighting kind of moving through the scene. Now, I'm going to put
my max bounce up to two. As soon as I do that, again, it's
going to get a little bit brighter. So obviously the more
bounces you have, the more color bleed,
the more light transfer you're going to get at
the cost of performance. Now, I'm also going to
take the opportunity to increase the samples
up to something like 16. Now, I'm running on
an RTX 30 series card. It's very, very fast. So you can see my performance
even with 16 bounces on the global illumination is
still moving along pretty well. Now, let's kind of fly up here and
look at this Happy Halloween sign and talk about reflections
and ray trace reflections. So we've got some objects here
that have a roughness map assigned to them already. So if we go back to
the post process volume and we go into ray
trace reflections, you can see that there
are some parameters that you can play around with. So this is a pretty important concept
with ray tracing inside of Unreal. It's a hybrid ray tracer. So what that means is at any
given point or any given pixel, you can decide whether
or not you're going to trace a ray to calculate
what the final color should be or if you're going to fall
back to the raster renderer. For reflections, the driving
factor of that is you're going to be max roughness. So if it's below 0.6, it's going
to use a trace ray to calculate what that should look like. If it's above it, it's going to
kick back to the raster renderer. So notice the effect
on this object that's got a texture map tied to
roughness as I move and swipe through this attribute. As areas that are exceeding
the threshold get underneath it they start to ray trace. And you can see that
as I move through here, it starts to look a little bit better
as we trace more and more rays. Now, I'm going to go ahead and crank
my samples up to something like 16 on this. It's going to slow it down a
bit, but it's still pretty fast. Now, the other thing that I want to
do really quickly is the max bounce. So right now we don't have
reflections of reflection. So if I put my max bounce to two,
look up in this area right here. You're going to see a
really big change when I flip that guy between one and two. So if we go one and then if
we go over here and hit two, it just starts to have the
interaction of those reflections together. So for shiny stuff,
having a max bounce of two is normally a pretty good idea. All right. So I'm going to turn
off that frame rate, because it's a little distracting. But that's basically what I did. And for demo purposes, we'll just
drop that back down to something like 0.5. And we'll kind of fly over here. And the next thing that we want
to talk about is translucency. So again, in the post
process volume, you have control over how the translucent
surfaces are going to be handled. So we're going to go to
translucency, and we're going to switch it from its
default raster over to ray tracing. Now, my scene's black, so there's
not going to be a lot of change, but you will see some
reflections kind of kick in some of the windows
as well as the shadows look slightly different on the glass
surfaces when I flip between this. So you can see right here and sort
of over in this area right here the difference between the two. So we want to ray trace the
translucency in this project also. So that is basically it for
setting up the ray tracer using the post process
volume to kind of fine tune a few of those attributes. Next we're going to be
looking at the sky atmosphere and the volumetric clouds. And these two things
are really, really cool, and they actually contribute a
great deal to the overall look and feel of my project. So let's jump into
place actors, and I'll give you a quick demonstration
of how they work. I'm going to drag in
the sky atmosphere. As soon as I do that, you
can see the moon got darker but the environment's still black. The reason the
environment is still black is we haven't defined which
direction light is our sun. So we have a direction
light in our scene. Let's just grab it. Search for sun. And I'm going to turn on
the atmospheric sunlight. And as soon as I do that,
that directional light now drives how that
sky atmosphere works. So as I change the angle, you
can see the environment changing color as well as the overall
color of that directional light. So the light angle really ends
up driving everything in this. And you can see as
that sun kind of moves through these objects here it just
does this really fun little cool effect. Now, the next thing
that we're going to do is we want to add another
light into our scene to handle all the kind
of indirect illumination that would come from that
hemisphere of the sky. So that's done with a sky light. So as soon as I drop
the sky light in there, you can see the shadows now look
cool the way you would expect. Now, what we're going
to do is we're going to make sure that this sky
light is set to movable. And I'm going to click on the
box that says Real Time Capture. Real time capture on
a sky light is made to reference out to the
sky atmosphere as well as the volumetric clouds. It's very fast, very performant, and
it's basically just a simple switch. So once that's on, I can completely
control what my environment looks like, my sky environment looks like
with all the lighting information all with one direction
light and kind of it's all based on the angle of that light. So very, very cool,
super fun technology. Now, the next thing that I want to
talk about that you may have noticed is the sky atmosphere is taking
care of the top half of the world, but the bottom half from that
horizon line down is black. It knocks to black. That's not good for my
project because it's like this little planet
floating up in the clouds with this big old moon. So what we want to do is we
want to use exponential height fog to fix that. So as soon as I drop in
exponential height fog, it's not knocking back to
black anymore, which is great. And the exponential
height fog is actually made to work with the sky atmosphere. With that said, there are
project specific settings that you need to make
sure that are turned on for them to talk to each other. So just search for fog
in your project settings and make sure that these
guys are turned on. They may not be in your project. So with that done,
it's worth mentioning that exponential height
fog, as you can see here, is a tool that existed
before the sky atmosphere. And one of its jobs was to simulate
scattered light in the environment. The problem is we have
the exponential height fog doing that as well as
the sky atmosphere currently. And that's going to give us
incorrect results, because we're multiplying the colors together. So all you have to do is go
to the exponential height fog, fog scatter color, and make it black. And then we're going
to do the same thing for the directional indirect color. So we're going to take that
and also make that black. So now that we've done that, we've
got the correct lighting model. One more thing that
I want to mention is that I did use volumetric fog a
good bit to get to the overall look and feel of my piece. So I'm just going to go
ahead and turn that on. And you can see that it adds
in a little bit of volume scattering to the lighting model
in the scene, which is pretty cool. So this starts to look pretty good. Now, the other thing
that I want to do is I want to modify the way this
exponential height fog is working. By default, the gradient is going
up way too high into the scene and is contributing
way, way too much. So we're going to tone that down by
going into the exponential height fog. And I'm just going to
kind of scroll up here and I'm to give it
a bit more falloff. So it's just down there
on the horizon line. I don't want it graying out my
stars or fogging out my stars or my moon or anything like that. So we're just going to kind of
crank that up kind up nice and high like that. Now, I'm going to drop this sun
down a little bit lower in the sky so you can start to see
what's going on with this guy. So there's the sun. And you can see by default my
shadows are a little too crisp. So what we're going
to do is we're going to change the light angle on this. You can see they're
ray trace shadows. So the larger I make that light
angle, the softer and the more diffuse those guys are going to be. So I want that sun source to be kind
of big, because in my environment, I'm trying to make it look
like I have this big old giant moon that's lighting my scene. So the light source is big,
the shadows should be soft is. That's the point I'm trying to make. And I might turn this down to
something like, I don't know, five. We'll just turn that
down a little bit. Now, the next thing that I
want to do is I want to get-- let's get some clouds in here. The clouds are really fun, so we
might as well get those in here and start playing around with them. So we'll drop the volume
clouds in our scene. And you can see they look
pretty, they look cool. By default, those volume
clouds don't really have-- or I should say, by default the
light, the directional light, doesn't have shadows
turned on for cloud. So it's not interacting
with the clouds and creating shadows with them. So we want to fix that by
selecting the directional light and going down to its cloud sections,
which is somewhere down here. And we're going to turn on that. And as soon as we do that, you
can see pretty big change there. Another thing that
we're going to want to do on the actual clouds
themselves, if we go back to the world outliner, is we're going
to turn on the per pixel attribute for those clouds. So if we go into volume
clouds, I'm going to-- let's just pull this
across here a little bit. I'll go back up here. Go into cloud tracing. And we're going to turn
on the per pixel sample so you can see the effect of
kind of what that's doing. So that starts to look kind
of pretty and kind of cool. And it's really quite fun. Now, obviously as I move
my light through this too, it's just going to look really,
really nice, beautiful, realistic. You can see those shadows
kind of coming across. So what we want to do is
we want to get the sun sort of over here doing its thing. We could even push it back
here a little bit further. So that starts to look a little
bit more like what I had going on. Now, there's a lot of places
that you can play around with all these different sky
attributes, cloud attributes, and things like that. There's actually a
tool inside of Unreal that kind of consolidates that. So if you bring up the
environment light mixer, this gives you a kind
of a one stop shop where you can start to really
play around with this stuff. So obviously if we come
in here and we start to-- in mine, I actually made my planet
radius a little bit smaller. And I did tweak a fair
bit of these guys out. I actually gave it a little
bit of an aerial perspective view so that we're sitting up
a little bit higher in the sky and I gave it a little bit
aerial start sort of that. And then, of course, I
changed the overall look and feel for the clouds. I dropped that height
layer down a little bit, and then I actually made them. You can see here if
I look up here, you can see what happens when
I change that height flare. So how tall into the sky do those
do those clouds kind of go up? And there's just so much control
that you can play around with when you're dialing this stuff in. And one of the other ones you
can switch this from minimum to normal where you can see all the
different attributes on something, on the clouds or on the sky. So very, very powerful
tool inside of Unreal to dial in what these guys
are going to look like. And I actually made my
planet radius really small, because I wanted it to look like
it was this fun little planet kind of floating up there in the sky. And that was basically what I
did to get to the overall look and feel of the sky. So let's jump back to
the finished product and show you what it looks like. So I'm going to turn off-- let's keep that guy docked. I'm going to turn off the
stage, unload all that stuff, and we'll go to levels and we'll
turn off our look dev start. We'll turn our moon level on. And let's just get our
look dev done turned on. And of course, we need a house. We've got to have the house in there. So that is what the end
result ends up looking like. And you can see it's pretty fun. Now, if we jump over to
the world outliner here, there's a few things
that I have going on that may be interesting to you. So let's just grab
this light right here. This light is the moonlight. So you can see it's adding in that
extra little kick inside of there. And I talked about the volume fog. Each light has the ability to adjust
how much volume scatter it's giving. So if I put this up to one,
it's going to really scatter across that environment a lot. I had that toned down to
something a little bit lower. But you can use this to
adjust how much that light is going to come in here. And another thing that I'm doing
that's kind of interesting with this is if you look at my
sky fog color, this is a big spotlight that's in there. And that has a really
bright blue mixed into it. And I'm using that to
tint the environment. So what I've done is I've
made my atmosphere high. So in the sky system, the
higher you go in the atmosphere, the more it becomes
the vapor of space, the less color you have in there. So I had my sky
atmosphere a little bit higher so it looks like I'm
floating up in the clouds. Like the horizon line
is really pretty low. So it feels like
we're up in the cloud. So then I'm using this fog light. It has volume scatter
with that color in there to kind of tint that and give it
that sort of moody feel to it. And then I've got a few
other lights inside of here that are doing different things. I've got some rectangle lights
that are assigned just to the guy, and then I've got
some extra lights that are doing little kicks on the
house and things like that. So nothing super fancy. It really is the sky model that's
making up the majority of this. And then for the clouds,
I kind of fine tune them. And I did add one thing into the
clouds which I'll quickly mention. So if we go and we select
the volume clouds here, I'll show you the modification
that I made to those guys, because it's kind of cool. So in the volume clouds here,
I've got my own little instance that I made. So if we look at my
content browser, I just went to the
Engine Content folder and copied what makes the clouds up. And I modified it
with this DTO offset. So this gives me the
ability to slightly push or pan the clouds around. That functionality isn't in there. But I wanted to get this
little arm just floating over on the side of the cloud. So the way I did that, if we
just double click on this guy, I'll show you the change I made. It's actually really pretty simple. So this is literally I just
duplicated the material. And what I did is I
went in here and I just added in on the world
position of those clouds, I just added in a simple add
with this parameter DTO offset. And that lets me just push the UVs of
what generates the cloud parameter. So that's all I did. And then I also actually added
in a different texture map. So in the Engine
Content folder, there is a texture map that's got 128. And there's different
resolutions of the noises. So I actually bumped mine up
to use the higher resolution. So if you look in the content
folder, I just browse to it. You can see there's
a 32, a 28, and a 64. So I just went to the
highest resolution one. But other than that,
it was just a matter of me tweaking and playing around
with a few parameters on the clouds. And that's the overall look
and feel of the environment. So I hope you guys like that. Let's keep moving forward. All right. I'm going to hand it over to
Harvey so he can start talking about animating the character. HARVEY NEWMAN: So now that we have
this great scene set up by Daryl, I'm going to go ahead and show you
guys how to edit some animation. Obviously this guy is
already too awesome, dancing around, feeling happy. He could not like Halloween more. So let's see if we can find
anything to add on this guy. Now before I go ahead and
animate, just bear in mind that this is motion capture. And this motion capture has
been kind of like added. So the motion itself has
been added to a skeleton. Now, quick tip for you guys
is to use HIK for you guys to be able to create a
quick rig so we can start editing the motion accordingly. Now, if I go ahead and
show you guys the joints, you can see that it's just
basically a base skeleton moving around, doing his thing. Now, this already has
been set up for you guys. So I'll go ahead and actually
just show the IK handles. And you'll see that
in this way, things are much more like your
regular standard rig. So the way you set up HIK it's
actually by going to this little guy and basically defining
this character as an HIK. As I mentioned before, this
has already been defined. But the good thing about
it is once you define it, you can actually start
selecting your controllers and using this little
bit here as a picker as you would do with
any other picker. And it's a very useful way for you
to actually animate your characters. Now, if I were to actually edit
this motion, well, the first thing I would do, obviously, is find
a place that I can actually edit some motion. So for example, this hand here
when he goes over the head, goes through the head. So I would actually set
up an animation layer. After setting up an
animation layer, I'll go ahead and set up
some anchor points. So I'm not really
animating at this point. I'm just setting a before
key and an after key so I know that I can work within
this and know that after this point, the animation is going
to stay the same. And before this point, the
animation is going to stay the same. Now, I'm going to find the
worst part of the animation. And then within this part,
I'll go ahead and actually edit this motion a little bit. Add some rotation,
add some translation. When I'm happy with it, I set a key. And at that point, as you can
see, the motion is now cleaner. There's no intersection. The hand goes clean over his head. Now, I would actually do that
overall, the whole motion. After I'm happy with
the whole cleanup, I would have to
actually build my arcs. Now, for that, you can actually use
animation editable motion trails. Brilliant tool to edit your
arcs, to edit your motion. So if you go ahead and
go to your options, you can see motion
trail options here. So the way I have mine set up,
or I like to have mine set up, is by increments of one. And then I have 10 pre-frames
and 10 post frames. I also like to show my
frame numbers as well. And then I like to actually have
my trail thickness a little thicker than the default. The default is one. I like to have minus three. So if I go ahead and apply
and create motion trail, now you see that right there that's a
beautiful motion trail being created as the character moves around. 10 frames before, 10 frames after. Looks really cool. Now, those numbers that you
see popping up right now is basically the keys that
I set up here in my layer. However, if I actually
go back to my base layer, you'll see that the numbers displayed
are the numbers for the whole time range. One frame each time. So looks really neat
and is very useful. You can actually select those keys. And I'll go ahead back
to my layers so you can see how I would edit this bit. So if I actually go
back to my perspective and let's say that I want to make
sure that perhaps number 182, this arc is a little bit
bigger than it is right now, because I want to stretch it. Because I want a straighter arm. So if I set just one
more key here just to make sure that I
have an anchor and I can edit this bit with peace of mind. So I don't select the controller. What I select is actually the
key directly in my motion trail. And if I do that,
notice what happens. See that? It's not only editing the key itself. It's actually editing the keys before
and after to give you a better arc. This is a brilliant way for
you to actually quickly change your animations to make sure that
you have a better animation overall and have it with just a few keys. You can change your
animation accordingly. OK, so now that I'm happy with it, I
can go back to my cam, my camera z, and see our beautiful
motion playing around. I can go back to my file camera
and see this motion playing as I want it. Now that we have this
playing and looks exactly as I want it to,
all right, now that we're done with the animation,
I'll pass this along to Steven, who
will show you Live Link. STEVEN ROSELLE: Thanks
Harvey, thanks Daryl. Hi, everybody. My name is Steven Roselle. I am a product manager for Maya. And I'm excited to give you a
little sneak peek into a project that we're working on. And that is Maya-Unreal Live Link. So this is just a technology preview. And before I get into
the details, I want to throw up a quick statement
that basically just says that what you're seeing is exactly
that, a technology preview, and there's no guarantee that
we're going to ship this. And certainly don't make
any purchasing decisions based on what you're about to see. But I do want to give you a little
bit of a window into what we're doing. So the Maya-Unreal
Live Link has actually been around for a couple of years. It was originally developed by Epic. And it's two pieces. It's an Unreal plug-in
and it's a Maya plug-in. And when working in tandem,
they allow you to stream data from Maya to Unreal. It's very much focused on
character animation workflows. And so what we've done
is we've partnered with Epic to push this forward and
try to extend the functionality. And one thing that
we are working on is essentially kind of taking over
the Maya portion of this workflow, allowing our friends at Epic who
have extensive Unreal knowledge to focus on what they're
good at and allowing us with obviously a lot
of Maya knowledge to focus on what we're good at. And working together, we feel like
we can really improve this workflow in a lot of ways. So now I want to give you a little
glimpse into what we're working on. So here you see the
Live Link in action. You have Maya on the left. You have Unreal on the right
with a live stream of animation between the two. So Harvey is scrubbing the
timeline and also making updates to the animation. We asked Harvey to run through
the setup process, which basically involves launching the
Live Link UI in Maya and then launching a
similar UI in Unreal in order to make the
connection between the two. So you identify the Maya
Live Link as the source, and that will turn the little switch
on in the UI from red to green, indicating that you
have a live connection. Now it's just a matter of feeding in
the assets that you want to stream. So here we're adding the root
node of the skeleton character that we want to stream into Unreal. And we just have to go in
and create a simple animation Blueprint as the next step. And quickly rename that. And we'll open up the Blueprint
editor, or Harvey will. Essentially go in and make
the Live Link post connection. And as we connect this and
enable it, what you'll see is now we have a live
stream, indicating that we are connected again. So we can drag the character
into the Unreal environment. And there's one more step. We have to actually activate
this on the character. You can see as I scrub
the animation, or rather Harvey scrubs the animation, it's
not updating until I activate this. And now I have my live stream
set up and ready to go. And I can begin to animate. I can begin to key frame or
modify the various key frames. So we've been working with Harvey,
who's actively tested this and used this, and we've asked
him to go in and make some changes to the character
in order to refine the motion. And as you can see, as he drags the
manipulators for the control rig, and even as he used more advanced
features like the motion trails, the editable motion trails,
those will update automatically on the target animation in
Unreal, which is pretty awesome. So he can just basically
continue to iterate in Maya with all the
complexities of the control rig and all of the great animation
tools that Maya has to offer. And you can see that in
context in real time in Unreal. Now, some of the new things that
we've added in addition to the UI are things like blend shape support. So here Harvey is actually
going in and animating some of the facial
expressions and some of the lip syncing for the moon. And then he can put that in
context with the rest of the scene. So now since the animation data is
already in Unreal for the character, now he can go in and
relative to the character, he can start to animate
the blend shapes. And what you'll notice is the
timeline between Maya and Unreal are actually synced. So as Harvey scrubs
the timeline in Maya, that automatically updates
the timeline in Unreal so that you know exactly
what you're going to get. You know if you're
seeing frame 50 in Maya, you're seeing frame 50 in Unreal. So it's a really powerful advancement
with the Live Link workflow, and we really feel
like users are going to be able to benefit from this
in a lot of different ways. And we're really happy to be working
with Epic on pushing this forward. All right, back to you guys. DARYL OBERT: Thanks, Steven. That's looking really good. All right, so the next thing
that we're going to be looking at is how I generated the animated
logo for Happy Halloween. So if we play it back,
what we're seeing is 142 point lights that are
animating their visibility. Now, it would be really hard to
choreograph that and time that across the Happy Halloween logo
manually for each individual light. So what I ended up
doing is I ended up using MASH, which is
a set of tools inside of Maya for doing kind of
motion graphics workflows to animate that wipe. And then I take that
information and I use that to help drive
some Blueprint code that turns the visibility
of the point lights on. So I'll just play it
back one more time so that you can get a
sense of what it looks like and the overall effect when you have
all of these little ray trace lights kind of coming in and they're adding
their intensity to the objects next to them and things like that. I think actually it kind of works. I think it's kind of fun and it has
this really nice soft little glowy feel to it. So let's hop into
Maya, and I'll show you how to set up the MASH network
to get this animation started. All right, so here we
are inside of Maya. And what we want to do is use
MASH, the motion graphics tool set, to go ahead and generate
an array of geometry that's going to be numbered exactly in
the way I want the Happy Halloween logo to wipe on. So I've got a piece of geometry
that is in the right position, but it's one single node. So the first thing
that we're going to do is we're going to separate this out. So if we go to the Modeling Tools. And in the Modeling Tools,
we'll just run a Mesh Separate. So that's going to go through and
we kind of expand this out here, you can see that we now have
an array of poly surfaces. But if I grab the
first 14 of them, you can see that they're kind
of highlighted there. They're just randomly scattered
around the Happy Halloween logo. So that's not going to
give me what I want. So what we want to do is we
want to modify these a bit so that we can use the information
that's in these to position our MASH network or our instance. MASH is really just
a fancy instancer. So if we grab one of these
guys and hit the F key on it, you can see that the pivot point for
that guy is actually at the origin. So the first thing
that we're going to do is we're going to go ahead
and grab all 142 of these and we're going to do
a modify center pivot. So by doing that, now the pivot
point is in the correct spot. As I click around these
guys, that's cool. The problem is that their local
translation or their world position isn't correctly set. So let's just grab all 142 of them
again and run Modify Bake Pivot. So now as I click
through these, you can see that the translation
values are actually where they exist in world
space, which is pretty cool. So just to clean this up, I'm
going to do an edit delete by type history just for my own sanity. So the next thing
that we want to do is we want to use MASH to instance
a new piece of geometry onto these newly
generated poly surfaces that are in the right spot with
their pivots in the right spot with their world transforms
in the right spot. So let's get a piece
of geometry for MASH to work with by
creating a polygon cube. And if we frame it
on this guy, you can see it's just sitting
there at the origin. And to make things a little bit
easier to see when we instance this, I'm just going to crank up
the intensity of that guy. So what we want to do is we want
to use MASH to create an instance-- 142 instances that
we are going to get positioned where those
helixes used to be. So we'll go and click on
the Create MASH Network. And the distributor
by default is going to put 10 objects
going down the x-axis. We want 142 objects. And if I just crank this
up to something like 600, you can see that-- or 500, whatever. I've got a long line of cubes. That's not what I want. I want the cubes on that
Happy Halloween logo. So that's really simple to do. By going to the distributor
and switching it from a linear distribution
to become a initial state. So with it set to initial state,
now all I need to do is drag and drop these nodes on. Now, if I select one
of these nodes, it's going to select the MASH distributor. So here's a quick tip. If you just say copy tab,
it's going to give me a duplicate of that attribute editor. So now you can see it
deselected like I said it would. But I have this
duplicate sitting there that will let me drag and drop
those guys on there really, really quickly just like that. So let's frame in on that guy. And you can see there
are our instance cubes exactly where we would want them. So the next thing that we need to do
is we can go back into the MASH node here. We need to add in
the ability for this to have its visibility animated. So go to the Waiter and
click on Add Visibility Node. So now if I was to do something
like drop the random strength down, you can see randomly those cubes'
visibility is getting turned on and off. Now, that's not what I want. I really want to be able to
control that with a volume. I want to be able to animate
something across these and have that change the visibility. So easily done by going
to fall off object, right clicking, and saying Create. So we now have this fall off object. If I kind of zoom out here, you'll
see that it's at the origin. So let's just go ahead
and grab that guy and hold down my V
key to snap it onto-- get you over there. Kind of snap it onto that
Happy Halloween logo. Kind of frame in on that guy. So you can see wherever
this goes, it's turning on the visibility of those
guys, which is really pretty cool. Now, I'm going to make
this a little bit bigger, just because it's going
to be easier to work with if it's kind of a big thing. And just for demo purposes, I'll kind
of crank through this pretty quick. So as I move this
guy across here, you can see it's turning on and
off those, which is great. So what we're going
to do is we're just going to literally animate this
volume wiping across there. So we can just hit
the S key right there. We can move forward 60 frames
or something like that. And I'm just going to literally move
this guy across something like that and hit the S key one more time. So now as I scrub my animation,
you can see that they turn on, but they kind of turn off
when it leaves the volume. And this is easily fixed by
going into the MASH volume, which is this guy right here, and switching
the mode from normal to add. So watch what happens as
I scrub through this now. It's going to just
only add visibility. It will not-- after the volume
leaves, they stay lit up. So that's pretty cool. And that is how I basically
went ahead and created that. So the next step is to take
this array that we just made and have it generate actual geometry,
because right now this is also-- like if we kind of scrub into this. It's one piece of geometry. So how do you do that with MASH? It's actually pretty straightforward. What we're going to do is we're
going to take this piece of geometry and we're going to modify it. So if we go into animation, we're
going to say MASH Utilities. And we're going to tell it
to switch geometry types. So by doing that-- oh, it wants
me to select the Waiter. So let's grab the Waiter,
and say MASH Utilities, Switch Geometry Type. So it's now set up to
become an instancer instead of one mesh, which is pretty cool. So with it now being an instancer,
all I have to do is I have to say, you know what, on
this instancer, let's go ahead and run a utility that's
going to bake instancer to objects. So this is fine. We'll tell it to bake the animation. And we'll just say-- I think I did 60 frames. I don't remember. So I'll just do 70 frames. And we'll say Bake Animation. So it's going to go through. You can see boom, boom, boom, it
just added in all that information. And now what I have
is I have an array that's going to go through
these based on how-- you can see that it's just an
array of numbers or geometry that's correctly numbered
the way I need it to be. As I select these guys,
they're kind of coming through. But the problem is they're in the
correct order in the outliner, but the numbers are all random. So all you have to do to
fix that is select them in the order which you select them. So if you just grab the first
one and then you scroll down here and you grab the last one,
and then you come up here. And this is a really
cool little trick. All right. So switch on the renamer. And then just take this
and just say, I don't know, we'll just call it fun. So boom, just like that. So we now have our network in order. And that's what we
need, because that's what the Blueprint code is going
to work off of inside of Unreal. So it's kind of a strange workflow,
but hopefully it makes sense. MASH is an awesome tool and it can
do all kinds of fun crazy things. So let's jump in Unreal and I'll just
walk you through that Blueprint code really quickly. All right, so here we
are back in Unreal. And you can see we've got these
cubes in the correct spot. And what we want to do is we want
to search and replace all 142 of the cubes, which I'm going to
select all right here with a point light. So we're just going
to grab all of those. Right click on top of them
and say replace actors with. And then we're just
going to say point light. So it's going to go through. And just like that, add in 142
point lights, which is kind of cool. And then, of course, we can
set our attenuation down to something a little bit smaller. And let's just make sure that those
guys are all set to be movable. And they are. And their intensity is way
way, way, way too high. So let's tone that down a bit. Something like maybe 0.1. I don't even remember
what I had it at. And look, you can see that volumetric
fog kind of coming around those guys and glowing those out. And then, of course, you
can change the light color to make them nice and warm
or do whatever you want to kind of fine tune in that look. But let's go 0.02 or
something like that. That's getting close. Maybe it was a little warmer. Well, it might be a little much. Yeah. So maybe 0.01 is what I had. Something kind of like that. So now we've got our lights. So the next thing
that we want to do is we want to create the wipe
effect using Blueprint. So let's go ahead and check that out. All right, so the first step is to
get all the lights to an off state before we go in there and start
using blueprint code to turn them on. So let's go ahead
and select them all. And just search for visibility. And just throw those
guys to an off state. So I'm going to build
this up in two steps. The first thing we're going to do
is just create some Blueprint code that turns on all the lights. And then we'll put in the
delay after we do that, because delay is a
bit more complicated. So we're going to create
a new Blueprint class, we'll just make an actor blueprint
and we'll just call this BP. We'll call it BP test, just because
we're kind of working it up here. So if we double click on this
and we go into the event graph, off of event begin play, the
first thing that we want to do is get a list of all
the point lights. We want to get those
lights in an array. So we're going to do a
get all actors of class. This is, again, going
to create an array. And the class that we want
to create is a point light. P-O-I-N-T. So we're going to get
all the point lights in the scene. With that, what we're
going to do is we're going to run them through a loop. So this is going to create an array. And what we want to do is we want
to say for every light that's in that array, go through
for each one of those and set their visibility. So if we pull off of here
and do a for each loop and just shove the out actors array
into the input array for each loop, then off of the body,
the loop body, we're going to give it the command that we
want to do, which is set visibility. So if we pull this out
and say set visibility, you can see there's a set
visibility point light component. And that automatically gives me
this point light component input that we just want to take
the array body, this element, and shove that into there so that
it's basically going through, it's querying, it's finding
all the point lights. It's making an array,
and then it's going to go through for each
object in that array and set its visibility
to an on state. So we'll just say on. So we'll compile that. We'll hit Save. And we'll drag this into our
level and we'll hit Play. And just like that, you
can see the light comes on. Now, to make this a
little bit more clear, I'm going to go back
into this guy and I'm going to put a delay in here. So we'll just type delay. And we'll tell that
delay to be one second. We'll compile. Let's just clean these
guys up ever so slightly. And with that done, we can play. So play. One Mississippi. They turn on. Pretty straightforward. So we have a simple delay. We hit Play. Takes a second. Runs through for each loop. Everything turns on. So you think, OK, that's cool. Let me put the delay
after for each loop. Now, here's the problem. Let's just try it
and see what happens. Put that there. We'll put that there. We'll put that there. We'll compile it. We'll hit Play. And you can see it executes
through, but nothing happens. It's just one of them
turns on and that's it. So the reason that happens is the
for each loop, that for each loop happens all at once. It happens during the first
tick that it hits and it just, boom, floods it, done. That's it. So you can't put a delay
before or after in the array. You couldn't put it here. You can't put it there. It's just the way Unreal works. So how do we get around that? What do we do to fix that? Well, what we're
going to do is we are going to create our own special
version of the for each loop. We're going to basically
copy that for each loop and we're going to make
a modification to it. So we're going to make our
for each loop with a delay. And this is really pretty
straightforward to do and pretty easy to
do inside of Unreal. So let's compile this
guy one more time. And let's jump in there and
make that special for each loop. All right, so here we are
in the for each loop macro. And what I did is I
basically grabbed all this. I copy and pasted it into
a new for each loop macro that I basically set up. And the only node that you need to
do is you go to the inputs node. And on the inputs node, you add
in a new delay float variable. So that will be something that
you can adjust in this node. And all you have to do
is in between the assign and this branch is
add in the delay node. So it comes out of
that, loops around, and it introduces delay
before the branch. So it's literally just
introducing this one node and then wiring up an input so that
we can adjust how long that delay is going to last. So now all we have to
do is substitute out that for each loop with
this custom version that has this extra
node added into it. So let's go ahead and close this down
and I'll show you how to do that. So if we go back to our BP
test and I drag out off of this and I do a for each loop with
delay, you can see here it comes. And we don't need this one anymore. So we're just going to wire that up. And we'll wire that up. And we'll take the array
element into there. And we can blow this guy away. So you can see there's that
extra input that we added. So let's just go ahead and
add in a second, I don't know, something like 0.2 or
something like that. We can compile this. And now if we hit Play,
it's going to come through. And they're going to
basically go through and wipe. Now, it's wiping in the wrong
order, which is a bit of a bummer. But that's not too hard to fix. Let's go ahead and address
that really quickly. So let's just jump back in
here and let's take this array and let's just reverse it. So coming out of the array if we type
reverse and just shove that in there and compile it. That was kind of a silly mistake. But I think the
reverse should fix it. Let's check it out and see. So it plays. And yeah, here comes my happy logo. So really pretty fun. That is basically it. Hopefully, that makes
sense to you guys. All right, so here
we are back in Maya. And the last thing that we want to
do is send over some Alembic files. And Alembic is another
standard open source file format that's great for
exchanging cached geometry. Alembic grooms for Xgen
hair, things like that. So we've got some meshes that
were made using Bifrost as well as this little animated spider. And if I kind of scrub
through this, you can see he's got this
little movement on there. He's just kind of
constrained into that web. So we want to grab all
of this information. And we're going to save
out an Alembic file. And we'll just tell it
to write this guy out. So we'll say create an Alembic cache. And we're going to export
selected to Alembic. And I'm going to give it a
start and end range of 1 to 300. And we'll hit Apply on this. And we can send it to we'll
just call it web spider. That's fine. We can overwrite this one. And it'll take just a
second to write this out. All right. So with that done, let's
just jump back into Unreal. We'll go back to our content
folder and inside of here. And FX will jump in. And we're going to do an import. So we'll say File, Import. And if we go into scenes,
we'll jump up a level to cache. Go into this Alembic cache. We'll grab this guy
that we just made. And it's not a static mesh
that we want to bring in. We want to bring in this geometry
cache, and that is all good. So we'll just say Import. So it'll take just a
second to import this in. All right, so with that done, we can
go ahead and get ourselves kind of positioned down here. Oops, I got this weird cube in here. Let's get rid of that. I don't need that guy. And let's go back to our level. Let's make sure that we
don't have any of this. Logo start, logo done. That looks good. Let's just add in this spider cache. And we can go to our Details panel
for this guy and just 0 that out and kind of zoom in on this. You can kind of get a
sense of if we hit Play. There it goes. So you've got the spider. You've got the spider web going. We've got our Happy Halloween
sign up there doing its thing. And then, of course, there's the
dancing guy that you saw earlier. So that is basically it. I'd like to thank everyone for
their time, the amazing questions that we had in the chat. It was super fun. I'd, of course, like to thank Harvey
and Steven for all the hard work that they put in on the file. Cheers, everybody.
