[VIDEO PLAYBACK] [MUSIC PLAYING] - We have touchdown. Can anyone hear me? Please copy. [CHATTER] [BARKING] - Mom, mom. Do we have any methylated spirits? - What? What are you wearing, George? - The space man needs it. - Well, the spaceman
can make do with water. - Yeah, we saw The Omega
Man the other night. Pretty-- pretty bloody [INAUDIBLE] - Hello? [INAUDIBLE] Where you going? Jeez, you're growing up fast. - I mean, he's supposed
to be a scientist, right? I mean, walking around
[INAUDIBLE] pandemic. - Exactly. - Dad, can I go [INAUDIBLE] - Back to your bloody microscope. You know what I mean? - Dad, you smell like beer. - I know. That's my special perfume. But the missus liked it. You liked it, didn't you? - What's not to like
about Charlton Heston? - Dad,
can I go on an adventure please? - Yes, love. Course you can. Off you go. [MUSIC PLAYING] [CHATTER] - Jim likes me. He still likes me. [MUSIC PLAYING] [CHEERING] - I'll tell you. Any time there's a
blackout, I just-- I feel so powerless. Someone try to remind me
where the fuse box is. Do we even have a fuse--
what is a fuse box? It is the same. [CHEERING] - Gentlemen, I give you the videos. - What's that? - [INAUDIBLE] - Warren? Warren, can you go and see
what that mutt is barking at? - Yeah, just a minute. Why isn't it bloody-- - Warren, the dog. - Would you just let me finish? - George? George? Georgie? - We're upside down. - Georgie? Warren, she's gone. [END PLAYBACK] AMANDA SCHADE: Hey, everyone! With all the excitement
of Unreal Engine 5, we want to take a
moment to recognize the incredible
contributions from you--the Unreal community! Enjoy the latest community sizzle,
packed with amazing projects in film production to games to animation
and beyond--watch the full video on the Unreal Engine
YouTube channel! Ever wanted to fly a
broom or fight a dragon? Well, now you can! With Wevr's new virtual
reality experiences for the Harry Potter store, anyone
can make their own magic firsthand. Discover how the team created
interactive spell-casting and broom flight systems in our latest
interview on the Unreal Engine feed! And speaking of
dragons, the talented team at indie studio Playwing have created a dogfighting
flight game like no other. In the team-based competitive
multiplayer Century: Age of Ashes, jump into the saddle of
a fire-breathing dragon to battle enemies,
swoop through castles, nosedive down tunnels, and take
evasive action to shake off pursuers in the process. Soar over to the feed to find
out how the team finessed the aerial ballet of flying a dragon
and the inspiration for the game. Popping over to our community
spotlights--this week we're kicking off with a quaint Countryside
Cottage from Royston Buthello. Created with a variety of DCC tools,
they used this opportunity to dive in to UE4 to learn about
shaders, lighting, Blueprints, and more--head over to their
ArtStation page to let them know what you think! Here we have a beautiful interior
environment from VasanthAnbu. They could've fooled
us when they revealed it was their first UE project. Stroll over to the forums to give
them your feedback and props! And last up, we have
Heartland, a lovely short film and powerray's first UE5 project! After learning the basics of
development for a few months, they leveraged free Marketplace and
Quixel assets to build the project. Pop into the forums to check it out! Thanks for watching this week's
News and Community Spotlight! TINA WISDOM: Hello, everyone
and welcome to Inside Unreal, a weekly show where we
learn, explore, and celebrate everything Unreal. I am your host Tina,
and today with me I have two incredible guests,
Russell Paul and Ryan Schmidt, here to talk with us today a little
bit about the geometry tools in UE5. So starting off, let's get to
know our guests a little bit more. Russell, would you like to tell
us a little bit about yourself? RUSSELL PAUL: Sure. Happy to be here, first of all. I'm Russell Paul,
Senior Technical Product Manager. I'm focused on geometry
tools, modeling tools, as well as helping out with
the automotive industry as well in my spare time,
which I don't get that much of. I've been modeling for-- oh my god, almost like 30 years now. I started in the early
'90s learning Alias, which was one of the
early modeling packages. And then I spent a
good long time modeling for visual effects production before
joining Epic about three years ago. I've been working with Ryan on
modeling tools and geometry tools for a couple of years
now, and version 5 is sort of a giant
leap forward for us, so looking forward to
sharing it with everyone. TINA WISDOM: Yeah, absolutely. It's incredible. The increase in features and tools
and the stuff that's available now-- it is absolutely mind blowing. But Ryan, would you like to tell
us a little bit about yourself? RYAN SCHMIDT: Sure. Hi. Yeah, also super excited
to be doing this. So I'm Ryan Schmidt. I'm an Engineering Fellow of
Geometry on the Unreal Engine team here at Epic. So I've been at Epic for
about three and a half years, and I came to start these things
we're going to talk to you about. So I came here to sort
start up this initiative to build 3D modeling
tools into Unreal Editor. And then recently have started to do
geometry scripting for Unreal Engine 5.0, which we'll talk about in the
second half of the stream here. I previously worked at Autodesk
on some software called Meshmixer, and basically I've been trying to
figure out for quite a long time how to build these kind of tools
into game engines and editors. So it's super exciting for me
that it's sort of happening and that all the people
watching this are going to go off and use it afterwards. Definitely for sure-- please do. TINA WISDOM: Please do. Use the cool things that
they have worked so hard on. All right, well, we'll kick
it off with Russell here. Do you want to explain
a little bit about what you're going to walk through? RUSSELL PAUL: Sure. I think if you want to swap over
to my screen, we'll get going. Obviously, the first thing
we're going to do is-- I'm in vanilla UE5, just from the
launcher, just so everybody knows. We're not showing
anything special here. But just wanted to give everybody
an overview of the modeling tools and just kind of walk
through the basics. There's a ton of modeling
tools that are available, and there's no way that we're
going to get through all of these. But I want to just give everybody
kind of a little introduction so they can get in the
package and have some fun. So first things,
just so everybody knows, you do need to turn on the plugin. It is loaded automatically
with some of the templates, but if you don't see the modeling
tools under the mode for modeling, you might want to just
check and make sure. So I'll just go to the plug-ins, and
look for the Modeling Tools Editor Mode. You can also turn on the Static
Mesh Editor Modeling Mode. That's going to add a subset of the
tools to the static mesh editor. And then the other thing that
we're going to look at today is there's a new-- it's
still tagged as experimental, but a standalone sort of UV editor,
so we'll talk about that just a little bit today as well. So you might want to turn
that plug-in on and just help Ryan out as well. There is the plug-in for-- let me see if I can get in here. So there is a Geometry
Script plug-in that Ryan is going to go over, but you just want to make sure
that you have all those turned on. Once those are all turned on, you'll
get this modeling pallet right over here with all these really,
really fun modeling tools, and so we'll start to
dive into some of those. Modeling Mode is relatively new. It's been around for the
past couple of releases, but it's really come to
fruition in this version. And if you're coming at this
from non-modeling background and you're just jumping into
Unreal, great. If you come from another background,
a couple of things to keep in mind. We're working with static
meshes most of the time, and that's what we're going
to be focused on today. So you want to keep
track of managing the meshes as you're
building them, and so one thing that
to take a look at is this little area down
here at the bottom left. And that actually keeps track of-- one thing to look at is one,
what LOD you're working on. So if you want to work on a
specific LOD of something, you can actually
switch that one there. But what's really
important is understanding where your meshes are and your
elements that you're creating go. So there's this new asset location. I clicked on the little gear icon
just so that you can bring up some of the other options. You can turn off or on, and you
can look through these at the time. I've specified a specific
path just called meshes_rtp just so that I know
anything new that I'm creating is going to get
placed into my Content folder, and then I have a meshes_rtp. So anything new I create is going
to get dropped into that folder. So it's just a little bit of
housekeeping for everybody. The final thing is-- so this little scene that I have
here is just a project I made. I just said New
Project..., I said Games, and I grabbed the Vehicle
template because I thought it'd be fun to try and actually
do something in a space as opposed to just looking at-- pushing
and pulling spears around. So this is just this
little game template. And then I went out to
the good old Marketplace, and I grabbed this Automotive
Salt Flats environment which is kind of a nice little space. And I just merged it
into this scene so that I can have my vehicles
so when I hit Play, I can actually have my car,
and I can drive him around on the little wide open salt flats. So what that did is
that kind of inspired me that maybe what we should
do is sort of-- this is a Rocket League car
anyway, so maybe just show off some of
the modeling tools by thinking like,
what if we go ahead and start making some Rocket
League obstacles or things to do? I'll kind of run through some of
the tools in sort of in that spirit. So up at the top left
here, basic shapes. Let's just grab a quick box. This is different than
the older style place box. We have a lot of options here for
size, subdivisions, polygroups. We'll cover polygroups a little
bit more as time goes on, but these are really useful
concept that we can have. So I'm just going to drop
a little box in here. Say Complete,
just to drop in the space. Let's give it a better material. Since this is starting
with a template, we have these nice sort
of basic materials. And of course, these meshes come
in, and there's an option for if they have physics control. So for instance, if I was to drive-- [INAUDIBLE] which
is not very helpful. I think what we need to have
is we need to obviously-- I have this beach ball that
I kind of made earlier. So we're going to
make a little ramp. So there's a couple of different
ways that you can edit this. Let's do the first one
here, which is-- everything in Unreal
is a triangulated mesh. If you really want to
just edit triangles, you can just go ahead and
grab these triangle edit, and you can actually interact
directly with the triangles and move them around if
you wanted to or edges. So if we wanted to sort of make
a really, really sort of crazy steep ramp here-- so this is all sort of stuff
that I think a lot of people might be familiar with. This is just editing
the triangles directly-- and I would say Accept. And once again, what I've found
really fun about this whole concept and having the modeling
tools in here is this idea that I can actually craft and
kind of come up and conceptualize ideas and things directly in
the space where I want to be. So I'm not actually having
to think about stuff in Maya or Blender or other packages. I can just kind of
come up with these kind of crazy ideas
directly here. But obviously,
this is a pretty boring ramp. Let's go ahead and try and
make it a little bit nicer. So I'm going to jump over
to the other side of tools, and this is called
PolyEd (Poly Edit). It's actually short
for PolyGroup edit, not for Polygon edit,
which is a little deceiving. But when I have this mesh
and then I select PolyEd, you see that I get this
whole set of new tools that I can work on and utilize. And what it is this
group is the collection of the triangles that were there, so
each one of these faces is a group. So I can grab these,
this little group right here. I could actually say like
Extrude if I wanted to. Or because these groups are actually
structured like a square, a quad, we can actually kind of mimic some
classic quad-based modeling tools, like insert edge
loops, if we wanted to. Then I'm going to say I'm done
inserting some edge loops. Let's make this ramp a
little bit more interesting. We were talking earlier about
watching people modeling and how exciting that could be,
and now here I am just modeling, and you get to watch-- how exciting it is to be doing that. So we'll say Accept. So we've got a little bit
of a little bit better ramp. Let's see if we can jump
and hit our ball over here. Let's do this here. All right, look at that. I should build a wall back there
eventually because that ball's just going to keep rolling for endless-- TINA WISDOM: Into infinity. RUSSELL PAUL: Yeah. I actually had this idea of
building like a little stadium arena and stuff, but I was
like, I got 30 minutes. I can't. Anyway-- of course, this is great. This is sort of a fun
little blocking thing, but one of the things that is
really great about these tools is-- and what's going on with some of
the other integrations into UE5-- is how far you can take
some of this kind of stuff. Since we're out in the middle of the
desert, I kind of was thinking maybe we can do a little
Burning Man kind of thing. So I think what we need to have is-- I'm going to go grab
another cube here. Let's Complete this guy. And instead of it being sort of
just this plain gray thing here, let's make something--
let's say 2 by 4 by-- it's really thin. Obviously, I've gone in,
and I've tweaked my scale values. So let's go ahead and bake
the scale so that we just have a regular 1 to 1 scale on this one. I don't need to Bake Rotation. I'll turn that off. And let's see what else
do we need to do this. Well, we probably want
to round the edges. So there is a bevel tool in here,
so I'm to just grab that guy. I'll say PolyEd. I'm going to just grab the edges
real quick, just so that we can-- and I'll say edge Bevel. That's a pretty significant bevel. Just turn that way
down, just to give a little bit of an edge in here, and we'll say Accept. And then I need to give this
a little bit better texture, but before that,
there's some UV tools down here. There's some really,
really great automatic UV tools. I would definitely say
explore some of these options. The AutoUV tool, especially when
you have really complex meshes, if you bring in a sculpt
or something like that, there's some really great automatic
unwrap tools that are in here. But we're just going to
grab the basic Project. I'm going to do a Box
projection, and let's just say-- basic box like this. And we'll say Accept. Now, obviously, I don't know
what the heck this looks like. I don't have any of these so this is where we would go in and jump
in and say, under Asset Tools, and then I'll say UV Editor. And so now, we can actually have
a nice little UV Editor area here, so let's just turn on
our checker pattern just so we can see what's going on. And there are some tools in here. This is brand new, so we're still
building up the toolset in here. But there's definitely some useful
tools for sewing and splitting, or for go ahead and solving islands,
for unwrapping an island with-- But we can also have
some basic things in here for, hey, let's just lay
things out and pack them together so that we can have a
better packing of all the pieces. Those are useful as
well, so let's just make sure that what we have is-- turn that checker pattern back on. I want to make sure that
the top and the bottom have lots and lots of space. So there's this little menu
up here at the top where I can select individual islands,
so if I want to grab specific spots, I can go ahead and say,
let's just move this around. I think that's the bottom. No, that must be the side. This is the fun part of me going,
which part of this [INAUDIBLE]. TINA WISDOM: It's always the
challenge with UVs. [LAUGHS] RUSSELL PAUL: Yeah, UVs are
definitely a love/hate relationship with things. It's like everybody loves them, and
then hates them at the same time. It must be this one. There we go. So let's just grab that guy
here, and this guy here. So let's just rotate
those guys around just so we can move
those guys a little bit. Make them a little bit bigger
just so they take up more space, and let's just say that's done. I don't want to waste
everybody's time doing UVs. But we need to give that a
better texture, so of course, in case you haven't noticed,
one of the awesomest things that came in lately is you can actually
launch the Quixel Bridge directly from the Editor now. So if you wanted to
add stuff in here, you can actually just
click on Quixel Bridge, and what's great about
that is you can just go ahead and find all
sorts of stuff in here, whether it's 3D models or textures. So if I was looking for 'plywood', there's all sorts of
surfaces here for plywood. So I just grabbed this sort
of old plywood, downloaded it, added it to the space. And now that I have that here
in my Megascans directory, Surfaces, just go to Old_Plywood,
drag and drop that on. So now, we have some plywood. Now I want to make
a nice smooth ramp, but obviously,
this was just a basic cube. So let's go ahead and go back to
PolyEd, and what I'm going to do is I'm going to use the
Insert Edge Loop again. But this time, instead of using
just a single cut, because I know want to make this ramp a
nice little curved shape so that our car can be a little better. Let's go to Even. Let's say four sections. There we go. Now, we can curve that,
and now let's go ahead and make another
couple of copies of it. We don't want it repeating,
so let's just rotate this guy by-- I'm repeating texture here. I noticed that my pivot point
wasn't centered between those guys, so let's just go ahead
center the pivot. And you'll notice that, since these
are all instances of the same one, they're all going to shift a
little bit, which is expected. Because since they're
all instances, when I adjust the pivot of the first
one, the second and third one will actually adjust their pivot. So let's just go ahead and
[INAUDIBLE] the same space, so now we have nice starting point here. But of course,
what we need to do is we need to support our ramp with
some structure, so once again, by going into the Megascans
directory and grab some 3D assets. Let's just grab this
wooden beam here. Because we need-- can't have
our plywood floating in space because that just wouldn't
be physically correct, now. Would it? TINA WISDOM: My plywood
always floats in space. I don't know what
you're talking about. RUSSELL PAUL: Yeah, I know. I don't know. It depends on how physically
accurate we want to be, I think. Let's see, that's somewhat OK. I didn't type in my rotation
values perfectly, so-- Trying to remember,
type in everything perfectly. All right, let's just-- Go ahead and move those over. You have support on both sides. Now, of course,
what we want to do is we need to make some shape out of
this, but these are all instances of each other. And this is something to keep in
mind as you're modeling in here. If I was to go ahead and, say,
take this one piece of plywood and bend it, all the other ones
are all looking at the same mesh. So what we want to do is we
don't want that to happen. We want to be able to bend
each one individually. So one thing, in this situation
like this, that is actually kind of an easy thing to
do, is I'm actually going to grab all of these
parts, and I'm going to go over, and I'm going to use the
MshMrg (Mesh Merge) tool. And this gives you a couple
of different options. One is,
I'm going to make a New Object, and I'm going to call it 'rampTop'. And then the Output
Type is whether or not you want to make a static
mesh, derive it from the input. You can also make volumes
and dynamic meshes, too. I think Ryan will talk a little
bit more about dynamic mesh. I'm going to focus on static mesh. And then you can decide what
you want to do with the input. So I'm actually going
to delete the inputs. Actually,
I'm just going to hide the inputs. So that's all the input meshes, and
if I say Accept, what I have now is I now have one mesh that
represents everything there. So now, this is helpful
because, now, I can go ahead, and it's just one mesh
that I can work with. So now, I can go ahead and
say, what I want to do now is I want to just go
ahead and grab a Lattice. So let's just go ahead
and say [INAUDIBLE] Interpolation Type is Cubic. And then once again, you get
to watch me move points around to make some shape that I want. Oh, no. Missed some point. So we can keep-- like I said,
if we had more time of the day, I could spend all sorts
of time just playing with this to make sure that the
shape of my ramp is perfect. But let's just say something
like that's looking pretty good. Let's hit Accept, and so now,
get this ramp out of the way. It's kind of a chintzy little ramp. [INAUDIBLE] All right,
so it's looking pretty good. Let's hit Play. See if we can jump. See how this jump works. Oh, anyway, well, the ramp was good. TINA WISDOM: You still hit the ball. RUSSELL PAUL: I still hit the ball,
which is all I was looking for. But obviously, since I talk
about being physically correct, one thing that we don't
have here is we don't have any supports for this guy. So let's go ahead, and I'm
going to grab that beam again. And so far, all I've been
doing is literally just sort of just grabbing these Quixel
pieces and sticking them in here. I haven't been doing anything to
modify them other than a lattice, but you can do, actually,
all sorts of things. But in order to do them properly,
one thing that we want to do is, same reason that I had
up here with the plywood, I want to make sure that I
am not doing things that is going to affect any instances of it. So for instance,
I have this one beam, and I know I'm going to need
to cut this beam in order to not pass all the way through. So I'm going to actually
duplicate this mesh, and this is not just an instance. It's not just making a copy here. It's actually making a
copy in my asset folder that I'm going to use later. So I'm going to make a copy of it. I'm going to keep my input so
that I can use it later, and then let's just rotate this
guy, say, maybe, 45 degrees so he can support it. And then I'm going to do that
again, so same thing, Accept that,
and let's just rotate that. Maybe like-- actually,
let's rotate that all the way. Let's say 90. I'm not going to spend all day
modeling, which I could do, but let's do one more just because-- just because. So stack that guy up here, so
that's looking pretty decent here. So we got these things,
but obviously, they're passing through each other that,
which is not really what we want, so I'm just going to go
grab one of these guys. And there's a bunch of editing
tools here that you can work with, so PlnCut (Plane Cut) is a really
helpful one, especially when doing something like this. So I'm just going to
drag this guy down. Give it a little bit of a cut. Let's do the same thing to this
one, except for this one, we obviously we have a couple
more things we need to do. So go up here. So instead of a single cut,
I'm going to click on the Cut option right there,
and I'm going to say Flip Plane, so that way, I can actually
cut a couple more times. So cut it right there. Let's say Cut,
and then we'll rotate. TINA WISDOM: This
is blowing my mind. That's incredible. RUSSELL PAUL: Let's do this
last one over here, and-- RYAN SCHMIDT: Russell, you should
show the control clicking maybe. RUSSELL PAUL: Yeah. Oh, here. RYAN SCHMIDT: It's too late now. RUSSELL PAUL: Oh, I could-- at least,
I wasn't able to undo that one. RYAN SCHMIDT: I don't know if
it'll help actually for these cuts. RUSSELL PAUL: Yeah,
I don't know if it'll help. Yeah, anyway. So we'll just do that one. What is cool about this
one, though-- what is nice,
it filled in this gap here. Up at the top here,
there's a piece of wood, but this is where,
sometimes, we don't see it. So I wasn't originally
going to worry about it, but this is actually a perfect
time where I could go here, and I can say, Asset Tools and
jump over to the UV Editor here. And let's say Display
Background and Material. This is a-- beam texture,
and then what I want to do is find that new thing
that he made up there. So let's drag that around
so that we actually can give that some proper end grain
as opposed to what it was before. You can say Apply. You should see, so now, we actually
have some proper end grain on there. That's good. Not that you can see it,
but modelers are like that. We get all antsy about
that kind of stuff. Pivot, Center that just
so I can drag it over there a little bit more. Want to make sure that I had
proper end grain on there. Now, you know what,
the last thing this thing needs is this all stuff is not nailed
together in any way, shape or form. So as I was putting this together,
I was trying to think of what are some things in mixing
and matching and adapting different tools? And so obviously,
one thing we want to do now is we're going to use some
of those Poly Editing tools to make some brackets to
put some things together. My favorite most used
tool in a modeling package is--we're just going
to say box here. Make a area down here. And I'm going to just
jump into PolyEd, and I'm going to
turn on Select Faces, so I can grab this face. There's different selection
techniques and Marquee Selection, so if you select-- you could
select vertices or whatever. We can frame in on that guy. I'm zoomed in super close here. There is a method to my madness. Trust me. So then let's grab this guy here. I'm going to use the
Push Pull tool here. Maybe [INAUDIBLE] out a little bit
further and then grab this guy here. And what we need to do is, let's go
ahead and insert a quick edge loop. Not that many. So the other thing that I didn't
mention in here to just keep in mind is there's Insertion Mode,
and there's two different ways that you can do it. One is Plane Cut,
and the other one is Retriangulate. And Retriangulate can be
really helpful on your mesh if it's going to stay in these
nice sort of square poly groups. Because what it'll
do is it'll keep-- and you can turn on
the triangle here. Might be hard to see. So Plane Cut is actually going to
cut the existing triangles with-- so you'll have the
existing triangles plus whatever new triangles are needed, whereas
Retriangulate will actually give you nice clean triangles. So you end up with just
two triangles per one of these poly groups, which
can be really helpful for doing [INAUDIBLE]. So let's just grab those guys. Move them over. Grab this face right here. Extrude that out a little bit. So we got a nice
little L bracket that's going to hold our ramp
edge together here. Let's go ahead and just
do a-- grab that guy. Go back to our UVs. Just do
another quick box projection. Let's see what sort of
fun materials I grabbed. Rusty Black Metal--
throw that on there. So now, we have a little bracket. I think what we need,
just to help tie this all together, is we probably need some bolts. So let's just throw a couple of
little quick little bolts in here. That's way, way too big. So let's see, let's go ahead, and
I'm just going to grab the edges. Actually you know what? I did some little mistake here. So there's two options when you're-- a couple of options when
you're making your primitives-- or your shapes. One is to have the groups being
created in different ways. So you can see here,
when I go to PolyEd, I have one poly group that's
the entire outside edge versus the entire inside edge-- or the top and the bottom. And that's not really what I want. What I want is I want a poly
group for each one of these sides. So inside any one of the shapes,
there's this Polygroup Mode, and I'll say, instead of Per
Face, I'm going to say Per Quad. So let's just drop that one in here. And now, when I go to PolyEd,
you'll see the difference. So now, I have a poly group for
each one of these sections here. So in this particular
case, that's going to be super useful because what I
want to do is I'm going to go ahead and say,
select all the edges of this guy, and then I'm going to do a
bevel on all these edges. And then we'll say Apply
that, and now, I have little poly groups
for all the new bevels. I'm going to grab it again,
and let's just do another bevel. Make it a little bit smaller. So we have a-- we're sort of faking a
little bit of a round here. So now, I have my shape here. [INAUDIBLE] as well. Probably need to have--
just going to fake in a little bit of
the bolts on there. Instead of eight,
let's just do 12 sections. And forgot to drop it. There we go. Put these two together. So [INAUDIBLE]. And of course, a lot of work
just for these little details, but [INAUDIBLE]. TINA WISDOM: They're important. RUSSELL PAUL: They are important
they give all that little texture. So I'm just going to do a
quick MshBool (Mesh Boolean) and say Union these guys together. And of course, it gave me a
duplicate material, so now, we have two of the
same material on here, which is an excellent opportunity
to show that you can't actually go ahead and go to-- there's an option here
for MatEd (Material Edit). So what we want to do
is I'm going to grab-- basically,
I'm going to say Select All, and I'm going to say I want
everything to be this material. And say Assign Active Material, and
then for the second material insert, I'm going to delete that guy. So now, I'm going to say Accept,
and so now, we've gone ahead and we've deleted this material
on here, which is obviously going to be helpful for
being a little bit more efficient with our assets. And there's all sorts of other
things that you can do with that. Let's go down here. All right. -90. Put our little bolts around here. All right. Probably go ahead and combine
all these guys together. Bit more efficient. I'll just hide the
inputs just in case. There we go. So we have these guys
that are all set there. So I'm not going to go through
and build little panels for every single one of these
guys, but I think you guys get the
idea of some of the things that you can do in here. But now, we have a nice little ramp. If we hit Play, we can
drive, and we can-- maybe I'll try not to jump. Oh, gee! Oh, gee. TINA WISDOM: Still hit the ball. I'm just saying. [LAUGHS] RUSSELL PAUL: I still hit the ball. [INAUDIBLE] because that's
kind of [INAUDIBLE].. I've actually been
having a lot of fun with this whole concept in the sense
that, as I'm going through this, and I was making this
ramp, I was starting to think of all the other
things I tried using. There's some other deformers in
here that are actually really, really cool. For instance, if you wanted
to, let's go ahead, and I actually-- there's
deformers for doing wraps and twists and things like that. I actually tried to see if I could
get the car to spin around and do a 360 with some of the warping. There's so many things in here
that just, all of a sudden, when you start going through
some of these tools, you just go, oh my God, I can do that. I can do that. And then there's other
things in here that are just really helpful from a
production standpoint, doing stuff. So for instance, right now,
this whole beam section, all these beams right here,
they're all different beams, and they're all sourcing this
sort of high-res 2K mesh. And obviously, sometimes that's
actually not super efficient. So if we wanted to, what we could
do, is I'm going to just go. One of the last
things here before we turn it over to Ryan
is, let's go ahead and do what we did before. I'm going to merge all those
together, and let's hide the input. And so now, we have just a single
mesh, and in the UV Editor, what we want to do is just to make
things a little bit more efficient. I'm going to go ahead,
and I'm going to go to Channels, and I'm going to say
Add a new channel. So now, we have two UV channels,
so you can preview just channel 0 or channel 1. And let's go back to
Channels, and what I'm going to say, instead of Add,
let's say Copy my UVs from target is going to be channel 1. Source is UV0, so I'll say Apply. So now, I have two of the
same exact UV channels, but now that we're
working on the second one, let's just lay these out,
and let's Repack this channel. So now, what you have is UV
0 is taking the original UVs from the Quixel sort of
material assignment texture, and now, I have UV 1
so that I can use that. So some things that you can do. Let's save. Save that. Hopefully, I actually did it. In addition to the UV tools,
there's a whole bunch of also some really cool baking tools,
so I'm going to say BakeTx (Bake), and there's a bunch of
different baking options that we can do in here. For instance, you can say,
for instance, Tangent Normal. If you have two objects,
you can do Object Normal. Ambient Occlusion if you wanted
to bake ambient occlusion. Curvature is also a really cool one. But we're going to go here quickly. I'm going to say Texture,
and right now, it's going, what the heck is going on? That's what the red thing is for. So we're going to say
the Target Mesh is going to be UV 1 that we want to
have, and then I'm going to not worry
about my source map. But my Source Texture,
I'm going to say, is right here, and let's give it that same
texture [INAUDIBLE] here. And then you can see, it's kind of
gone soft a little bit in this area, so let's just turn up
our texture resolution. I'm not going to do super high. Let's just do 1,024 just so
we can see what's going on. But what's really cool is I've
taken all of those other maps, and we're basically going to
go ahead and just bake that in. So now, in my-- it stores it right here. Essentially, what we have is
it's called this one right here. It's taken,
and it's baked those 2K maps that was the same on every single one,
and I've baked it into one new map that I can then use. And I could go through,
if I wanted to, all the different
effects and normals, but now I have one map that I can
use that goes over everything. And every single piece has
individual texture space as opposed to overlapping texture
space from the original. You could also do things
where, instead of doing that, you could use the baking
tools to bake, for instance-- instead of doing that,
let's turn off Texture. You could, say,
do a Curvature map so that if you wanted to do some little
edge work on here, or other things,
or ambient occlusion, you can do all sorts
of fun stuff like that. And you can do all that
directly in the Editors you're playing around to do stuff. So there's a ton of tons and
tons of different tools in here, and we haven't even really
gotten into data prep or importing data, data
cleanup, things like that. But to me, this is some of
the tools to get you started, get playing around,
get making stuff in here. And then the final thing that I did
want to mention that's in here-- let's see if I can find it. Where did I put it? Oh, I made it called
sandBox over here. Let's get rid of that. So once again,
I just [INAUDIBLE] same sort of beams that we had earlier. I just stacked them up
to make a little area. Made a little space in here. There are some fun
sculpting tools in here if you wanted to go
ahead and have a mesh, and you could actually just
say, go ahead, and I have an alpha channel in here. Let's just no alpha channel. Move things around. But you can kind of sculpt to
your heart's content over here. So now, if we Accept,
let's say Play, let's see what happens if we drive over there. Whoops. OK, wait. TINA WISDOM: Saved it. RUSSELL PAUL: I saved it. Uh-oh. I picked the wrong car. [LAUGHTER] So anyway-- TINA WISDOM: What this really
was, was showing your skills as a stunt driver. RUSSELL PAUL: A stunt driver, yeah. It's getting slow, I think,
because the collision is a complex collision. So I mean,
the other thing that you could do, and Ryan can guide me
through these things here, because I'm not good at
setting up my collision, is you can actually
go ahead and actually do a Msh2Col (Mesh to Collision) object here, and let's do-- RYAN SCHMIDT: Set it to-- RUSSELL PAUL: Convex Hulls? RYAN SCHMIDT: Sure,
set it to Convex Hulls,
and set it to Per Input Object. The next one,
Input Mode there, set that to Per Mesh Component. See what that does. RUSSELL PAUL: There we go. See that, and then make sure
you turn on Append to Existing. Correct? RYAN SCHMIDT: No, in this,
you probably want to replace them, in this case. You might even be able
to use boxes for this. But anyway, leave it as Convex
Hulls and see what happens. RUSSELL PAUL: Let's
see what happens. I was trying to understand
collisions earlier-- last night, and I was like,
I need Ryan to explain. RYAN SCHMIDT: You should have
watched my video, Russell. RUSSELL PAUL: But you could
see that it didn't slow down when I hit it, which is awesome
because it gives you the opportunity to actually see what happens when
you're making these collisions and make adjustments. The other thing that I
didn't really jump into is that a lot of
these modeling tools actually work with
volumes, and even a lot of these shapes. So if you needed to, you can
actually create a shape or a volume directly. So if you want to
make a BlockingVolume, and I'm just going to
do it the same way, and you can have the list
of volume types here. And if I were to drop that in-- Let's just turn off Game
View so that you can see it. Ah, landscape. Where's my landscape? If you wanted to, you can actually
use the same Poly Edit tools on this guy to actually
work directly on this, and you could actually
add stuff to it. I like the Push Pull tool. It's similar to CubeGrid. It's not as great as
the CubeGrid tool. There's been some other great
presentations on CubeGrid so I'm not really covering it today. But Push Pull also does some of the
same stuff, where if you were to do-- see, now I'm getting off topic here. But you can do all sorts of cool
stuff with this guy, so PolyEd, grab this guy. Let's insert some edge loops. I don't know what I'm
making, but anyway, if I grab this face and this face,
this is what I like about Push Pull. Go like that,
and I can make [INAUDIBLE].. So much fun. Anyway, those are some of the
fun things that I have here. Like I said, there's so
much more to this toolset that we just don't have
time to cover today. There's really great deformers. There's the ability to add
displacement and bake it into the mesh if you wanted to. There's controls, obviously,
for baking, scale, and rotation, adjusting your pivot points. There's also simplification and
remeshing tools or welding tools for cleaning up meshes. There's so much in here,
but I think what I was hoping today is just to give you
guys a little taste of how much fun you can have
just being creative directly in here, modeling, editing,
mixing together Quixel assets or stuff that you've brought in,
editing them, adding to them, and really crafting experiences
directly in the Editor without having to jump
around to any place else. You can just do a ton
of stuff and actually take and build out some really
interesting geometry and some really final shapes and things
directly in Unreal now. So with that,
I think I'll turn it over to Ryan. TINA WISDOM: Yeah,
that sounds incredible. I do have to mention,
I don't know if either of you saw, but chat absolutely lost its
mind when you used the Cut tool. We were all just,
all in sync, of oh, my god, what did we just watch happen. RYAN SCHMIDT: Yeah,
some of the devs on the team have put in,
in different places, ability to do some of these operations
together from different tools, like the thing Russell
just showed where he just pulled the face through the thing. We didn't have that for a long
time, and I actually have a video on my YouTube
channel about workarounds for not having that
and ways to do it. And then we just added that,
and it's just so awesome. Just be like, boop, and you make
a hole on a window or a door. Yeah, it's good. RUSSELL PAUL: Yeah. TINA WISDOM: Yeah. RUSSELL PAUL: Ryan,
do you want to jump in? We can answer questions later. Do you want to-- RYAN SCHMIDT: Yeah, sure. So we could just switch
to my screen I guess. So I've made some slides. You invite someone who used
to be an academic person into your livestream,
you're going to get some slides. This is just going to be to help
me explain some things, and then-- but I'm mostly going to do demos. So don't worry. But what we're going to talk
about is geometry scripting. So all that stuff Russell just
showed you is all our Modeling Mode. It's kind of like interactive
tools, pointy clicky type tools, and there's been people
asking in the chat. I've been watching it,
and immediately when we started working on this, people
started asking, can we script this? Can we use Blueprints with those
tools and things like that? So we haven't gone
that route currently, but what we did is basically,
all those tools are built on a set on a geometry library,
a C++ geometry processing library. We call it, that's like the
mesh, and the operation's like a Boolean and stuff like that. And so what we've
done is we've exposed those operations and those mesh
objects and stuff like that to Blueprints,
and so that's geometry scripting. And so basically, I'm going to,
for the next half hour or so, talk about geometry scripting
and show some demos. So this is completely new in 5.0. If you looked into
modeling in UE before, the modeling tools have actually
been around for a couple of years now, but not anywhere close
to what we have now in 5.0. But geometry scripting is a totally
new thing, and we've used it. If you watch the UE5 release
event, there was a demo of doing some
stuff in the Lyra project, and that was all done with
this geometry scripting. The person doing
the demo made a wall with a window in
it and some stairs, and stuff like that. And so I will show a little
bit of that at the end, but let's-- high level,
what's geometry scripting? So what it is,
it's just a library of UFunctions for doing stuff with meshes,
so you can generate meshes. You can modify them. You can query them. The functions are
Blueprint functions. They also work in Python. I'll just mention a bit
about that at the end. Most of the stuff I'm going to show
works both in Editor and at runtime. I'll try and call out
stuff that's Editor only. That mostly has to do with
things like creating assets, and a little bit, we have some SubD. Russell didn't show any SubD,
but we do have some SubD operations, and those are
currently Editor only because of a dependency on a
third party library that doesn't work on all platforms. And basically, this builds on other
new UE5 features like DynamicMesh and DynamicMeshComponent,
DynamicMeshActors, and I'll talk a
little bit about that when we get into
more the sort of-- I'm going to talk a bit about
the technical underpinnings of this geometry scripting. So this is experimental
stuff in UE 5.0, so Modeling Mode was
experimental for a few years, and now,
we're considering it to be beta. Modeling tools, Russell didn't
really mention this aspect, but when you edit a static
mesh, you're not really introducing any
dependency on the modeling tools. So when you clicked
Accept on that tool, and the static mesh is updated,
you could go turn off Modeling Mode, and that static mesh is still there. It's all fine. So geometry scripting is a
plugin that, when you use it, you're going to become-- if you have a Geometry
Script Blueprint, it's going to be dependent on
the Geometry Script plugin. So because it's experimental,
it's not enabled by default, so Russell showed you how
to turn this plugin on. It's the Geometry Script
plugin, but you have to go turn that on in a
project where you want to use this. And I'll just mention-- so I'm
going to do some tutorials, but similar to how
modeling takes some time, wiring up Blueprints take some time. And to be honest,
I'm not an expert at it. I mostly do C++ programming. And so I do make videos
that I've been posting on YouTube of short demos of things,
so I'll just show that channel if you want to look it up. That's my Ryan Schmidt
Epic-- is my account there, and you can find a playlist
of geometry script videos. Oh, I guess that's showing
all the views and stuff. Well, anyway, whatever. I don't know if there's any
secret accounting stuff in there. I guess you can pause
it later and find out. But I wanted to show-- that's right. So I've posted some-- here we go. So I've posted modeling
videos in this-- that's other people's
modeling videos. There's a lot of those on YouTube. These are my modeling videos. I'm getting there. And so I've made-- this was
all mostly done in 4.26. I made a few modeling
videos, and then we made one for the early access
about basically taking 3D scans and turning them into usable
assets, all using Modeling Mode, the stuff Russell showed. So for instance,
I mentioned a video there when he was trying to
set up the collision. So this UE 4.26, Creating Simple
Collision using Modeling Mode is a video all about
the tool that Russell used for setting up
simple collision, and this is the one I mentioned about
making windows and doors. So this video is basically obsolete
now because of that Push Pull thing that Russell showed
that took one second. You don't have to watch this
half hour video anymore, so problem solved. And then those videos are
also the Geometry Script stuff we're also posting on our new
Epic Development Community. So my account there, I'm rmsEG,
and if you find me or search for "geometry script,"
you'll find the same videos that I was posting on YouTube
here, and you can even get things like the sample code. So this is the Python one. I believe I posted
the Python script here for this video, which does Booleans
between two million triangle meshes. So Russell did mention,
but our Boolean tools are actually extremely capable. This is a demo of Booleaning
one two-million triangle mesh from another. It takes about a minute to do
that, but these are-- and it's very reliable and robust
and scales up really, really well. Anyway, so let's go
back to Geometry Script. So there's two main uses,
and one is to make your own tools. So the way you can
do that in the Editor is two ways-- with Editor
Utility Widgets, and actions. So I'm going to do a demo right now
of making an Editor Utility action to flip the normals of something. So it's good that Russell's
here because Russell was always asking us, he wanted to be able
to just select something and flip its normals. And we could do that
with our Normals tool, but it was four clicks, and he wanted it in one click. And we were always hesitant
to add another button, and I've seen people in the chat
saying there's so many buttons. And so we didn't want to add
just a button just for that. And so in some ways
Geometry Script exists because of that,
because we wanted it to be easy for someone to do something
like make one click thing where they could flip
the normals of something. So I'm going to go Editor Utilities
and create an Editor Utility Blueprint, and it's going to
be an Asset Action Utility. So I'm going to do that. I'm going to call it 'FlipNormals',
and I'm going to edit that. So there's two things
we have to do in here. So first, we want to expand this. No, I click "+". That's OK. We're going to add a
Flip Normals function. That's the one we're
going to implement, but I want to override
Get Supported Class. This is important because we only
want this to work on static meshes. So I'm going to set the return type
to be Static Mesh, so it's just in the dropdown there. So I'm going to go back to
my Flip Normals function, and basically,
what's going to happen-- I can even just save
this and do it now-- is once we've done
that, then when we right click on an asset
in the Editor here, and we go to this Scripted Asset Actions, you'll see there's
a Flip Normals function. And if we change this to
be named 'FlipNormals2', it's going to update automatically. Now, it's Flip Normals 2. So basically,
this function in your Blueprint becomes an action in the UI. And then there's a function,
Get Selected Assets, so I'm going to right click and type
a little bit, things to do searches. So that's going to give
me the list of assets, and then I'm going to do a For
Each loop over those assets. And each one, I'm going to
Cast to StaticMesh because-- Wait a minute,
I need to wire up that Exec pin. So this is the loop body. So basically,
each asset that's selected-- this will work with multiple selections. I'm actually only going to use
one, but it's basically going to give me the static
mesh asset in this Blueprint. And now I'm going to do
something else, which is Construct Object from
Class, and I'm going to set this
to be a DynamicMesh. I'm going to create-- this is basically going
to be a temporary object that we're going to use. We're going to copy the
static mesh to a dynamic mesh, which is the new thing that
lets us do all this mesh editing. So then once I've got
a dynamic mesh, I'm going to Copy Mesh from Static Mesh. I'm going to wire my
static mesh asset in there, and so now what this
node has done is it's copied that static mesh into the
dynamic mesh, assuming it succeeds. And then if it does, I'm going to
run a function called Flip Normals. That's just one of our many
Geometry Script functions, and if I just right
click here and go to Geometry Script,
similar to how the modeling tools have
way too many things for us to show in this livestream, there's
way too many functions for me to go through. There's over 160 functions, all
sorts of things like deformations, like Bend Warp,
or Displace from Texture Map. I will show that one. It's really cool. Smoothing, all sorts of things. Booleans are in here. There's Booleans,
like Booleans and Plane Cuts. A lot of the stuff Russell showed
is accessible via Geometry Script. Really so many things. So I'm going to copy that
mesh from the static mesh, so now, I've got it. I'm going to-- oh,
yeah, that's right. I was doing this-- Flip Normals on success. And then so now, I've flipped
the normals of that mesh, so now I'm done. But I need to put it back
into the static mesh asset because I copied it out into
this dynamic mesh that I created. So I'm going to do
basically the same thing-- Copy Mesh to Static Mesh. Let's wire that up. The target mesh is the one
that we've now flipped, and I need to get that static mesh. So I'm going to zoom way out. You won't be able
to read it probably. Just wire that over there. Not great edge
layout, but that's it. And so if I compile this,
I'm going to save it. So there, I put an instance
of the table in there. I'm going to right click down
here, Scripted Asset Actions, Flip Normals, and there we go. The normals flipped. So it flipped the normals. It has to rebuild the asset. I mean, it looks weird now
because the normals are broken, but if you had imported it,
and the normals were broken, then now, it would be fixed. So that's a simple example
of this really simple Editor operation you can build yourself. You might have noticed,
if I right click here-- sorry, on the asset. I have this one that's
called Flip Y Up. So one of the videos in that
YouTube channel I mentioned does the same thing, and it
sets up an action for flipping-- if you import something that's Y
up, and you need to flip it to Z up for
Unreal, it's just a little action that does that. You can also make actions
where you can right click in the level--
the viewport here. It's a little bit more
complicated because we want to flip the asset, not the Actor. So you have to figure out which
asset you have from that Actor, but that's called an
Actor Utility Action. But basically, same kind of thing. So let's go back to my
slide, so I remember what I was going to do next. So that's a really simple example
of the kind of thing you can do. So if I wanted to Boolean
things, you could do all that kind of stuff via
these right click actions. Another thing you could do is
you can set up more complex-- so those are just actions where,
basically, it's just a command. This one, I'm not going to show
you building the whole thing because there's too many nodes,
but I will just run you briefly through the Blueprint. So this is an Editor Utility
Widget, so basically, when I run it, I'm going to right click on it
and Run Editor Utility Widget. I didn't do a lot
of great UI layout. But essentially,
what it's going to do is it's going to let
me make a blocking volume for whatever's selected. So I'm going to select these
three things and click Wrap, and you see it and made a convex
hull blocking volume automatically for those objects. So I can turn up the
number of vertices. Maybe give it some buffer. And now, I think if I PIE here. I don't have a
Character set up here, but I-- oh, no,
I can fly through. Sorry, this was the wrong-- uh-oh, I'm stuck. [INAUDIBLE] There we go. If I had a Character in this scene,
the Character wouldn't be able to-- I guess I could put a sphere and
have it simulate or whatever. But anyway, you get the idea. So that gray outline
there, hopefully you can see it on the stream, is a blocking volume
that was auto-generated. And I can just delete it and change
the settings and make another one. I could make it smaller, I guess. Oh, that was too far. That was too far inside. So this Editor Utility Widget--
if you want to make one of those, you just go Editor Utilities
> Editor Utility Widget, and what it gives
you is it gives you this more advanced
thing where you get a little UI builder,
and you can drag in buttons and put labels on them
and show settings. I'm not going to go through
how you set all this up. It's not that
complicated, and I think we've definitely
got materials on our website about Editor
Utility Widgets and how to use this kind of stuff. It's super useful and
powerful to be able to make your own little tools like this. So the graph here is
a little complicated. Basically,
I use this Sequence node, which are super useful to do these
things, then do these things, then do these things. So the first thing it does is it
gets all those selected Actors, and it loops over them. And for each one of
them, it gets its mesh and copies
the mesh out of it. So this is similar to that
Copy Mesh from Static Mesh. This is Copy Mesh from
Component, and it can take in lots of
different types of Components and automatically get
its mesh and get it in world space, which is how
we did this because we're going to do everything in world space. And what this branch here
does is it accumulates them all into a combined mesh,
so that's this Append Mesh function. So basically,
it took all those tables, and it made one mesh for them. And then it figured out
what the pivot point should be of this output convex
hull blocking volume, which is this Get Pivot for Bounds function. And then it computed
a mesh convex hull. So what this does is
it takes in one mesh, and it gives you the convex
hull in an output mesh. And then I just transformed
it so that the pivot is in the right place, and then
there was that offset parameter, and this Apply Mesh Offset
is a Geometry Script function that offset things in and out. So it does that, and then it
just uses a function called Create New Volume from Mesh. So this is also a
Geometry Script function. So you give it this hull mesh
that we've computed and offset, and it makes a new
volume from that mesh. So this is all-- I mean, there's sort of a lot here,
but there's actually really not all that much here. And a lot of it's kind of
boilerplate to just get the meshes and stuff like that. But from that,
we added this functionality that, actually,
the Editor doesn't have. There's nothing in the Editor where
you can just select some objects and make a convex hull. So we basically built a
feature ourselves just using some Geometry
Script and Editor Utility Widgets
to provide the UI. Our internal teams are now
doing this kind of thing a lot, so building out these kind of
UIs, they can become as complex
as the Editor UI that you see on the screen to build
these kind of tools in the Editor. So that's building Editor stuff, so
sort of Editor tools and operations. So the other thing that is
really cool with Geometry Script is that you can also make
procedural mesh objects. So you might even
have looked at what I just did there and
think, well, could I make a thing that does
that mesh offset operation instead of a tool or operation? And so the short answer is
yes, so I'll start with a super simple thing. Let's get rid of these tables,
and go to this directory here. I'm going to make a Blueprint Class. I'm going to make a
GeneratedDynamicMeshActor. So this is a special type of Actor. It's Editor only. I'll explain a little
bit more about that. There it is-- Select. So I'm going to make one of these,
and I'm going to call it 'BoxBP'. Going to right click and edit. So close these other ones. I'm just going to go right
over to the Event Graph. So I'm not going to use
the Construction Script. I'll explain a bit more about that. But an obvious thing might be to
do this in the Construction Script, and you can. But we actually
have-- that's why it's a special thing we have
support specifically for making these procedural mesh things. So I'm going to type "on rebuild,"
but basically what I did here, and this is the first thing you have
to do every time, is right click and go "on rebuild." And then you'll get this Event
On Rebuild Generated Mesh. So basically,
this is where you generate the mesh for this box actor. So I've got this target mesh. I'm going to right click
here and say 'append box'. I'm just going to
leave all the settings. Going to compile that, and now, when
I drag one of those into the level, it's a box. And I mean,
that's not that exciting. It's just a box. I could switch this to be
a sphere box, what we call one of our two types of spheres. And I compile that. Now, it became a sphere. So essentially, the mesh is
being generated on the fly by this Blueprint. So this Target Mesh, if you
remember in the Flip Normals one, I did this Construct
Object from Class, and I made a DynamicMesh object,
so that's what this Target Mesh is. This is the target
mesh for this Actor, this generated DynamicMeshActor,
so anything I do to it is going to appear over here. So I switch that back to the box. I'm going to change its
dimensions to 200. Compile. OK, so now I've got a wider
box, so you can see I can
set those settings. So I could go over here
and add a variable. We'll call that 'Width'
and make that a Float. Make it public. We have to compile once, then we
can go set the width over here. And we'll start it at-- sorry, I'm misclicking. Compile that. Oh, I didn't wire it in. So I got to get the Width,
hook it up here to this Dimension X, and now, we've got a width setting. So now, I can change that setting,
and so now, I have a parametric box. It's not scaling, and if you see
the scale here, it doesn't change. It's all 1, 1, 1. I'm just changing the box generator,
and you can see the mesh here. And you can do other stuff in
here, like I could add some subdivisions, 2, 3, 4. And now,
the mesh has some subdivisions, and so basically, by using these
Blueprint variables and wiring them-- building out these graphs
and wiring stuff into them, you can build a
parametric generator. So I'll just take this target
mesh, and I'll do-- oh no, I don't want to [INAUDIBLE]. I'll do Russell's
favorite operation. You have Russell to thank for
Bevel in UE 5.0 because he-- we weren't going to do it, and he
badgered us literally for a year. I mean, we were going
to do it eventually, but we didn't really have time. But Russell really made it happen. RUSSELL PAUL: It was a daily,
daily, daily badgering. RYAN SCHMIDT: [INAUDIBLE] and so I'm
going to right click on this Options pin and Split Struct Pin,
and I'm going to make-- I'll just duplicate this. It's the fastest way. 'BevelSize'. And set this to, I don't know, 2. Put that in there. This drag and drop
of parameters doesn't work on the Split Struct pins. So now, I can go over here and
change the bevel on the fly, so now, we basically made
this parametric box object. And you could do this with
any kind of shape generator. So we have a whole bunch of
them, so I did that Append Box. I didn't show these before,
but I'll go back to Geometry Script if I can find it. It's alphabetic. G. So there's Geometry Script. We've got-- did we
call them primitives? We call them primitives, so you
can see boxes, capsule, cone, curved stairs,
we have linear stairs. So the stairs generator
in the Lyra demo that was done in the launch event is
just this linear stairs primitive, and they did a bevel afterwards. And that's how they change
the bevel in the video. So there's all sorts of--
there's revolves and extrudes and all sorts of things in there. So that's the sort of
simple box shape generator. So I did this procedural box
demo, so I'm just going to show you a few pictures
now in these slides to just explain some stuff from the nodes. I guess I can do it on the nodes. So one thing is you'll notice that
these functions, when we make them, and they're empty,
they have this Target Mesh, and they have this asset picker. I just want to mention,
ignore that asset picker. You have to wire something in. There aren't assets
you can put there. This is just a thing we-- like I said, it's experimental,
so there's still a few rough edges. So we need to hide that,
but it's not hidden, and it has tripped some people up. The Target Mesh is on the
input and output sides, so that doesn't mean it's
outputting a new mesh. It's outputting the same mesh. We did this. I showed a picture on
the next slide, and I guess you even saw me doing it. It lets you chain together
these operations really nicely, but it's the same thing going in
and out of each of these nodes unless it's got a different name. So instead of having to wire
one thing into a bunch of nodes, you can wire from one node to the
next, but it's not a different mesh. If it's got the same name on
either side, it's the same mesh. The options-- in most of our
nodes, there tends to be almost
always an Options input, and that Options is like a
custom input for that node. So in this case,
this is a mesh plane cut. And it's got a long name-- GeometryScriptMeshPlaneCutOptions,
and that has settings for the node. And sometimes we put,
if there's something that you're basically
always going to have to use, we'll put it as a separate input. But generally,
there's an Options, and you can right click
on it like I did and do Split Struct Pin. You can right click on the Options
or on the input transforms and stuff like that to expand
them out if you want to do more specific
stuff inline in the node. But this helps us. Having these separate
options structs helps us keep things tidy when you don't
need to change these settings and helps us going forward as we
add more capability to these nodes and things like that to make sure
that we can keep things backwards compatible while still being able
to update them as we go forward. And then just one last thing about
the nodes, that they almost all have this Debug pin. This is a thing that we didn't-- I mean, to be honest, we didn't
get it done in time for 5.0. So what we intend to
do with this is to make it possible to wire
in the debug object that you'll be able to use for
a sort of geometric debugging, to help you figure
out what's going on, what's the mesh at a
current state in the graph, without having to go and
break up all the wiring. But that's not actually available
yet, so this should be hidden. But we, again,
didn't get it hidden in time. So I'll show you another example of
a Displace from Texture operation. So this is going to combine
a few different things. I'm going to get rid of that. I'm going to make a new generated
mesh, GeneratedDynamicMeshActor. And we'll call it 'DisplaceBP'. We'll go to Edit..., and we'll
jump over to the Event Graph. And we'll right click,
and we'll go to 'rebuild'-- Event on Rebuild Generated Mesh. So I'm going to add a variable. I'm going to call it 'SourceMesh'. I'm going to make it
a Static Mesh type. [INAUDIBLE] that. So basically,
what I showed you before was a parametric shape generator,
where I started from scratch. But here, what I want to do is
I want to start with a thing. So I'm going to get that
Source Mesh, and I'm going to do a Copy
Mesh from Static Mesh. But now, what it's going to do is
it's going to read this Source Mesh. And actually, before I do that,
I want to right click on this and change it to a Validated Get. So Validated Get means it'll
error check and have an input pin, and it's good to do that to
avoid bad things from happening. So I'm going to copy
out that static mesh, and so actually, that,
by itself, is a valid thing. So if I drag one of these into
the level, there's nothing in it. But I'm going to go to
Modeling Mode quickly, and I'm just going to
make an empty torus-- oops, I need to-- oh, well-- that I'm going to
use for this example. So I've got that DisplaceBP,
and I've got my Source Mesh. That's the parameter I made. And I'm just going to
stick this torus in there. And so now, every time I move
this, it's actually recomputing. It's rereading that static
mesh and generating this, basically updating the generator. And that update is
reading the static mesh. And so now, what I'm going to do is
I'm going to do a PNTessellation. Let's say we do two levels. Let's make 'Levels' a parameter. It's going to be an Integer. It's going to be public. We'll compile. We'll say that Levels is-- it can start out at 0. We'll wire that in there. So now what we have is-- so we've got our default
torus, but we can subdivide it. Uh-oh. Set a limit on there because
if I drag that up to 100, it's going to be bad. Let's set it to 4. RUSSELL PAUL: You can't go above 10. RYAN SCHMIDT: Mistakes
could be made. So now, I can-- you can see now I have a subdivided
torus, option for subdividing, and then I'm going to Apply
Displace from Texture Map. So I'm also going to add a 'Texture' input. Make this a Texture 2D. Some of these things have so many-- Texture 2D. There we go. Public. Again, Get Texture,
Convert to Validated Get just to make sure I have one. If it's valid, I'll wire it in here. And let's split the options,
and you see there's a magnitude. And we'll just add a-- mirror that. Make that a Float. We'll set the default to 1
there, too, and wire that in. So now, nothing's going to change
because I don't have a texture set, but if I find one-- where's my Displace? So I've built this Blueprint before,
so I have some textures here. It's not doing anything yet. But you see now, it's displacing it. It starts to get more
expensive, of course. This is the thing with
procedural generators. So it's displacing it,
but you see the normals are wrong. That's because the displace node-- the Displace tool. So in Modeling Mode
here, we have a tool. Russell didn't show this one. We have a Displace tool that
does basically exactly this, but it does a lot of
stuff automatically. But in Geometry
Script, because we want it to be as efficient as
possible, we're not going to automatically compute
the normals because maybe you're going to do two displacements. So we have a function,
Recompute Normals. Now, the normals are
getting recomputed as we change those settings. So I could go a lot higher
here, but you see now,
it's gotten kind of chunky. Also for this example, I have
a video on the YouTube channel that shows how to add basically a
checkbox over here, where you can, if you're happy, turn off the
recomputing every time you move it, and it'll stay in that current
state, and it won't change. When you change the settings,
it won't do anything if that checkbox is disabled. But essentially, it lets you
freeze it in a current state, and then there's no overhead when
you're moving it around or doing things with it, and that's the
kind of thing we're probably going to build in in
the future by default. But you can build it right
now in the Blueprint. So that's a simple
displacement Blueprint. Now, this is a different-- I mentioned just then
that this object, because it's being updated as you
move it around, that's not great. And also it's not a static mesh. And so why do you care that
it's not a static mesh? Well, a lot of UE rendering features
only work on static meshes-- for instance, Nanite and Lumen. Now, this displacement
capability is a really great way to make Nanite stuff. If you have high-res
displacement maps, then you can just
basically drop them on objects and to
make really high poly shapes that you maybe
want to use Nanite on. I could just put this bunny
in here instead of the torus. Now-- oh, it doesn't have
UVs, so it doesn't work. How about the table? Let's see what happens. Yeah, there we go. I mean, that looks
terrible, but it did work. It displaced the table. Let's put the torus back. TINA WISDOM: Modern art. RYAN SCHMIDT: It's art. Should have planned ahead. I could put this cliff in there, but
it's half a mil-- 500,000 triangles. And so I'm not going
to do that right now. So something you might
want to be able to do is convert this dynamic mesh
actor, because that's what this is, to a static mesh, so
there's a couple of options there. One is we have tools
in Modeling Mode, so there's a few tools in here. There's this Convert tool
that, for instance, will let me create a static-- basically, convert this
in place to a static mesh. And there's also,
Russell showed the Mesh Merge tool. Where's that one? RUSSELL PAUL: There's Duplicate. RYAN SCHMIDT: Yeah,
that's what I'm looking for. Oh, yeah, MshDup (Mesh Dupe). So I'm going to duplicate because
I want to keep the inputs. So let's duplicate that. So now,
this is a static mesh version of it. And now, they're not linked
or anything like that. So if I go back here, and I
change this to 10, what I could do is I could also use
the Transfer tool. So if I select this one,
and then the static mesh and do Transfer and Accept
it, now it's going to basically update the
static mesh with this source mesh, and this is actually--
what I just did there is the central part
of the whole Lyra system. So that's one option. The other option is we can actually
build it into this Blueprint, the ability to bake
out to a static mesh. So what I'm going to do here is I'm
going to duplicate this SourceMesh. I'm going to call it 'TargetMesh'. I'm going to add a function
called Bake to Static Mesh. And essentially,
if something is set here-- let's do Convert to Validated Get. And then I'm going to right
click and go Get Dynamic Mesh. This is the other way. So in this Event Graph,
it gave me this target mesh, but there's also a function
on the Dynamic Mesh Component,
which is called Get Dynamic Mesh, and that gets you the same mesh. So this function,
basically, when we call it, it's going to get the current
mesh, and it's going to go Copy
Mesh to Static Mesh. And I'm going to put the
validated To Static Mesh in there. This function-- I'm going to
set it to be Call in Editor, and that's going to do
a magic thing where, now, if I find it in
here, now, we've got a button called Bake to Static Mesh. So it took the name of the button
from what I named this function. So now,
I don't have a target mesh set, so it's not going to do anything. But remember before,
I accidentally made two toruses, so I'll just use that torus. I'm going to set that
as the target mesh. I'm going to put one in the
scene, just so you could see that it exists. I'm going to go back down there. I'm going to click
Bake to Static Mesh, and now, it baked it to that torus. So basically,
I built a little utility here now where I can use this to
update an existing static mesh asset. There's also a capability
to make a new static mesh asset from Geometry Script,
which I will actually show in the Lyra
demo of this because this is, again,
part of essentially what we used in Lyra. Essentially, now,
what I've made is a little tool where I can make high
poly displaced things. It doesn't have to be a torus. We can put any mesh in
there, any displacement map, set our levels and magnitude, and
then bake it out to a static mesh. So it's sort of a
procedural generator. You can think of it as just a
variant of our Displace tool, but it's also a procedural
generator for shapes and a kind of general purpose tool. But it is also an Actor,
so you could give it other functionality and
all sorts of cool stuff. So Displace from Texture-- oh, I've got a cool video. So this is from someone
at Epic that we found on-- actually, I saw it on Twitter. When I started
putting out Geometry Script videos,
this appeared on Twitter, and I posted it on
our internal channels. And it turned out it was another
Epic person who'd made it. So here, in this
video, what's happening is it's using what
I just showed you. There's a plane. The plane gets tesselated
highly and displaced, and then one more thing
happens, which is that they do a plane cut a little
bit above where the plane initially was. So anything that didn't
get displaced gets cut off. And then these are just
some high-res textures, and now, essentially, this is a
tool for turning those high-res textures into heightfield
meshes, high-res mesh pieces, which is pretty awesome. That's, again, a thing that will
take multiple steps in the Editor, and actually, they're even mirrored. Maybe you can see in this. I don't if you'll see it
on the stream resolution, but there's a line here. It looks like they've mirrored the
parts, which I only just noticed. So again, a more advanced version
of procedural shape generator built with Geometry Script. This is the Bake to Static
Mesh demo I just showed. I have a video for that if
you want to go watch that one. I'll just show you a few
other things that people have done in the last couple
of weeks with Geometry Script since it came out in the
first preview of UE5. So this are some examples
from Kristof Lovas, who's a UE third party developer. So he made a sort of jewel or
stones or crystals generator by just doing random plane cuts
and smoothing it out a bit. You can also use,
if you add a spline mesh component, you can sample from the spline mesh. And so he used that to make,
essentially, a revolve generator that is based off a
curve, which again, is a thing we kind of actually
have in Modeling Mode as a tool. We have a Revolve tool,
but we don't have spline curves. So this is assembling something
to extend the Editor, which I just think is super awesome. And then a couple of days
later, someone else figured out how to do that to make
even more advanced stuff, so here's a procedural
wall generator where the base is a spline mesh component,
and then in the generator, the spline mesh
is being sampled. And then the points
from the spline mesh are being used then
to do the generation of castle wall-- sort of shape generator. So super cool stuff
that I'd actually, I'll be totally honest with
you, I didn't know this would be
possible when we made this. I didn't know you'd be able to
stick a spline component on there and do this. I probably should have known
that as the Geometry Fellow, but I had never had to
assemble things that way. So very, very exciting to see
all the stuff people are doing. How are we doing for time? Half hour. I'll quickly show Booleans
because, I mean, obviously, you want to do Booleans
in a procedural generator. That's just super, super
critical thing to be able to do, so lets do
GeneratedDynamicMeshActor. 'BooleanBP'.
I'll just do a quick one. I won't do it with the
full thing from that video. 'rebuild generated mesh'. Let's do Append Box. So now, we made a box. Now, we want to subtract
a sphere from it. So we have a node for that,
a mesh Boolean, Apply Mesh Boolean. The tricky part, though, here,
is we need a second mesh. So before,
I showed you that thing that was like Construct Object from
Class, and we could use that. So basically,
what we want to do is we also want to append a sphere to
something to a separate mesh, and then we want to subtract it. So I could do Construct
Object from Class. That causes a lot of
problems because this will be a temporary object that,
at the end of the Blueprint, gets thrown away and needs
to be garbage collected. That's a sort of
technical thing in UE, where it manages stuff that
gets created and destroyed. And that is going to make your
Editor slow down over time and use a lot of memory
if we do it this way. So to work around that,
we have something called a Compute Mesh you can allocate. So allocate is like
a programmer word. It means allocating memory. But essentially,
what this does, it means that we can make a temporary mesh
that we can use to do other stuff, and then at the end
of the Blueprint, we're going to do
something else. And actually, I'll just-- let's do
a Sequence because this is actually the cleanest way to do it. In a lot of my videos, I've actually
wired it in at the end of the graph, but this is simpler if you just do
your whole Blueprint as one thing. And then the second,
we're going to go 'compute mesh'. Release All Compute Meshes,
and this will essentially clean up these temporary meshes. So it's important to do this. If you don't do it
after 1,000 of these get created by running the
Blueprint over and over, you'll get a warning
message reminding you that you need to do this release. At the end,
you can also do it one by one, but essentially,
let's just do it this way. So I made a Compute Mesh. I'm going to append a sphere to it. I'm going to translate-- let's see,
I'm going to split the Transform, and this was dimensions 100. So the top corner is 50, 50. So now,
I've got a mesh I can subtract. I'm going to set that as the tool. I'm going to subtract that,
and that's the whole thing. Let's compile that. So now, I got-- oh, that's right,
because the Y needs to be 100. Is it Y? I think that's it, yep. Now, I put a sphere at the
corner, and then I subtracted it. I could go over here and
change it to a union. You want to see what
the actual shapes were. And so those were two separate
meshes, and then I subtracted them, and I subtracted the temporary
one from the main one. And so this is how
you use a Boolean. You need two meshes,
and these temporary meshes. This is a really critical
thing, these temporary Compute Meshes you use to make
in-progress states of your script. And again, this one, I have a
video for where I combine that with doing some patterns. So I took that sphere in the
corner, and I tiled it, which we have a function for that
called Append Mesh Transformed that will let you basically
append a bunch of copies, and then I use that to subtract it. I'll just mention something. This came up for us with internal
artists who started using this. You don't have to do a
union to combine two things. You can just append,
and then they'll be overlapping, but that's often actually better,
and it's almost always faster to compute, at least. So if you're just adding
stuff, you can use Append. You don't have to
use a Boolean union. It's much more efficient to just use
this Append Mesh or this Append Mesh Repeated I just mentioned. And like I said,
we have these temporary meshes that you need to use
sometimes, and we have that function Allocate Compute
Mesh and Release All Compute Meshes. So we call this
dynamic mesh pooling. Essentially,
it's reusing the UObjects, if that makes sense to you. And it's reusing the
memory for those UObjects instead of always deleting
them and allocating new ones. So that's built into
DynamicMeshActor. If you're in those Editor
Utility Widgets that I showed, you can use a function
called CreateDynamicMeshPool to make your own pool because
they don't have this built in. And it's less critical
there because, basically, if you're running it once,
you'll make one temporary thing. It's OK. But the Geometry Script where
every frame, as you move it around, it's recomputing,
this becomes a problem. OK, I'll just talk
a little bit about these pieces for more technical. This is the C++ level. But it's good to know about,
even if you aren't in the C++ level, what these things are. So we basically added
a few new things in UE5 to support what I just showed you. So we added this thing called
the UDynamicMesh, and then a component and actor for that. And then we had this
AGeneratedDynamicMeshActor. So UDynamicMesh,,
basically, what it is, it's a UObject container for
something called FDynamicMesh3, which is the C++ level
class that is the mesh. So this is a new-- I mean, it's not as new, because
it's been in UE for a few years now. This is the basis for
all the modeling tools. It's a high performance,
editable mesh type. So it uses more memory
than other meshes. But it allows all these
edits, like, things like a mesh description
or a static mesh don't really support out of the box. And we've got this huge
library of geometry operations for FDynamicMesh3 all in C++. Just, to be clear, the
UDynamicMesh, it's not an asset. So if you're familiar
with UStaticMesh, that's an asset that gets
serialized and cooks in your game, but as a separate
file, as an asset file. So UDynamicMesh isn't an asset. It is just purely a C++ thing that
you can interact with in Blueprints. UDynamicMeshComponent is a
component for UDynamicMesh. So this used to be a thing
that we used purely for kind of like live previews
and modeling tools. So this is how we can support
our sort of real time sculpting on something that's 5 million
triangles is via this component. It's very optimized
for fast updates. But it's not as good for-- I mean,
you pay a cost for that ability, and that is that it doesn't render
as efficiently as a static mesh. So in UE5,
we made this a real component. So you can create and
save them in the level. You can edit them
with modeling tools. You can set collision and
simulate physics on them. You can procedurally generate
them using Geometry Script, both in Editor and at runtime. And then we made an actor for
that component, DynamicMeshActor. So this is a standard actor
type for DynamicMeshComponent, similar to StaticMeshActor
and StaticMeshComponent. In Modeling Mode,
you can create them. But it's not enabled
by default in UE5. You have to go into
the editor settings and turn on Enable DynamicMeshActor. So I'll just show you. You go in here. You go Edit > Editor Preferences...,
Enable DynamicMeshActor-- oh, it's in the Project Settings-- DynamicMeshActor,
the Enable Dynamic Mesh Actors. And then when you go
in, in Modeling Mode, you can make a box
that's a static mesh-- Russell showed you-- and a volume. You can also make a dynamic mesh. And so the critical thing
here is to understand that there's not an asset. So if I make a box, right,
it's going to make a new asset. There's the box it just made. But if I make a dynamic mesh,
it's not going to make an asset. So you might-- so
that's good and bad. Because one of the things that
does come up in modeling tools is that you end up making
lots of temporary assets. So if you have watched what Russell
was doing, he made some things. And he combined them. When he combined them,
the old assets didn't get deleted. They were still in his
content browser somewhere. And also, everything was instances. So he had to sort of merge things
to make unique copies of them. So if I poly edit this
one, it's going to edit-- it's going
to update both of them. Because this is actually
editing the asset underneath. But if I take the dynamic
mesh, and I duplicate it, and then I poly-edit the new one,
it doesn't affect the original. Because they're completely
separate meshes. There's no instancing
or anything like that. So these Geometry Script objects
are also DynamicMeshActors. They just have a Blueprint
that generates the mesh. But when you make one
with a modeling tool, it's just a standalone one that
doesn't have a procedural generation sort of involved. OK, so I just did the demo of that. I'm going to skip some of these
because I've gone over time. I just wanted to mention versus
procedural mesh component. So because a lot of people
who've done this kind of-- tried to do this kind of
procedural stuff in the Editor, you often end up using
ProceduralMeshComponent. So I wouldn't say
DynamicMeshComponents exactly are a replacement for
ProceduralMeshComponent at this time. But there's a lot of times
where you would preferentially use DynamicMeshComponent. And we are hoping to reach a point
where there's really no reason to use ProceduralMeshComponent. The main difference in UE 5.0
has to do with physics support. ProceduralMeshComponent supports
async, physics building. And DynamicMeshComponent doesn't. But it does now in 5.1-- or it will in 5.1. It's already been
implemented in ue5-main if you're familiar with that kind
of terminology in our GitHub. And so it's basically, overall,
more efficient for storage. You can handle
millions of triangles, whereas ProceduralMeshComponent really will really slow down
into that kind of stuff. They're both serialized
in the level. Neither of them supports
Nanite or Lumen. So those are some of
the current limitations. I think I have a slide here on-- yeah, they don't support Nanite,
Lumen, or distance fields. They do both support raytracing. Neither of them has
LODs, levels of detail. And they're both
serialized in the level. OK, and so let's just
mention Python, which I didn't have time to talk about,
which I knew I wouldn't, so I didn't try. I've got one video about doing
Python stuff I mentioned. This is really great
for that kind of Editor Utility
stuff, Editor Tools, QA Tools,
if you're in a big studio and you want to check all your
assets to make sure that they have some geometric
properties, like maybe all the UVs are in a valid UV
space, and stuff like that. You can script those
things with Python using all the same Geometry Script stuff. OK, and then I mentioned Lyra. So I'll just quickly show,
in Lyra, we basically built these procedural
shape generators. So this is the Lyra starter game. And there's this Tools directory. And in there,
you'll find some Blueprint classes, like, for advanced window,
corner extrude, a ramp, the stairs-- there's the stairs. So these are the
stairs, for instance, that were demoed in the
sort of UE5 launch, right? So this is a stairs object. If we go in here and we look, these
are quite a bit more complicated than the ones that I was showing. You see, if I zoom out, there's
actually quite a lot going on here. That's because they
do a lot more stuff. So they have a lot more settings. But ultimately-- so
what happened here, there's a tech artist
who built these. I think he's actually
in the chat on YouTube, Simone Lombardo here at
Epic, who basically took what we had done
with Geometry Script and just like turned it up to 11
and did all sorts of awesome stuff building these kind
of level design parts. So what do I want to show you? So the stairs settings over
here, like, I showed things that had one or two settings. These have all sorts of settings. So I can go in. But they're all sort
of accumulating things. So I can turn on the bevel, right? And now the stairs have a
bevel, the same way that we put a bevel on that cube. There's some stuff in here
to generate simple collision. There's nodes for that. I didn't have time to show
them, things like changing the step height,
which will automatically-- so this Blueprint
automatically computes, given a step-height setting,
how many steps do you want, and that kind of stuff,
all sorts of super cool options. Yeah, like, I think, in the
video, they turn on Floating. So in here, there's these
linear stairs appends. That's the sort of core that
makes the stair geometry. But a lot of the settings are
computed by other Blueprint stuff. This is what tech artists are
the geniuses at figuring out. How do you compute all these
settings from other settings, and stuff like that. There's the part
that does the bevel. And then there's a simplified
collision generation. So there's a bunch
of nodes for that. So you can go in
here, and play around, and experiment with these
really sophisticated Blueprints. And like I showed, right-- so these
are all these DynamicMeshComponents. But the same-- sorry I just
have to drink a bit of water. I've been talking for too
long, clearly. So, remember, I showed you that
Bake to Static Mesh button. That's exactly this button. And we also have this one,
Generate New Static Mesh. So basically, if you wanted to
use this to build your level, you could take this part here,
generate a new static mesh-- I'm going to click that-- and that's going to make
a mesh automatically. And you see it populated,
this Target Static Mesh. I can even browse to it. And here it is,
it's in this directory, which is where they go by default.
So now, I can place-- nope. Why can't I place that? I wish Simone was on the
stream so he could tell me. And so,
anyway-- only reference assets-- oh, it's because of
plug-ins and levels, right? It's to keep you from
shooting yourself in the foot by referencing content from
one plug-in in another. OK, so let's go to a real level. And I'll do it in there. Recent Levels > L_Expanse_Blockout. [INAUDIBLE] load the map. So basically,
the Lyra levels were built-- Lyra, sorry. I called it "Lyra" for a long
time before anyone corrected me. And I still haven't adjusted. So this is a simplified version. The actual Expanse level
is even more complicated. But these whole levels were built
using these Geometry Script tools. And that's actually
what's under the level. So if you open this, you'll see-- it's maybe a little weird. You'll find all these
parts floating down here. And that's because these parts,
like I kind of showed before, where I had the displaced
torus, and then I was baking it to a static
mesh, these parts are the things that are used
to generate the actual level geometry, which is static meshes. Which it has to be. Because it supports
Lumen in this project. And actually, Nanite is turned
on for most of these assets too. But we didn't want to lose the
ability to edit them still. Because that baking that I showed
before was kind of destructive, right? A little bit,
you have to we could go down here and try
and find which-- these arches were generated
by something down here. But what we did is we built the
system into Lyra where you can swap. So basically, I'm going to
right click on this thing and go Scripted Actor Actions
> Swap to Generated Mesh. So this is one of those
Editor Utility actions, like I showed before. It's an Actor action. When I do that, I mean,
nothing really changed. It looks the same. But actually,
this-- you see that only this one has this little diamond. This is a thing I didn't show. But you can basically
make these little 3D handles in a Blueprint in your
Geometry Script Blueprints, or any Blueprint, actually. It's just that you make
an effector parameter. And you make it-- there's a little box to check,
to say, give it a 3D widget. So now I can edit this thing. And now I can right click on it. Oh, I have to-- I got to go to the right
thing over here, right? So I'm editing it so I can
now go down here and click the Bake to Static Mesh button. Because this, right, it has a
generated mesh associated with it, like I showed before. And it's going to update
all of them, right? So I can do these kind of edits
in place and update all of the-- because what it's really doing
is just updating the static mesh. And all of these other ones
are still that static mesh. And then I can right click on
it and go, Swap to Static Mesh. And go back. So now, it's the static mesh again. You see, the handle disappeared. And so now I can go just basically
do that on anything, any other one. Because they're all the same. We'll put it back. Bake to Static Mesh,
and then go back. And then I can swap it
back to the static mesh. So almost all the
stuff in this level, nearly every level-designed
piece, was created this way. So what the tech-- what the
level designer did is they took these objects. They dragged them into the level. And they configured it in
place, till they were happy with what it looked like. And then they generated
a static mesh for it. And then they swapped it to
that generated static mesh. And then,
when they want to edit it later, they just swap back,
and do the edit. And so this is a pretty
exciting thing that we think-- we built that whole system,
essentially, in Blueprint. So all of those swapping
actions are here in this bake-generated mesh system. So there's some special
base classes that keep track of that relationship
and the editor actions that do the swapping. But it's all done
here in Blueprints. So you can migrate
this to other projects and sort of do your own
kind of modeling like this. And you can make your own-- so these tools, you can just right
click here and make a new Blueprint that becomes one of these tools. They're not a special
thing that isn't easily portable to any other project. So I think that's my last thing. That's the last thing
I was going to show. OK, so I guess I went over
time, I think. I'm sorry, Russell. We've only got nine minutes left. RUSSELL: Well,
it was clear as you were talking, how many things I missed. So you know, it's-- TINA WISDOM: I think
you both did great. No worries. But if you're up to
it, there's a couple of questions that were
popping up a few times in chat that I'd like to address,
especially the ones that were asked by several people. I think we can sneak a
couple of those in there. One of the main ones is
for the modeling tools. Are there hot keys
available for that? Can they assign
anything to hot keys? RUSSELL PAUL: Yes, there's-- let's see. It's under Editor Preferences. You want to switch over. Hotkeys is always one of those
ones that's always a bit tricky. You can actually
bind a lot of things to custom hotkeys,
inside Unreal, a lot of the hot keys
are already used. But if you wanted to customize
them in the Editor Preferences, you can adjust them. In terms of-- there's
actually quite a few hot keys that are already associated
with some of the modeling tools. And they tend to get displayed in
the menu when you're doing things. So if there's stuff
you wanted to do. For instance, I think Ryan
mentioned transform the Control key. In Sculpt Tools,
there's options as well. In CubeGr (Cube
Grid), it's actually-- there's actually
a little shortcut info right here so
you can actually see, if you were laying
out Cube Grid stuff, you can see quickly how to do stuff. And that's in there for you as well. So there are definitely abilities
to edit hot keys, as well as-- and there definitely is some
tooltips in here for them as well, the ones that exist. TINA WISDOM: Awesome. I know that, for me, hot keys
are integral to making sure it speeds up my workflow. So I'm sure a lot of people
are going to be relieved to know that they can still
use hot keys with some of these favorite tools. RUSSELL PAUL: Yeah. TINA WISDOM: Can Nanite geometry be
deformed with these modeling tools? RUSSELL PAUL: Yes. I actually-- it's funny, I did
a previous demo where I actually had-- some of the meshes actually
had Nanite enabled on them. And I actually had just done
the demo with Nanite enabled. So, yes, you can. In this particular case, I had not
loaded the Quixel Nanite meshes. But, yeah, you can do it. It does have an impact. Because-- Ryan, correct me
if I'm wrong-- because it is having to recalculate some
of the Nanite information when you complete the operation. RYAN SCHMIDT: Yeah, so when
you're editing a thing live, it is not using Nanite. So basically,
Nanite is like a rendering level thing on a static mesh asset. And so when you go to edit a static
mesh asset with the modeling tools, we are actually basically hiding
your instance in the level. And we're making a preview mesh. That's this DynamicMeshComponent
that I've mentioned. And that lets you
efficiently do stuff to it. And when you're done,
and you click Accept, it updates the static mesh
asset, which then updates the Nanite rendering
geometry and stuff like that. And so it doesn't affect
it while you're modeling. But when you click Accept, if
you're on a 2 million triangle mesh, it takes longer to do the
updating because of Nanite. TINA WISDOM: Understandably so. RUSSELL PAUL: Yeah, that's right. It's 2 million triangles. TINA WISDOM: It adds up
a little bit eventually. So-- RYAN SCHMIDT: Yeah, yeah, yeah. But one of the things I saw some
people asking in the chat earlier, like, why would we do
our modeling in UE? And one of our big things
we've been focused on is making a lot of our stuff scale
up to Nanite-scale resolution. So we can sculpt on a raw 5
million triangle sort of mesh. And our deform tools and
stuff like that are very performant at those resolutions. Because our internal
teams who've been building Nanite content have been using these
tools to do a lot of that stuff. And so that's one of our
focuses, has been making things work at Nanite scale,
where it's possible. Some things still, I have to
say, are not that performant yet at that scale. But a lot of things,
we have an auto UV generator that works on millions of triangles in-- it doesn't take hours, it takes
minutes, that kind of thing. RUSSELL PAUL: I mean, even those
wood beams that I was dragging in, I think they're a little
bit older Quixel assets. But they were at the highest
quality Quixel assets that they had. I mean, they were far
more dense than, I think-- for a beam that you might expect. It's fine. I haven't had any issues working
with the high res geometry. TINA WISDOM: That's awesome. And I know, again, that's going
to be very helpful for especially people that are trying to make stuff
with exclusively Quixel content. I think that will be really
helpful, in the long run, for those. There was a question
about the plane cut that was blowing
everybody's minds earlier. How does the plane cut
handle complex geometry? Does it read topo or preserve quads? RYAN SCHMIDT: It does not read topo. And we don't have quads. You know,
everything is a triangulated mesh. So it's cutting
through the triangles. And then you have the
option to fill or not. TINA WISDOM: Awesome. Is there a way to set up
color IDs using Unreal 5? RUSSELL PAUL: So for vertex color? Or-- RYAN SCHMIDT: Yeah, I'm not sure
what color ID means in that context. TINA WISDOM: It'd probably be
vertex color, I would assume. RUSSELL PAUL: Yes,
so there actually is-- let's see if-- RYAN SCHMIDT: We do
have-- we have bake-- we have basically tools where
you can bake to vertex colors. And then we have-- it's not really part
of Modeling Mode. There's a separate Paint Mode that
allows you to paint vertex colors. RUSSELL PAUL: Yeah, sorry,
I was trying something. I wasn't-- bake to vertexes is
not something I've tried too much. TINA WISDOM: I'm coming in
with the hard questions. You'd better have read up! RUSSELL PAUL: It's a live
demo, you know? I'll experiment too. I'd have to see if-- I think Lonnie and
the guys are online. They can ping me and tell
me what I'm doing wrong. TINA WISDOM: They can handle
it, chat. RUSSELL PAUL: But,
yeah, I think Ryan said there's another mode for painting. And then you can
paint weight maps and stuff directly in
your [INAUDIBLE] TINA WISDOM: Awesome. For some of the questions directed
more at the scripting side now, so, it's your turn, Ryan. Switching up. RYAN SCHMIDT: Sure. TINA WISDOM: How heavy is
Boolean for the engine? Because, obviously,
the logic for Boolean sometimes can be calculated
as a very heavy step. RYAN SCHMIDT: Right. So it's a hard question to answer. Because it really varies based on
how often you're doing the Boolean and how many triangles are involved. And then it can also depend
on the configuration. Like, if you have lots
of stuff that's, we would say, co-planar,
like, two cubes that are the same height
that are overlapping is more complicated than
if the two cubes are offset so that no triangles are
directly on top of each other. Generally,
it's not an operation that you would want to be doing every frame. So in these demos
that I've been doing, it's being computed
as I move something. But then,
when I'm rotating the camera, it's not computing that Boolean. If it was, you would see it. You would feel the frame rate. I have done some
demos and experiments before with things like
a wall and and a gun that makes holes in the wall
with a sphere or something, like, you shoot shoot-- well, we did one that
was the bunny gun, where it basically shoots a
bunny rabbit at the wall and subtracts the bunny rabbit. And in that kind of thing,
where it's a one-shot operation, you would probably see be able
to see some hitch on that frame. And then you have to kind
of tune the resolutions to a point where you feel
like that hitch is acceptable. Because anything with
the scripting right now is being computed
on the game thread. We've been looking at, like,
can we make these things async? But in general,
Blueprints run on the game thread. And it's a bit complicated to-- it makes it harder
for the user to use this stuff if everything has to be
running async and sending messages around. So, yeah, that's why we've
been mostly focused-- although I said it's
available at runtime, we've been mostly focused
on geometry scripting in the editor as like
procedural generators. But once it's generated,
it's not doing the Boolean anymore. And so you don't pay those
costs, sort of, every frame. Yeah. TINA WISDOM: Awesome. For the scripting,
how expensive, overall, would you consider it to be. To narrow it down maybe
a little bit further, when would you not want to
use scripting, especially considering Nanite,
and some of the other features? When would you encourage using
something besides the scripting? RYAN SCHMIDT: I guess it sort
of depends on for what purpose? I would say using the
geometry scripting at runtime is more kind of experimental as a
concept than using it in the editor. In the editor,
if something is expensive, it will sort of lag while
you're doing the operation. And then it won't be slow anymore. If you're trying to
do it at runtime-- like, people have asked
for things like, well, could I procedurally generate
a whole level on startup? And you could. But it would probably be too slow,
unless the level was very simple. If you're generating something
that's a million triangles, that's going to take a
couple of seconds at least. Nanite doesn't-- so like I said,
Nanite's not really supported on these procedural objects. And it's not supported at runtime
to automatically-- or to make a new Nanite mesh at runtime. So there's a lot of things like
that would just be too slow. If you had a million triangles,
the Nanite pre-computation that has to happen takes
a couple of seconds. So it would be too slow
to do that at runtime. So using any of this kind of
scripting stuff at runtime is something that is
really situation dependent. You really have to do performance
profiling and figure out, is it fast enough to do
this in this context? And definitely, the sort of dream
is like, everything could be procedurally generated on the fly. But performance-wise,
we're sort of not there to do, especially if you want to
do really high-resolution models and things like that. TINA WISDOM: Absolutely. So this next question I'm
going to pose to both of you. I'm curious about both of
your answers for this one. RYAN SCHMIDT: Sure. TINA WISDOM: But with these modeling
tools, obviously, some of these are fairly new, fairly experimental. And they'll continue
to be built upon and reiterated
over time as well. But ultimately, end goal, I want to
look into the future a little bit with the both of you. With this toolset,
what is the goal here? Are you trying to eliminate
the need for external tools and be able to just make
everything directly in Engine? RYAN SCHMIDT: I think I'll
answer that one, Russell. Unless you want to. [LAUGHTER] RUSSELL PAUL: You can go. RYAN SCHMIDT: So we aren't trying
to eliminate anything definitely. People make amazing stuff with
all the other DCCs out there. And Unreal integrates
with a lot of them. We're trying to make
it possible for people getting into the game industry
to make their stuff directly in the editor. And there's a lot of good
reasons for that because-- particularly around iteration time. So if you want to make
an amazing fire hydrant, you can do that in anything. And you can import it, and the
same way that we import stuff from Quixel Mixer. It's like an asset now. And you place it in your level. But especially for this
level design stuff, like I briefly demoed with
Lyra, and Russell demoed with making the
ramps and things like that, going back and forth
between a DCC starts to be-- you start--
you reach a point where as you're
fine-tuning a model, you're spending most of your
time just reimporting, waiting for stuff to go back
and forth and not actually doing your creative things. And so we're really focusing on
trying to make those iteration things less painful. And there's a huge world
out there of modeling stuff. Particularly Blender,
if you look at it, there's hundreds of
third party add-ons and stuff like that to do
all, sorts of, amazing modeling stuff in Blender. And we're not trying to
eliminate any of that. We're just trying to make
it more efficient for people to work in Unreal. And so that's our view
on that right now, is use whatever tools you're
the most comfortable with and let you work the
most efficiently. And we're going to try
and give people things that help them build Unreal content. But still,
we're working on an entirely new-- you can see it in ue5-main,
development of a whole new importing system that makes importing more
efficient and stuff like that. So we're investing in both of
those directions simultaneously. RUSSELL PAUL: Yeah, and I think-- I didn't really touch on it too
much, is working with imported data and making sure that you have tools. There's tools for when I hit
like baking scale, or fixing normals, or correcting meshes. These are all little things that
our advanced users are probably dealing with. And a lot of times, it's like, oh,
I brought my stuff into Unreal. And I forgot to do this. Or I need to do this. Or I need to adjust this map just a
little bit or this UV a little bit. And having to continuously
bring it in, go back out, go to another package,
redo these things is a big-- it takes a lot of time. And it becomes more inefficient. Whereas, if you can just make those
corrections directly in the editor, it can really, really make the
whole process more efficient. We've had, obviously, conversations
with the Fortnite artists and some of the special
projects artists who've really taken
things to the extreme. But I think like Ryan
said, for me, what I'm getting into it is as people
learn, they're going to experience. And they're going to
try out different tools. And they're going to experiment with
Maya, or Blender, or whatever it is. But what I find the most
fun about this process is not only the ability
to help make sure that models that I've brought in
are efficient, or that are working, or do clean up,
or data prep operations. But it's also,
just like what I was doing today, is it's actually quite a bit of-- creatively,
it's fun to basically be in here and iterate through things
quickly, directly. And yeah, in production, it might
be like, OK, some of this stuff, you need to jump over
to a DCC with texture artists and the whole blown thing. But creatively, it's great to
have all the stuff directly in the editor. It's a lot of fun. And just in case somebody
was asking, the vertex color, I forgot to add the
texture map to the baking. But there is a bake vertex to bake
from a texture map to vertex colors. It's in there. It's actually called BakeVtx,
which seems rather obvious. But I just forgot to add the
texture map in there, so. [LAUGHTER] TINA WISDOM: Thank you for
the extra tidbit in there. [LAUGHTER] Both of you had such nice
answers to that question. Here, I was hoping for someone
to be like, yeah, eliminate all the competition. It's only Unreal. [LAUGHTER] RUSSELL PAUL: Yeah, that's a
very, very tough high-bar. [LAUGHTER] Maya is 20-- what, 26 years old now? 20-- TINA WISDOM: Yeah. RUSSELL PAUL: Or maybe not. Maybe not that old. But I know in 3ds Max,
they've had a long time to really develop that
toolset and iterate through. And we're-- it's a-- I don't think replacing them
is going to be something. I don't know. We'll see. RYAN SCHMIDT: Yeah,
and one of the things we've-- TINA WISDOM: Yeah,
it's more for working hand-in-hand. [LAUGHTER] RYAN SCHMIDT: That's right. That's right. One of the things we've-- just, a lot of us working
on these modeling tools came from the DCC tool industry
more than the game dev industry. And so it's been a learning
process for all of us to understand what
the differences are. And there really are a lot of
differences between a game art workflow, and a VFX workflow,
and stuff like that. And that is one of
the things we've seen, is that we can build tools that
are complementary in a lot of ways with what you would do in a DCC and
then what you would do in the game environment. And some of them are the same. You want Booleans
and stuff like that. But there's a lot of things,
that we want Unreal to support that. And a traditional DCC would
be done in different ways because they are not in this huge-- you're not always
working on a level. Whereas, on Unreal, generally,
you're always working in a level. Often, now the levels are massive
open worlds and stuff like that. And so there's just
so many differences. And so many of the people
want to use the modeling tools and in that context. And that's really driven our
development in a lot of ways. It's pushing us
towards what people are doing in Unreal,
where it would help them to be able to do those things
directly in Unreal versus just general purpose modeling,
where you could do it anywhere. TINA WISDOM: Yeah absolutely. Well, I have to thank
both of you so much for walking through these
tools with us today. It's incredible stuff that we saw. And obviously,
there's even so much more that we didn't have the
chance to touch upon, because unfortunately there
is limited time in the day. And there's so much available. So this just means I'm
going to have to lure you back on for another stream. [LAUGHTER] RYAN SCHMIDT: Sure, anytime. RUSSELL PAUL: The Russell and Ryan
modeling road show, I guess, is-- TINA WISDOM: Yes. RYAN SCHMIDT: That's right. [LAUGHTER] TINA WISDOM: We'll
have just each week-- RUSSELL PAUL: And take
our act on the road. TINA WISDOM: Yeah, we'll have
our own show for just this. [LAUGHTER] But-- RUSSELL PAUL: Just,
I was going to say, we did see a couple
of questions coming up from people who are obviously
seeing what the Quixel team is doing with mass and voxels. And there's a ton of
stuff that I think would be great to show at some point
that other teams are getting out there and showing. So [INAUDIBLE]. RYAN SCHMIDT: Yeah, we're really
the amateurs, me and Russell. [LAUGHTER] We're-- the real experts
are our internal artists, who've done wild stuff. RUSSELL PAUL: If manager is in
your title, you're not a demo guy. [LAUGHTER] TINA WISDOM: Well,
maybe I can see it. But-- [LAUGHTER] RYAN SCHMIDT: Yeah, yeah, yeah. TINA WISDOM: But before we go-- RYAN SCHMIDT: I was just
going to say, I just saw-- oh. oh, sorry. TINA WISDOM: Oh, no. Go ahead. RYAN SCHMIDT: There was a-- I have a bit of lag. I was just going to say, I saw-- they just posted it,
at least in the YouTube stream, to mentioning a forum thread
for follow-up questions. And please do if you're
listening and you had questions that didn't get answered. I'll be watching the thread. And some of the people from our dev
team have been watching the chat. And we'll be happy to answer
your questions and stuff like that after the stream. RUSSELL PAUL: Yeah,
and we do also lurk in the community forums, the Unreal
Engine community forum as well. And I do lurk in Discord
periodically as well. So we're out and around to try
and help answer your questions and listen to everybody's feedback. And there is also a public roadmap
that you can also comment on. If there's other elements that
you guys are really excited about, feel free to comment
at stuff there as well. TINA WISDOM: Yeah, absolutely. Like they were saying,
if anybody has more questions, because there were a ton. [LAUGHTER] So I'm sure if we missed
it, don't worry. There's plenty of
opportunity for us to still be able to get to your
questions and answer them. You can find them either on the
original forum post announcement or, as they were saying, just
out and about in the forum world. Please come over to our brand new
sparkly and shiny community site. It's very pretty. And we worked very hard on it. [LAUGHTER] But with that as well,
before I forget, do you mind going over the
plug-ins that they need to turn on to enable all the
stuff we did today one more time? RUSSELL PAUL: Sure. I'm going to switch
over to my screen. So the main ones you want to turn
on are Modeling Tools Editor Mode. That's going to give you the
palette over to the left. The Static Mesh Editor
Modeling Mode is, if you're used to using
the Static Mesh Editor, it's going to give
you a small set of tools in there for
working in there. But those are really just
attribute editors, and inspectors, and things like that. Most of the modeling
functionality is going to be in the Modeling
Tools Editor Mode. And then, the UV Editor is
obviously called UVEditor. And then, the final one
that you want to look at is called Geometry Script. Right here. Those are the ones
you want to turn on. And then, after you have
those guys turned on, yeah, you can just
grab stuff from the-- it should show up here in the mode
selection under Modeling or Shift+5. There we go. TINA WISDOM: Perfect. Thank you so much. Well, as you saw here, Unreal
Engine 5 is officially released. So if you haven't
already, make sure you go download it and
play with it as well as all of these really cool geometry
tools that we went through today. Make sure that you play around
with it, post your progress, post any cool stuff that you make. We do look around. We do see it. And it's really cool to see the
interesting and innovative stuff that people come up with. Like Ryan said earlier in
the stream, sometimes you guys come up with stuff that we
didn't even think was possible. [LAUGHTER] So-- RUSSELL PAUL: All the time. TINA WISDOM: Yeah. RYAN SCHMIDT: All the time. TINA WISDOM: Please
continue to do so. And tag us at Unreal
Engine on all socials so that we have a chance of
seeing all of your hard work. And also, don't forget to give us
your feedback on our new community site that I talked about, which
is dev.epicgames.com/community, a little bit of a mouthful. But it's worth it. I promise. Also, thank both of you so much
for coming today and talking on the stream,
talking about these tools, and showing our community some
of the very awesome things that are possible for them. And also,
thank you to the viewers who came and watched this stream today. It would be really
weird if it was just the three of us sitting here
chatting for a long time with nobody involved. So your presence here is also
super, super appreciated. And we post our streams
in video format. So if you missed anything at
any point through the stream, don't worry. We always post the video
format, which can be viewed on demand on our
YouTube channel or on our Twitch at Unreal Engine. It saves the VOD as well. So all of those wonderful questions
and answers that were in the chat are also saved along
with that video. So don't worry. You won't miss out on anything. You can come back and
view it whenever you want. Don't forget to keep up with us at
Unreal Engine on all social media, as well as come say
hi on our forums, where you can get
the latest news and also find all links
associated with today's stream. And don't forget to tune in next
week for our fluid sim in UE5 show as well. RUSSELL PAUL: Awesome. RYAN SCHMIDT: Great. Thank you. TINA WISDOM: Yep, thank you. RUSSELL PAUL: Thanks,
Christina, everyone. TINA WISDOM: Yeah.
