Hello, Unreal Fest. Or since we're live streaming,
I can make the programming joke and say, hello world. Hey. My name is Chris Murphy. And today, we're going to be talking about 35 features in Unreal Engine 5 that you probably don't know about. Now I'm going to level with you. I originally pitched
this as x features in UE5 that you don't know about. And at some point, marketing
we're like, we need a number. And I was like,
I haven't written it yet. So you'll see how many there are. Well, if you're counting, I guess. The other thing I want to
highlight before I kind of get into this is the word "probably". I know there are plenty
of veterans in the room. I'm still going to do
my best to highlight a bunch of obscure things
that are kind of in there. But there's a very good
chance that some of you picked up some of these things. That said,
I'll be impressed if anyone knows all of these things. Now for anyone there that's
like, who is this guy, my name is Chris Murphy. I'm an evangelist. Historically,
I handle Australia and New Zealand. And my role as evangelist,
which is a weird sounding job title for anyone unfamiliar
with the tech industry, is to basically help
developers within my region. There's-- Epic has a
reasonably tight knit presence in my part of the world. So consequently,
we kind of head around, we help out all sorts of people. And it's a rather strange job. But in the process, there's a lot of conversations we have reasonably frequently that it's
like, oh you didn't know about this key binding? You didn't know about this feature? Oh yeah, that was a small
note in a release note somewhere that you didn't read. Sorry about that. And the common joke
literally running through this entire conference is, you don't know about that checkbox? No. So in general,
the alternative titles here that could have been is like, features that developers groan about
when they realize they exist. And things that snuck
past you because you were too busy releasing a game. And why are you throwing
these things at me? We have to focus on
the current version. Chris, stop saying stuff. So let's go ahead and start
with some of the fun stuff. Most folks know the water
system that's come into Unreal. It's a fun one. But what a lot of
folks aren't aware of is that we have buoyancy
support in there. If you go ahead and
enable the Water plugin, you can go ahead and flick
on a buoyancy component to your Blueprints, at which point you get flotation of things. And you'll probably be
like, cool, Chris. You floated three cubes. But I floated many
more cubes than that. So it's a fun one. It works surprisingly well. It's one of those things that
I've literally seen people engineering this system. And I'm like, we did it already. So they get angry happy
if you know what I mean, when you find out the
feature is there already. The next one here is
the Niagara debugger. Plenty of VFX artists
in the room I assume. A lot of folks aren't
aware of the debugger though, which allows you to go
ahead, launch it up, and freeze frame the effects. You can also go ahead and
start to step through it frame by frame to
see what's going on. But another really cool thing here is you can filter by system
and filter variables out. So in the system viewer,
I want the fireflies in the background. So I type in the word, fireflies. You see that gave me a
little nice drop down as well because that effect existed. From here, I can look at that
and be like, oh, this is cool. But I really want to
know why the lifetime is all screwy on these things. So I can go ahead and
say, tell me the lifetime. And it's going to go
ahead and do that for me. So I want to flag that this
was there because folks aren't always aware of it. The other really
cool feature on this is that you can go ahead and
manipulate the speed as well. So if you want to run
an effect in slow motion to just see what's going on, feel free to launch this up and
change the speed as you go on. It's good. So the next one is
custom decal response. Now generally,
when you project a decal, I've gone ahead and projected
a gradient decal onto this, which is on the left hand side. On the right hand side, you can see we have cool blending
going on with that decal. So what's actually happening
there that's really cool is that Unreal Engine
5 has the ability to let you custom set up the
decal response of a surface. So inside the material,
you can actually say, hey, when a decal is projected onto you, this is how I want to do it. In this case,
I'm just doing a height blend with the grime to make it
look a little bit like it's blended into some certain
areas of it first. Now this is really useful. The two main functions
you need to care about if you're using materials
here are your Dbuffer Texture and your ApplyDBuffer nodes. The other thing that's
really important here is Receives
Decals has to be false. And I know that sounds
counterintuitive. But what Receives
Decals equals false does in this scenario
is it basically says stop receiving decals
in the traditional way. And if I need decals,
I'll handle them in the material itself myself. OK, if you're wondering what the
material was as to what I just did, I love how many
hands I just saw go, whoa, then this is a quick thing. I'm literally just
getting the same material, doing a standard blend,
and then just throwing in an alpha with a HeightLerp. It's nothing too complicated. Placeable clouds are fun. This is a system that a lot
of folks are unaware of. I bring this up because this
is a cool little system that's sitting inside the
Volumetrics plugin. You can access it. You can tear it apart because
it's written in Blueprint. So you can extend
this as you see fit. You really only need
two actors within it. There's a CloudMask
and then there is the CloudMaskGenerator. Once you kind of pop them in,
it actually handles the generation, pushes out a render target,
the render target then filters into your cloud setup. Now the default cloud
material won't work. So you'll need to enable
the Volumetrics plugin. And then inside of that, I suggest you take a look at Billowy_03. And that shows you
where the render target is meant to go in a
standard cloud pipeline. This isn't exactly like a, hey,
it's an out of the box feature. But it is a really,
really good feature to drop in, test
with, and experiment. Because so much of your
view in any open world game is literally the sky. And a lot of developers are like, so I put in the default
clouds and they looked great. And then they go about their day. And it never changes. So I wanted to highlight
this for a little bit more customization. Custom prim data came
in a little while ago. But a lot of folks
are unaware of it. And I think it was for 5.0 that
we cleaned up the interface. So historically speaking,
when you have a parameter, in this situation, you can see
that we have one parameter. And when I change it,
a bunch of rocks in the scene all change together. And that makes me sad because
sometimes, you want to go ahead and you want to have it
so that each rock could be modified independently. Now a lot of people would be like, guess I'd better make a Blueprint. And I'll be like,
I guess you're wrong. Because we have a great
system that you can use called custom prim data
that pushes the variable off to the primitive. You can see here that I
can now add moss intensity. And only that one asset is changing. All right, so it's actually
throwing these variables on the primitive and
then pushing it up. It's a really nice thing. You can do more than just scalars. You can have vectors. You need to custom
assign what numbers these are being assigned to,
like it's custom prim zero, custom prim one, or whatever. So there's a little
bit more work in it. And you need to kind of think
it through from a pipeline perspective if you're
incorporating it. But it is really, really useful. And it looks good. Now a couple of things
that are really useful here that are worth mentioning
is that if you historically get a material that is identical
but then you change a value, those things no longer
batch because you've got one instance with
the value of like, let's say you've got a
damage loop in there that's like a damage of 50%. And then another one
that has a damage of 25%, they're technically
different materials. When it's only custom prim
data, it's loading at they have
the same material. It's kind of just loading that
variable from the primitive instead, at which point we
have batching, which is great. So it's good for artistic
vision and it's good for performance reasons. Everybody wins. But it's a really nerdy
sounding art feature. And I think that's how
it got missed by some. This is something that's in 5.1. But you know when you look
at like the release notes and you're like,
no one is going to notice this? So I'm just being preemptive
about this one and flagging it. This is a 5.1 feature,
which is really cool, which literally lets
you go ahead and create variables and functions. And it generates the C++ header
information over here for you to use as necessary. This is really good
when you're learning it because you no longer have to-- I'm sure, anyone that has
done any programming here has gone through the ropes. When you're first
learning UProperties and such, you're like,
what's it look like? This is kind of a nice
friendly way to do that. Another reason I like it is
because it's a friendly way to kind of put your toe in the water as a Blueprinter that's moving
into programming that may want to have some-- maybe
all you want to do is make something inside
the asset registry. So you need to declare it. More on that later. This is a cool one. Interpolate material
instance parameters. So see this node over here? It takes two material
references that have a common parent material. Important. And then it takes
the current target. And what it does in this scenario, you'll see that I have material
version A, material version B, once again, there's the node. And I've bound it to spacebar. And when I hit Play,
you can see that it's interpolating between those two. Now the great thing there means
that your artist can basically make a version of the
material that is like, here's what it looks like with
the shield effect applied. Or here's what it looks
like when they take damage. And you can kind of have it as more of an artist driven version instead of them just changing a
whole bunch of those values in the Blueprint. You know when someone
tells you a console command and you're like, how on Earth
was I meant to know that? Well, a lot of folks don't
know, if you click Help, you can click Console
Variables, which generates a searchable
document of all of our console. Now I strongly recommend
you check that button there that says "Search in help
as well" because that checks our tooltips, which is really,
really good information. But in doing so,
I can just be like, look. I have a problem with fog right now. Tell me everything
that could fix it. And then the engine is
like, here is your list. And then we high five. And everyone is happy. Speaking of console
variables, I wanted to bring up the Console
Variables Editor plugin, which is off by default.
But if you turn it on, it's cool. It lets you add
variables, which is great. But you can then
flick them on and off. And you can see with the variables were flicked on or off. You can revert them
to the constructor. So you can see what that
default state of them was. Another really, really cool feature is that you can go through and
you can save those variables into presets. So if you have a
common setup that you need to have when you're testing
various things like these five options are off,
it's really cool to just be like, do that, computer. And again, high fives all
around, feature implemented. ABTest. This is not ab test. ABTest is a great
little console command that if you type 'abtest'
before a console command and then enter the two
values that you want to test, Unreal will automatically
flip between those two values over and over and over again. And it actually tells you
the performance difference of those two things. And then it tells you the
chance that that was from noise. Type in 'abtest stop' or you're
going to have a bad time. But this is-- by the way,
I used the worst possible image to show the fog off
on this in hindsight. So sorry about that very mild
flickering in the distance. But hopefully, you get the point. This is the actual worst image
in this for a cool feature. But the Common UI plugin
was added in 4.27. It's a feature of common UI widgets that get used in many, many games. I mean, there are a lot
of features that I'm sure anyone here in the
room that's handled UMG that-- you've built
that framework again and again between projects
where you're like, I guess we need to have a
rotunda in this project again. Common UI gives you a
lot of those basics. But another really cool
aspect of Common UI is it allows you to give
style assets to your buttons and widgets. So it's much easier
for you to change things in large
sweeping moves rather than having to go through
them all one by one. So being able to pass that in
as an object is really good. It's also a bit nicer for
interactivity with gamepads. Reload Asset is one that
I see happen frequently. You can see here that I'm
changing a Niagara asset. So instead of going, oh no. I broke it. You can just go Asset
Actions > Reload. And this will grab the
version of it on disk. You don't need to
restart the editor. And it works there. So you can see that
it's reverted it. But it actually works
for levels as well. So again, in this case,
I'm duplicating a bunch of stuff. And then I'm like, oh no. I broke it. Don't restart the editor. Just go to it and click Reload. And then it should revert
back to what you had. I like that there's a
little bit of groaning in the room on that one. I felt collective pain. This is a fun one. This is in UE5. This is the waveform
collapse generation plugin. So if you build a sample
environment like this, it kind of shows you how bits of
a thing can be stuck together. And you can use this widget. This is a plugin you can enable. You can use that widget
to create sample data. And then you can go ahead
and generate samples based on the thing
that you've built. OK? I bring this up
because this is like, one of the most
frequently rebuilt things that I see when people are first
learning procedural generation. And they jump on Twitter,
and they post it, and they're really happy because
it sounds really technical. Waveform collapse generator. But it's a really nice one
to have just a reference point for how something
like that could go together. So I wanted to flag
that this existed. And if you ever want to
kind of go down that path, that there is something that you
can have as a reference point. So it is all just housed
within this editor utility widget that has the output
and input controls from it. RVTs, or Runtime Virtual
Textures, these are really, really lovely. They've been in there for a while. Some of you that
follow me on Twitter probably consider me a Runtime
Virtual Texture evangelist. And I totally understand why. But the RVTs basically create
a large sample of the world. Can we bring the house
lights down for this sample, if that's OK? I'm not sure if you
have the controls there. Sorry to put you on the spot. He's shaking his head, no. But if you look really carefully, if you look carefully here, you can see that it's actually
blending into the environment. So as this asset is
kind of going into it, it's actually doing a smooth blend. And that controls
the normals as well. This means that your rocks
don't look like they've just got a hard polyline and stuff
stuck into the environment. It's a really,
really good technique. My apologies for using dark colors on dark colors for the
example in a well-lit room. But essentially, what it does is
it takes an orthographic image from-- so it just sees the xy,
and then it passes that off. And you can then sample that data. So your landscapes can
output that information. It's also really good
for performance reasons. Because you can kind
of get the cache that's coming through there and pipe
that back into the landscapes. Check out our docs
for more info on this. But it is a really,
really good feature both artistically and for
performance reasons if you have outdoor environments
that you want to feel good. Now Niagara Fluids are a
feature that plenty of folks have seen bits and pieces of. But just to flag it,
it is a plugin that if you enable, you can go ahead
and create your own. Now I wanted to go and step
into what that looks like. Because if you enable
the plugin and create one with the simple
particle source emitter, it's actually a really
comparatively friendly way to get into it. And what it does is it
actually passes its information from that left emitter
into the right emitter to control the fluids. So in the right hand side, you can see we're able to
change the temperature, we're able to change the advection, we're able to change
all of the stuff that happens after the flames
kind of get created. But on the left hand
side, that emitter is actually spawning particles
that it's pushing out-- excuse me. That it's pushing out. And what's actually happening is
that means that you can control the visuals of these effects. So in this case,
I can go ahead and say, hey, spawn them inside of
a torus and create this cool ring of fire. And I can control this
in different ways. But it actually is
just being controlled by a standard rather boring
emitter that just happens to have a nice way to
pass this information to the complicated stuff. And I bring that up because
a lot of people open them up and they're like,
that looks too complicated. But quite often,
I'm like, if you only go to the emitter
summary on the right, there's a good chance that you can tweak it and create some pretty
cool effects that you may not be aware of. Now here's an awkward one. If you've got something with fluids and you add an actor tag
"collider" to a mesh, I know, what that does is
fluids will now collide with those specific surfaces. So you can see here
that flames are actually spraying into that mesh. And if I move it around,
the flames go past. So again, you're adding
the actor tag "collider", and that will enable collisions
for fluids, which again, it just looks really cool. So just very happy
looking at that still. So again, just here, "collider". So I know I'm
reiterating this point. But it's missed by many. Now another thing that's really
useful for any folks that are developing content is
the advanced search syntax. So in this situation,
I'm typing Nanite enabled And the triangle count is greater than whatever number I type in. And what that actually will do is that will show me every single
thing within the content browser that has those values. Now it's worth noting that this
metadata that you see here, this information,
that is what is being saved in the asset registry. And that's what it's searching. So anything that's
really appearing in there with a number is
something you can then query through the browser. Now that information is referred
to as the asset registry. So whenever you define
a property in C++, if you flag it as asset
registry searchable, that will now be added
into that information. So a cool thing is that
if you did say, let's say you have weapon
Blueprints in your game. And you create a bunch
of different weapons that have a damage value,
and you make the damage value asset registry searchable. In your content browser,
you can now say, get me all weapons that have
a damage of greater than 300 and things like that. So that information
being used for your own nefarious purposes, good stuff. And if we go through here,
the other awkward thing that folks don't know
about is the columns view. I know this seems weird. But everyone often keeps
the content browser in just default tiles. But if you use the columns
view, again, it's searching all of that information. And you can now arrange
by certain things without having to type in queries. So I wanted to flag it. Because again, it's a thing
that a lot of people miss. And I wanted to make
sure you're aware of it. Blend space graphs are a feature
that has appeared with UE5. And that is if you create
a blend space asset, you may be familiar with this. But what you may
not be familiar with is that if you double
click on any of those, you actually now have subgraphs. So you can now have some
really crazy nested behavior with more complicated stuff handled within each blend,
which I personally think is really, really good. But be careful doing it because you can get some really deep
complicated behavior pretty quick. But again,
a lot of folks don't realize it because there was a lot
of changes with UE5. Bake to Control Rig. So in this case,
we have a regular animation. But it's worth noting that if
you go Edit in Sequencer, Bake to Control Rig, and you have
a setup on a control rig that will support it,
then what this will actually do is grab that animation that's come in from an external program,
and [INAUDIBLE] bake it out as keyframes within Sequencer
for all of the controls, not just the bones but the controls. Now the great part of this is you're now able to kind of tinker with
it and tweak it as you see fit. I bring this up because you're
probably looking at that thing down there and you're like, Chris, that's a lot of keyframes. And there is a Simplify Keyframe
button when you create it. But if in post, you want to do
a little bit more than that, be aware that you can
go to the curve editor, you can grab whatever keyframes
that you want to tweak, in this case, I guess, all of
them, and you can go through and you can click Filter. And Filter, I can go Simplify. And that will now remove
a whole bunch of keyframes and give me some generally
slightly nicer curves that I can now use. Now the great thing about all of
this is that when you do that, it creates an animation
in Unreal that saves that as an animation for that mesh. So this means that if you
have something like this, how many times have you
been given an animation from someone and then
you've been putting together a prototype, and that
animation is slightly wrong, but they've gone home for the night, but you really want
that feature working? So it's really nice to be
able to kind of grab that-- Sorry. That's sound like it's
coming from a personal place. But you really want that
feature working, right? And it's really nice to
be able to jump in there, and tweak it, and clean it
up, and whatever else. And they might do their proper
job later if they feel like it. But it's really great to be
able to bring these things in and tweak with it. It's also great
because you can grab-- if your team is
moving to Control Rig, knowing that you can use
previous assets that you've created, previous animations,
and potentially bring them across is really good. So animation mirroring
is another one that popped up with UE5,
which allows you to set up a mirror table and then play your things
on the left or the right. Again, this is really useful
because if we have something, like let's just say you
wanted to add left handedness, and all of them are
right handed by default, or let's say you
have some cool sprint animations in a leap that
always comes off of one foot, it's really nice to know
that you have options there. While we're on the
animation subject, because I guess I'm
on that train now, you know how often
you save variables out in an event graph for
animation Blueprints? Be aware that you can
create an arbitrary function and inside that function,
if you make the return value, which is what I'm doing here,
called Return Value, and you make this function
do whatever you need to, in this case, it's accessing
third person characters, and I'm making it const-- there I go. Making it const. This function, and I know
that was a couple of steps. But this function is now something that we can query
inside of the animation. So back in this animation
here, I'm now able to go grab this pin and say, I want you to run the get third
person character function. And then I'm able to go down
and get the movement component. And I can just check if is falling is happening without
having to create-- raise your hand if you've
created an animation Blueprint before. All right. Now keep your hand up if
you had to add 50 variables at the start of that
that you were kind of regretting the whole time. Yeah, notice not a
single hand went down. So it's nice having
some functionality like this, which just kind of
cleans up some of that stuff. Cube Grid is honestly
one of my favorite things that was added in five. It's a bit of a strange one. It's a modeling tool. But if you go down to the tool
that is labeled as Cube Gr, then you can go ahead and do this. It's really nice. You can just use Control click
to kind of extrude sections, create corners, pull things
out, et cetera, et cetera. And when you click the Complete
button that's awkwardly included in this GIF,
it will then go ahead and save it out so that Lumen will kick in. So you can see that I did that. And we've now got a
nice little asset. This is really,
really great for prototyping. Again, I see a lot of people
kind of weirdly scaling different cubes and stuff
within their environment sometimes where Cube Grid would just be much nicer for simple
effective block outs of things. Fix pivot tool is another one. How frequently have you been
given a model and the pivot is in the wrong spot? You can just click on the model,
then go to the Pivot tool, and just be like,
put this in the bottom center. The thing that we all want. And it'll do it. Pivot. Done. Geometry Script is a fun one. In this situation,
I did something rather simple. Geometry Script here is just
running a simple Boolean so that I can stick a fan on objects and it will automatically
create a version of that object with a hole in it. And what I'm doing is
I've created a cylinder. And we're just Booleaning
that cylinder against whatever object I'm sticking it on. But I want to point out
that that was really only just a couple of nodes. That was really quite
quick to put together. So just be aware that
this functionality exists. It's really effective. And you can create
some interesting tools. I wanted to flag this because
people have seen this in Lyra and they've been like,
that's a Lyra thing. And I just want to be like,
it's an everyone thing. And it's surprisingly easy. So if you feel like you
have some easy low hanging fruit for potential Geo Script
stuff, please by all means, get on it. Now the next one I want to touch on is texture baking because
again, texture baking is one of those things
that people are like, guess I need to do that
in an external package. But it is worth noting
that you can bake out curvature, normals,
bent normals, and more, which I put in bold, in engine. And all you need to do is
go to the modeling tools and go to the baking. Now a really, really, really,
probably too many reallies, but cool aspect of
that is that you can bake this stuff to textures. But you can also bake
it to vertex data. So if you want to
bake out the curvature to say the red channel
of all of your meshes, you can now access curvature
in any of your materials. Right? And the reason that's really good is if you look at your average
Nanite mesh, well, not average, but let's grab a Nanite
mesh as an example. They have really dense verts, right? And quite frequently,
we're pulling in textures that are quite large. So if you're looking at
Nanite meshes and you're like, I love that fidelity,
but I don't necessarily want to have really bespoke
baked out textures for all of these things,
you can do things like access the curvature to do some
kind of organic blends to maybe automatically bring
rust and stuff like that into these meshes and share texture sets between some of those
meshes, which means you kind of get a best
of both worlds situation where you end up with a
really high fidelity mesh but you also end up with your
texture reuse staying pretty much in check,
and overall quite often, a pretty good size for the
overall asset set that's being used, which is really good. So yeah. Vertex colors. My one thing that I
want to flag there is please try and keep
that pipeline in mind from an early point
in your production if you can just so
that you know ahead of time that red channels,
green channels, and blue channels are all going to be allocated
to specific kinds of things. Otherwise you can kind of
end up in a messy thing pretty quickly because the
artists are doing their thing and other artists are
doing another thing. So if you have a look at an effect and you're like,
that's too expensive, I can't use that on
mobile, just be aware that Niagara has a
Baker built into it. You can actually generate flipbooks from Niagara,
which is a really useful feature. And this is good as
well for things like, if you-- maybe it's
just a distant LOD. And maybe it's not even
for low end platforms. Maybe you just in the distance
want to have an explosion. But in this situation,
yeah, I just baked it out as a rather simple flipbook. And it's there. It's one of those things that's
weirdly invisible until someone points it out. And you're like, there is a button that says Baker that's been in
front of me this whole time. So I can see a bunch
of you are like, huh. So just be aware of that one. This is another great
one because this is what you expect particles
to do in Sequencer. And they don't by default, right? You know when you play
an effect in Sequencer and it's triggering an event? That really surprised him. So what happens is it's
playing the effects normally, but if you go ahead and
add a life cycle track down the bottom and then you
go to the properties, and you set this section
down here to say, Age Update Mode is Desired
Age, Sequencer will now control the point of time that that effect is at. And if the effect has been
set up for determinism, it's going to go ahead and it'll
scrub forward and scrub back, which is just really,
really great when you're doing any animation work, or cut
scenes, or anything like that. And you really want to
know that everything is exactly where it should be. This is a cool one. If you-- you have to enable this. But if you enable the
Chaos cache manager, you can go ahead and record with
that button down at the bottom, you can record Chaos
things that have occurred. So explosions,
and things that have collapsed. And you can play them
forward, but you can also then go ahead and do some
fun stuff because you can play them backwards. So in this case,
we're unexploding the barrels. But if you create something
like this in the scene, I could maybe make an effect that makes it look like a
wizard did it and unexplode a bridge that's fallen
down, or some rafters that have collapsed,
or whatever else it may be. So I just want people to be
aware that the Chaos cache manager is pretty cool. People kind of think of it as
like, well, why would I want to blow it up when I can just custom blow it up? And sometimes really tailoring what that effect looks like is fun. This is a good one and
the only audio slide that I have going on here. But if you get two effects,
I have music and wind playing at the same time-- [MUSIC PLAYING] And you type in this
command followed by a word, it will only play sounds
with that word in it. If I typed in wind,
everything else stopped. I type in music-- [MUSIC PLAYING] The wind has stopped. OK. And if you type in the
command again and hit Enter, everything plays again. All right? Because again, if you're trying
to debug footsteps or something like that, it's really nice to
just be like, please, engine, give me only footsteps. The next one I wanted to cover here is placeable volumetric fog. This is something I
really, really love. But again, it's one of those things that folks are aware of
volumetric fog in the engine, but they're often not aware
of the placeable variety. And what happens is if you
create a material in the fog domain, you can go ahead and you can drop a sphere inside the world. And when you do,
you can apply that material to it. Excuse me. And when you do,
you can now see that we have volumetric fog
that's placeable in very specific locations. And you can go ahead
and add panning to it. And you can move it around
and do whatever you need to. But see how that lets us
really kind of customize the mood in that room? It's a good feeling. There's a couple of caveats to it. But before I get into them,
actually one other thing I wanted to show you is that
again, these effects can be set up for movement. So if you look at this one,
you can see it a little bit better. I think I did more in this slide. We'll give it just a moment. So see how that fog is
kind of gently moving? I swear, I made this bigger. OK, yeah. It's a bit easier to see there now that there's darkness
in the background. But see? You kind of get that
gentle wisps going up. It brings a lot of
life to the scene. And it's pretty easy to do. A couple of things. Just make sure that you've made
your material in the volume domain. And you've gone ahead and you've
enabled exponential height fog, but you've turned volumetric fog
on in your exponential height fog actor. A thing that is a bit of a gotcha is you still need to have
a value greater than zero in your exponential height fog. It can't be turned off and
then only have volumetric fog in the scene. You need to have a
value that is greater than zero, even if it is 0.001. Just make sure that's set up. And for anyone here that's like,
yeah, but how did you do it? This is the material graph that I used to create that
effect that you just saw. I just made sure that it was
additive and in the volume domain. And in this case,
I'm using a volume texture to kind of create some of
the noise around the edges. If you want to see more
on this specific thing, you can check out my
Unreal Engine 5 guided tour video that's sitting on the
developer community online. And we have a node graph
that you can just copy paste straight into your thing. The next one I want to
touch on was named reroutes in the Material Editor. You can right click on reroute nodes and say Create A Named Reroute. And it will do this. And you can tinker with
them and change them around. And you can add new ones. But a cool thing that a lot of
folks are unaware of exists now is if you feel like, no. I hate named reroutes now,
you can right click on them and you can collapse
them back to a reroute. So if you're-- sometimes,
you're actually just doing it for a while. You're working on something. Or maybe you want it to
permanently look like that. But I want people to
just be aware of that. Now that's 35. But again,
I kind of just kept going. So since we have time, by the
way, if anyone is wondering why I haven't tweeted any tips and
tricks for the last two months, it's because I've
basically been like, I'll put it in the presentation. So that's why. But since we still have time, let's go ahead and hit up some other
things that are worth flagging. Common Conversation is
an experimental framework that sits inside of UE5. It snuck in there. It's worth checking out because it's an experimental framework for
building conversation trees. Again, it's really cool to
kind of have this set up. It's the fundamentals
for things such as-- sorry. Start again. Fundamentals of these things. So it's your graph setup, you can add tasks, side
effects, and conditions to each of these things. There's some support for
networking and replication. I'll level with you. I haven't had a chance to
really attack this yet. It's more of, I opened it up
so that it was there, started tinkering with it, asked an
engineer who was like, yeah, it's there. And then kind of-- you know
that hanging silence afterwards? So again, for something like
this, it's experimental. However, even if it's experimental, one of the wonderful
things about UE5 is you can open our source code. So even if you're looking
at writing your own, it's still really lovely
to look at something that Epic has done. And even if you're
like, I'm not sure if that's still going to be
there, or what's going on, the thing that I always stress here is it's really great to copy
someone else's homework. So if you can go ahead and
look at that thing and be like, OK, it'll make your life
easier building your own that may have your own conditions. Niagara GBuffer access
is another thing that a lot of folks missed
out on but I really love. So in Niagara,
you can sample the GBuffer. And a cool thing of that is
you can say to Niagara, hey, what color is the pixel
behind the particle that I'm about to spawn? And it'll be like, it's red. And there's this much roughness. And then you can go ahead
and sample that information and throw that onto a particle. So it's actually
really easy to create some pretty crazy Niagara
effects where you sample the entire view of the world,
throw particles on them, and then dissolve
everything into it. You can create some really
cool screen space effects that are sampling the world. And I don't know. I love it. But I haven't found a
cool enough demo yet for me to be like,
this is the exact use case. But I have used it
before on some things like dirt and grime. So whenever I had
dirt, kind of like dust coming off of the ceiling,
I sampled the original color of the area that the
particle was spawning. And instead of blending
just the transparency out, I actually blended the color
out as well into the dust effect that I eventually wanted to
kind of create some slightly better visuals on that front. Another thing you can do there
is, again, if you want dust blowing
across the ground, just sample that initial thing. And you can kind of create
something, a bit more finer grain that feels like it belongs. Sequencer Player Camera Blends. This is something that
a lot of folks miss. And it's really fair. I understand why. There's-- the thing that
everyone misses is top corner of this. So in this scene,
I've put a trigger in there. And I've got a
sequence with a camera. Now, the camera is moving around. And I go to the director track. And I'm setting this
up to Can Blend. And if you grab that very right
hand corner and very left hand corner, you can actually extend
it to create this blend track. Do you see that? Now if you have no previous camera, you know what this does? It blends from the player
camera into the cinematic, and then it blends out
of the cinematic back into the player camera. There's a person over
here that was just like-- at the person next to them. So I can only assume that one of
you built it for the other one. My apologies. So like I said, it's kind of --
it's a little bit tucked away because you have to really
grab that top right corner. See this little white pixel? No, see this triangle
in the top corner? You've just got to grab
that and pull it out. But yeah,
blending in and blending out, it means you can get
some really cool effects. If you want to have it as the
player steps through a doorway, and even if it's a first person
game, you can do some fun here. Because as the player
steps through a doorway, you can suddenly just seize
the control of their camera, do some cool looking
cinematics like they're getting attacked by someone
and pushed out a window or whatever. And then as they land
again, you just, you've already moved the
player over to that, and you kind of blend
the camera back in again. And you can have some nice
kind of seamless effects if you're really quick
and careful with it. But again, I've seen quite a few
developers build this feature. And when I tell them
that it's right click and then move the thing, they're
like, no one saw that triangle. And I'm like, sorry. So I want to flag this one. It's pre-skinned local
position bounds and normal. And I've got a vertex
interpolated node in there,
which you will need to do it. What happens is this. The screen doesn't
really do this justice. So you're going to have to
look at my hand gestures as I explain this one. But generally what happens is when you have a projection
in world space, so you're doing a world
aligned texture, what happens is that texture is,
it looks like it's projected from a projector. And as you move,
the stuff moves with you. Everyone still with me? Now you can do some really
simple transform math to keep projecting
in the actor's space. But the problem is if I
want to dissolve a person, we had [INAUDIBLE] outside
of a game dev conference. But if I want to dissolve a person and they're moving their arms, you know when someone's
arms get in the way? Just but if I'm dissolving a person, VFX wise,
and they're moving their arms, that creates a real problem for me. This is getting worse. So what happens is
as they're moving, the coordinates are going
to be moving around as well. And you're going to get
that weird jump back. Now what's really cool
is what these nodes do, the pre-skin local position
bounds and normals, is it grabs that information as
if they were in their T-pose. And because it grabs
it in their T-pose when you're dissolving
them, the sphere mask that you use to dissolve
them, or in this case, I'm just applying camouflage. So really, really bright camouflage. But in this case,
I'm applying noise to them. But notice as they move
around, that noise isn't shifting either. Do you see that? So that's because I'm grabbing
that information from basically their T-pose state,
projecting it over there, and then I'm carrying that through. So again, this is really,
really good for effects. And a common thing that
I see in video games is the person gets destroyed,
or disintegrated, or whatever, and then as they collapse,
I watch their foot disintegrate and then undisintegrate
for a second. And I'm like, you-- All of a sudden, I find myself
on Twitter being like, hey, use this. So just be aware that that's there and everyone is happier for it. Screen space transforms,
just be aware that if you grab the center of
the dot, it's in screen space. I know that's silly. But again,
a lot of folks are unaware of it. Cool thing you can do in
Unreal that's off by default is in the viewport
look and feel section, you can enable
rotational screen space. So that kind of gives
you this circular thing around the widget. And now wherever you
are, you can just rotate relative to your camera. It's nice. It's there. It's easy to work with. Statistics viewer. This is a little bit different when it comes to having Nanite
meshes in your scene. But it is still an
early thing to flag. Is just if you look at your scene and you want to quickly just get
some information about what's there, just be aware that you can use the Statistics view to
really quickly just be like, oh, OK. There are some really high textures being used in this scene. And I was not aware of that. It happens pretty frequently. And it's a very easy
first port of call when you're trying to check
out your texture memory and things like that. So I wanted to flag it. Now obviously, the next port of call is generally GPU capture
stuff when you start doing things like profile GPU. Now this is an awkward one. But how it works is this. If you-- there's a
series of commands you can do that allows you to
capture a GPU information that shows you on a per material level. But it used to be this-- it's like five commands
that you're setting up to disable RHI thread and such. And it's a bit of a pain. But we actually set up a
thing, which is if you type in
'r.rhisetgpucaptureoptions 1', and then do your capture, this will now give you a per material
cost as you scroll through. Now I made the mistake
of capturing this on a machine with a 3090 in it. So everything is like,
it's pretty much 0.0. But you can still see some
of these values are non-zero. So that's just kind
of a useful little tip to know about, that if you
type in that specific command, you can get it. So again,
I thought this was going to repeat. So I'm going to just do that. So the command for any
folks that wanted it is here, which is
r.rhisetgpucaptureoptions. It's a useful little one. Just make sure that when you're
done with your profiling, you've set it back to zero. It gives you a bit more information. Procedural foliage
is a little tucked away because it's in the editor
options, not in a plugin. So you need to enable
this on your editor. But how it works is you can
get your procedure foliage volume by just dropping
that into the world, expanding it to the size you want, and creating a foliage spawner,
which really just says, what foliage do you want? You can set up rules
and guidelines that say, how much foliage should
be put into the world? And whether things can grow in
the shade, how many seeds they distribute, what the
average distance of the seed distribution is,
and what their collision is like. And a cool thing is that
when you bake this out and you click that simulate button, what it goes ahead and
does is it creates it as regular foliage. And the advantage of that
is you can now erase stuff and add stuff without-- it just kind of does the
boring stuff at the start. And the other thing
that's really cool is if you get those variables right, often they look better
than what I painted in in the first place. And the reason for that is
because they're spreading by, hey, this one spread these
seeds, which created these ones, and whatever else. You end up with really nice
natural looking patches, which I really love. And yeah, it's a really
just good starting point that saves you a ton of time. So just be aware that it exists. And when you are done with it, you can just get rid of the
procedural foliage stuff and just treat it like
regular foliage, which I think is great. Camera locked movement. Some folks are unaware of this one. Just if you hold down
Shift while dragging, the camera sticks to it. Again, I know this has been
in Unreal for a long time. But too frequently, I do that. Or I watch someone do that
classic drag, move the camera, drag, move the camera, and then
while I'm sitting behind them. I'm like, do I tell them? So-- Because of that, it's a good
idea to just be aware of it. Another one that I
use pretty frequently is environmental bookmarks. So if I hit 1 at that starting
position, sorry, Ctrl+1 and then Ctrl+2,
I can then use 1 and 2 to just flip between
those two positions. I can do the same thing
over here with Ctrl+3. And now I have 1, 2, and 3. And I can really easily just toggle between all of those positions
that are in the environment. Now one thing I want
to flag with this is that one of the first things
I do whenever someone is-- makes the mistake of letting me open their level is I
actually just kind of hit 1, 2, 3, 4, 5, 6, 7, 8,
9 and 0 because that actually generally shows me what was
important to that artist when they were making the scene
because they've kind of created these little-- this is the control room,
and this is a tower, and this is whatever I've got. And it's actually a really
nice way to kind of quickly blitz between them. And every now and
then, you'll discover that all of the bookmarks
are in weird spots. And you're like,
someone else did something. And you've built over the top of it. And they're like, yeah. And they're like, how'd you know? And you're like, well,
I'm teleporting inside of your mountain and et
cetera, et cetera. So just be aware of that one. So it's Ctrl-- so I should have had some stuff on the screen. Next one is nice. This is the shadow pass switch. So let's say I'm
putting a light inside of this branded light globe,
which are not official swag, you can use a node called
the Shadow Pass Switch. And what it does is it says, hey, when I'm rendering the shadow,
this is what I want you to do. But when I'm rendering you,
this is what I want you to do. And now you can see
we're still getting the shadow on the bottom
of that light globe. But notice that we're
no longer casting that "you" shadow that we see
here, or unwanted shadow, if you will. And it is really just one node. This is really,
really good as well on-- if you ever do an effect
where you have a camera that's moving through a wall
or dithering out a gate or something like that,
like you have a chase camera and you're dithering stuff
out as your camera moves through it, you know what
I'm talking about there? Yeah. So shadow pass is really good
for you to be like, look. I want the view to dither,
but I want the camera to-- sorry, the shadows to always
stay as if the dithering never occurred. Because again, another thing
that you see quite often on people that have got the
dithering for the camera is all of a sudden,
they get some weird shadow action happening because
they're disappearing too. So I just wanted to
flag it with everyone. MoveComponentTo node. I like this because it's a really simple
little async Blueprint function. So I'm doing an attach. And then-- that was way too quick. But hopefully, that-- yeah. I put a slow motion on it. So what actually happens here
is, as-- in this situation, it's
saying, move the component over the course of 0.5 seconds to 0,0,0. And because I've attached it,
it's just moving up to her hand because I had attached
it to her hand. It's a really,
really simple little node. But I'll tell you what. If you're making a VR experience, I personally really
love this because it's just when you pick
something up in VR, instead of it just like popping
into their hand, that quarter second, half a second of it going, whew, that was louder than
expected, into your hand is a really good-- it just feels-- it
just feels better. It feels like what you expected
it to do instead of like, bam. You have weapons now. So MoveComponentTo is
a useful little one. I love it in prototyping. Yeah. So Simulation Stages are
a feature within Niagara that a lot of folks are unaware of. I wanted to flag this with
people because essentially, what it lets you do is
iterate over different data inside of Niagara. So instead of just running
your spawn and your tick, you can go ahead and you can
say, hey, I want to go ahead and
iterate over every particle and do this to them. Or I want to iterate over every
section of a render target to do something based on
all of that information. Now another really cool thing
about this is that Niagara, and this is especially true-- this is something you
do through Simulation Stages is that Niagara doesn't
need to output particles. What's really great
about that is you can run a Niagara system that's
actually outputting to a render target through Simulation Stages
because you iterate through all of the bits of a render
target and you're like, you get a pixel, you get a pixel. And set it up to
whatever you want to do. Now what's really
great about that is it means that if you're
kind of tinkering around, this is something I threw
together in about 15 minutes. And what it actually is, is I just literally fed a
Niagara render target, which you can see in
the bottom corner there. So it's just generating that. And I'm just feeding that render
target into the cloud system. So it's a really,
really quick thing to do. Because the cloud
system already exists. We have that. That is a thing. And when I'm kind of grabbing
that cloud information, and instead of just
using a regular texture, I'm just kind of piping
the render target that we're getting into there. If you want to do this
yourself by the way, just look at the Content
Examples project that we have. And check out the
advanced Niagara room. And there is a nice
advecting Niagara setup, which is a really
good example for you to just kind of hit with a hammer and do your own thing to. But I wanted folks be aware of it because, again, it's just there's some really advanced
effects like I've seen similar effects
like this getting a gross number of
retweets on Twitter. And every time, I'd be like,
it's just a Simulation Stage. And I want everyone to know
that they can do it too. It's accessible. So fun times. Here we go. This is the simple like,
my boss is coming mode. Hit Shift+F11 and it
will hide your taskbar. I'm just flagging with the
world because quite often when I'm saving videos
out, or saving GIFs, I find it really useful to
just go ahead and say, hey, for this information, I want to-- I just don't want the
taskbar down there. There's no purpose
to that being around. Next up,
I have collapsing and expanding Blueprint material nodes. Don't do this instead of functions. But it is nice to have
for certain situations where it's like one time use. So I collapsed all those
nodes to a subgraph. But I want to flag that
you can then right click and you can expand them
back to where they were. So if you do have Blueprint logic, that's really just a one time thing. Sometimes, it's nice to just
kind of get that and say, I want you to just
be one single node. And finally,
we have press K to keep location after physics. So all of these
kayaks have physics on them. And if I select all of those
kayaks, and I press K on them, K for keep, what it will actually do when I stop simulating is
keep them all where they were. So if you want to make
a reasonably organic looking mess, this is a really
good way to go about it. And just make sure you
turn off Simulate Physics when you're done. Otherwise,
they're going to keep simulating. So with that,
that brings me to the end. We have 30 seconds left. So nailed it. Thank you very much for coming. I hope this has been useful. And I hope to see you around
the rest of Unreal Fest.
