>>Luis: In case
you're not aware, the Quixel ecosystem
set of tools is freely available to
anyone with an Epic ID. This is especially good news
for students and educators looking to integrate new
tools into their classroom. If you go to the
Quixel YouTube channel, you will find a new playlist
called Mixer Fundamentals. This is a great set
of videos ranging in length between two
minutes and eight minutes. This is a great set of
videos that take you through a great
many of the tools inside of Mixer, including
things like gradient, position, curvature, normals,
projection modifiers, pattern components, noise
components, and many more. This is a great
way to learn Mixer and to integrate
photorealistic textures into your unreal
engine projects. You'll be able to utilize
the entire Megascans Library, as well as paint
directly on 3D models. If you're looking
for amazing new tools to integrate into
your curriculum for your next
academic term, this would be a great place to
start learning Quixel Mixer. Once again, it's free-- freely available to
all your students and a great amazing
tool to utilize a massive library
of not only textures but also 3D assets that
are photogrammically scanned at the highest
level of quality. We've also recently released
a beautifully developed PDF called Creators
Field Guide to Emerging Careers in Interactive 3D. The purpose of this guide
is to serve as a field guide to emerging careers and
skills in interactive 3D and a road map for students,
administrators, educators, and job seekers that covers
the entry level Unreal Engine skills needed to
join the workforce. It's designed to
help people start their journeys with Unreal
Engine and interactive 3D. This guide will
help advise teachers where to begin
teaching Unreal Engine and which competencies
to focus on. It'll help introduce
students to emerging careers in interactive 3D and the
skills those careers require, armed job seekers with a
roadmap to share their knowledge in interviews and as they
start their career journey, and also to illustrate
to hiring managers what Unreal Engine knowledge
new recruits need to have, and to prepare
administrators to understand the demands and skills
across those industries. As you can see, it's a
beautifully developed document. And if you want more
information about this guide or to want to learn
where to download it, just go over to
unrealengine.com News, where you will find a blog that
shares all this information, as well as the download links
where you can get the guide. Hello and welcome to
this week's stream. >>Tom: Hello everybody. >>Mark: Hello. >>Tom: Happy Friday! >>Luis: Happy Friday! You know, I think
we're in trouble guys. We're waiting for
this week's guest, and I don't know
where the guest is. Oh, wait a minute. It's right there. It's Tom Shannon. He's the guest. >>Tom: Oh, why
didn't you tell me? >>Luis: Did you know
you're going to present today? >>Tom: I'm always
ready to present. You just point the
camera and say, Unreal. >>Luis: Yes, well-- >>Tom: I've got something. >>Luis: Luckily,
that's the case. No, actually, very well prepared
today for Tom to be presenting. And today's a really
exciting stream. Today we're going to be talking
about technical art, which is very exciting topic. And maybe you can
see here in the title that Tom is a technical artist. And he's the technical artist
in the educational department, which is really exciting because
we've been working together. And we've been having a lot
of really amazing streams on Fridays, and
we've really been enjoying doing these streams. Last week we had the
secondary stream and the week before that or couple
weeks before that, we had Matt Workman in to
talk about virtual production. And we've really been sort of
excited about getting back also to doing more of an
in-engine focused stream. And one of the
things that we end up talking a lot about when we
travel around to do lectures at schools and
whatever the case is is really about technical art. And I think that Unreal
Engine is an amazing vehicle for technical art, but maybe,
Tom, can you tell us a little bit about what technical art
is and just sort of expand on that because I think that-- >>Tom: I was hoping you
could tell me what tech art is. >>Luis: It's
not in my title-- >>Tom: It's kind
of funny because when two tech artists
meet each other, they say, what do you do? I'm a tech artists. Oh, you're a tech artist too. Me too. And then we say,
so what do you do? Tech artists have
really kind of-- it's almost at the
point where it's like, I'm a game developer. It doesn't-- It used to be kind of a very
specific sort of a role that sat between
programmers and artists to help kind of build tools and
solve these kind of problems. But as games get more
complex, the space between artists and
programmers grows and grows. And there is all this
kind of in-between stuff that's not all programming
and it's not all art. But it's like kind of got
to have an eye for art, but the patience and the mind
for the program and the ability to kind of talk computers. And that's where us
tech artists sit, and so we're like there's
animator-y tech artists. There's pipeline tech artists. There's material and lighting
tech artists, audio tech artists, article tech artist. And different studios call
them different things. I've got a studio where
I am a tech artist, and all I did was
particle effects. And I'm like, am
I the VFX artist? No, no, but I'm touching math,
and materials, and lighting and all of that stuff,
but so kind of particle effects around that. So it's really fluid. So I guess my brand
of tech art is writing materials, and
Blueprints, and building tools. So that's kind of
where I started was in solving pipeline problems. >>Mark: I've seen people
come from both directions. Some people coming from
the programming end back into sort of
being tech artists. Another people coming from
the art end into tech art. I think both are a really
valid ways of doing this. >>Tom: Yeah, yeah, I
think a lot of us kind of we were going down one
path when we started. I went to school to
get a degree in art , and along the way I
learned some Flash stuff. And that just kind
of stuck with me, and I still wanted
to do game art. I'm just like, I
wanted to do game art. Low poly modeling is
what I want to do. And then I started
working in production. And I really disliked a
lot of the tedious stuff that we had to do. And also, there
were things that we were doing that we were like
doing guess work on and doing these really kind of
difficult kinds of ways to figure out how to
make this thing go along a spline at a certain speed. And artists had
calculators where they were figuring
out like, I move at this many frames
over this time. And I think it's
70 miles an hour. And they don't know their
math and so it was always wrong. It sounds like,
wouldn't it be nice if they could just type
in 70 and the thing would go along just flying at 70. >>Luis: So you
make life better. You make life for
artists, and designers, and programmers in many ways. >>Tom: And
the product would be better because we could say-- >>Luis: And the
product would be better. >>Tom: It is
moving at 70 exactly, and I can prove it, which you're
doing visualization, Mark. You know this that there's
a lot of questions about-- is that really the
data I gave you? >>Luis: So before we
get super deep into what it's going to be, I think, a really
exciting stream this week, let's say hello again to our
good friend, Mark Flanagan. >>Tom: Hey there, Mark. >>Luis: So Mark
had a very long history in visual effects and film. He came from--
you've worked at ILM. You've worked at DMAG. You've worked in a variety
of different film effects companies. >>Mark: Games companies. >>Luis: You've taught
and trained countless visual effects artists, and
technical directors, and technical artists
of various kinds, and RenderMan, and many, many
different tools before we stole you away to
come help us here in the educational
world of Unreal Engine. So it's great to have Mark. He's been with us
since the beginning of these educational
streams, and it's always great to have his
insight as usual. >>Mark: Very long
history is a very nice way of saying I'm old. [LAUGHTER] But, yeah, look, I've always
had a passion for technology from the very beginning of
being involved in 3D as well. Not to the same extent
as Tom, but because I came from architecture. And I honestly have
a strong belief that most art forms have both
a technical and artistic part of them. So architecture-- and Tom's
come from that background as well to an extent. It is a blend of
art and science. And art and science of always
being mixed like Leonardo da Vinci was a scientist. >>Luis: A
technical artist. >>Mark: He was
technical, and he was artistic. Separating the two, to
my mind, makes no sense. >>Luis: Yeah, absolutely. >>Tom: Absolutely. Yeah, especially
now that artists are using technical tools. I think that's a great point. Even chiseling out of-- I can't just go
chisel some marble. I don't have the
technical side of it. Even if in my head, I
can imagine the shape that I want that
marble to be, I'm going to have to
work on the tech side of my art for a while. And that's, I think
this is really important because, like you
said, you're not-- you wouldn't consider
yourself a tech artist. But you've done tech art. I consider myself a tech
artist because that's really what I enjoy doing. But I think, really, it's key
for students and educators to understand right
now that having that technical knowledge, even
if you're not a tech artist, is so key. And you probably do
it kind of naturally. You're learning software. But that-- and it's really I
think the mindset of problem solving and wanting to find
a better way to do your art. And like you said,
Mark, some people like me go fully into
that and others just have to have that to
help them with their art, so that they don't
have to face so many frustrations and can kind
of self-serve us a bit. >>Mark: Yeah, I think
one of the big things that's important today is to
realize you don't have to be a full-on programmer
to do these things, and you don't need to be
a mathematical genius. Just a little bit thinking
and maybe a little bit of high school
maths occasionally, but it's not--
and a lot of will. >>Tom: Right, you're
not a graphics programmer. I had to figure out
like speed conversions, and I did have to learn what a
tangent and apply normal are, but that was-- it took a couple of years
but I finally got it. Pay attention to
math class, kids. They say that you're going
to use it in the future, and they're right. And I wish I had spent
a little more time in an advanced
algebra and geometry. But even though I didn't really
go that way in high school and college and I know as much
math as I need in the stuff that I'm going to
show today I think has almost now I think I'm going
to use a multiply node at one point. And so I guess this kind of
brings us to what we're-- >>Luis: Yeah,
just one second. Before we get into that stuff,
for those of you who don't know me, I'm Luis Cataldi. I've been working
with education team here for a long time at Epic. I also have a
technical background. I came from the film industry. I was also a technical
artist of sorts. I was a rigger at
Blue Sky Studios, and also applied it in
a very different way. I built characters. I assembled characters
and made them work for the animation team. And that has also a
lot of math to do, so this applies
itself in many ways. And one of the things I wanted
to bring up, which I think is really relevant
to the discussion here, if you are
teaching students, if you are preparing
curriculum maybe for the next academic
term, or maybe if you're a student you're not
really sure which path to head, as Unreal Engine
grows and expands, more and more of these
types of disciplines are coming into
the engine, right? Like in 4.25, the
rigging tools have really evolved quite a bit. And so now more and
more people can actually rig inside of Unreal Engine. Now you can do-- a lot more things you can
do, a lot more film functions in Unreal Engine. You can do even more
complex material work and build your
own material types in Unreal Engine, which
is a different type of technical art, right? You can do a variety
of different things that escalate your
abilities inside of a real time tool set
specifically since we expose all the source code. And exposing the
source code doesn't-- and Tom, I think, you'll be able
to speak much more of this-- doesn't mean that you have
to dig in and become a C++ programmer. But it means that you can find
out where the engine is open, and that you can go
in and say, well, oh, I see what it's doing here. Let me see how to leverage that. Because I think that's
where many tech artists are able to go in and see
what the engine is doing. And by seeing what
the engine is doing, they can see what they
want to do with it, right? And I think that's one of the
greatest abilities of a tech artists and you guys
mentioned it already-- is a problem solver. And so if you're an
educator on the stream, if you make YouTube videos,
if you're a student, what we need more of-- and Mark, and Tom,
and I have the benefit of being around the people
that come to Epic all the time saying, we
need more of x, right? And what many people
need more of constantly is problem solvers and real-time
problem solvers in the Engine. And a lot of those
add up to be some type of a technical artist, technical
design, or technical x, right? And that means somebody that can
solve problems in the Engine, make it run it, whether
it's 24 frames a second, whether it's 60 frames
a second, whether it's 120 frames a second, whether
it's 240 frames a second. And so a lot of that really adds
up to what is the Engine doing? How do I make it do what I need
it to do at this frame rate? And how do I make the client
happy at the frame rate they need? And by the time you've done that
a couple times, bingo bongo, you're a tech
artist in many ways. Am I right? >>Tom: Right,
and it depends on the studio you're at
whether you're going to get called a tech artist,
or you're going to get called a rigger or
tools programmer or whatever. And there's a lot of questions
in the chat here about, , like so how do we get
started as a tech artist? How do we help kids
become tech artists? And Mark posted a link
to a blog that we wrote about being a tech artist. So it will help dig into that
term a little more for you. But I think some of
the comments in there were we're really right on is
finding those students that are already kind of
filling in that gap. You'll have your students
that are excellent artists, and it's very clear. And there are students-- programmers. There's going to be these
students that kind of-- >>Luis: Make it work. >>Tom: Find their
way somewhere in between, and they want to solve problems. And they might be the
ones that are working on lots of teams and kind of
identifying where things aren't working or setting up Perforce
or doing these things that are related to game development
that aren't exactly art or aren't exactly programming,
aren't exactly design. They are that glue that kind
of sticks them all together. And that's why tech artists
are in such crazy high demand even if they're not posting
job postings for tech artists. If you go in and you're
a character artist who can do materials and
lighting, as well as excellent
characters, you're going to get the job over at
the other 22 people who do excellent characters. So it's a little more obvious
to be able to do that one thing. So it's that-- it helps
you become that unicorn. It helps you to be a unicorn. >>Mark: People
are behind you. >>Luis: People in the
chat said, oh, apparently, I've been one for years. And that happens a lot too. It's like, I didn't really
know I was a tech artist, but I've been solving
problems at my studio or in my advertising company or
my architecture firm for years in Unreal Engine or whatever. And yeah-- >>Tom: Yeah,
I didn't know I was a tech artist until I went
to GDC, and I met this guy. And he was like, oh, I think you
should come to this tech artist roundtable. And I was like, what is
a tech artist roundtable? And so I sat in this room,
and there was like 20 of us-- tech artists-- from wherever. That term didn't exist yet. And so we were all talking
about like, what are we? And in most of the
conversation was about, how do we sneak in tech art
in the production budget? Because we weren't supposed
to be programming or building tools. I was supposed to be building
cars and materialing them, instead of writing a tool
that'll do it for me. And so we'd have to kind
of break it to our leads. We'd have to-- hey, you know,
all those hours I spent? Well, I didn't do that thing. But I did this. >>Luis: So you remember
that comedian a while back. It was like you might
be a redneck gift. >>Tom: Right, yeah, you
might have missed that artist. >>Luis: I think we have
missed an opportunity that do have with tech art. There might be a tech artist. >>Mark: There is
another role as well, which some people may actually
find relevant themselves. In the film
industry, quite often you hear the term TD,
technical director, which is very, very close
to what a tech artist is in the games industry-- first cousin. >>Tom: Absolutely. And you know, and
that's absolutely kind of the career path. So I think most people, when
they start out typically, they don't know that there's
a lot of opening-- tech artist positions. I could be wrong. It's been a while
since I started, and I kind of grew
into the position. But it's kind of a position
you tend to grow into. And that's something
I would love to-- if schools can and students
can identify earlier, that that's what they want to
do, and schools can offer that, that'd be great. But I do really believe it's
kind of a discovered thing that you kind of figure
out as you figure out what kind of artist you are. It's-- >>Mark: It's very much-- >>Tom: It's the thing
that gives you that joy. >>Mark: First decision,
they're doing the thing. I'm having trouble
rigging this thing, and I've made it to
something to make it easier. And then I share with
everybody else in the company. And suddenly, I'm a tech artist. >>Luis: Well, I think
that it happens that way, right? I think that you'll
find these people that are resistant at first. They're like, I'm just an
artist, or I'm just a designer, and I just want to go in there
and make my thing prettier or make my thing-- prototype my thing. But then they find their
gateways, and I think, this is a good way to transition
into some of the gateways, right? They may go, well, I'd like
to be able to either build the material to make
this thing look great, or I'd like to
write the Blueprint to make this thing
do something, or I'd like to you know build
the particle systems or build the rig. And so there are a series
of gateways that help really expose people to the technical
aspect of the art, right? And so, it could be that
you start to really embrace the material system
in Unreal Engine, and that really
opens up your world. And you're like, wow, I can
do this, and I can do that, and I can do the other thing. And I was just doing this
brute force the hard way, and then I discovered
the materials system is super flexible. And I don't have to
do it the hard way. I can do it once
and propagate it to 1,000 objects or where you
discover Blueprints, right? And Blueprints just really
opens up your world. But it's going to be the focus
of the rest of today's stream where you discover the
effect system, where you discover the terrain system. You discover all
these other systems in the Engine that
take someone who says, I've labeled myself just an
artist or just the designer. And before you know
it, they're like, well, I could do this for the
next two weeks one at a time or I could do it once
for the next day or two. And then push a
button, and it's done, and I'm just going to go play
ping pong for the next three days, right? >>Mark:
One of the things, which I remember, one of
my favorite tech artists said that it may take me
three days to make this tool to do thing. It might take you 20
minutes to do once, but then I can use it
for the rest this week and get five months
worth of work done. >>Tom: So that was
literally the only way I got to keep doing tech art. It was by showing
that when I do this, we can save this
amount in the future, but it was still kind of like,
but it says on your business card 3D artist. So why do you need a
copy of Visual Studio? This doesn't work. Luis brought up something
that that's also a big part of the
role of tech artist. It's understanding the
technology that you're using and, oftentimes, helping
the rest of the team understand the
technology better. One of my favorite
jobs as a tech artist was getting new software. And I was kind of my job
to poke every button in it, and put our data into it,
and throw it in our pipeline, and try and see where it
breaks, see where it works, see where it doesn't, and then
go to the rest of the team, and just give them
an idea of like, push this button
when this happens. Never touch these things over
here, and give them guidance. didn't have you know 20 artists
all having to hit every button to figure out what
the right way was and coming up with
their own way. It was my responsibility
to figure that out. And then get everyone together
in a room and be like, this is how we're
going to do it. Now you don't have to
go through all of that. Because-- and a lot of
artists, they don't want to. Some people-- they don't want
to click it every button. But I'm like, I
don't understand it. It's just I love Unreal. It has so many buttons to it. I want to see what
each one does. So it's not always
about like programming or like mastering
materials or HLSL. It's very broad,
and it's, again, that's like filling in that gap. Like, oh, the artists
haven't really figured out this technical tool. I can do it and just
help them how to do it. That's-- so this is all-- these are things
that aren't like out of the book of game dev-- of what you're
going to be doing. There are kind of things
that you discover, and each studio and each
production within a studio will be very different. Like I said, sometimes, I
was being very technical. So I was just making particle
systems for six months. It's a very fluid, and it's
one of the reasons I really enjoy being a tech artist,
is that it is so fluid. And I get to solve lots of
different problems and work-- one week with audio folks and
one week with the programmers. Over here, wow, I'm
doing physics now. So with my ADD, it
helps a little bit that I don't get bored with
the thing I'm working on. I can help everyone though. It's really a great position. It's so much fun. >>Luis: Well, one of
the things that's really-- >>Tom: Obviously. >>Luis: --really awesome
is Tom and I when we were sitting at Epic-- working every day, we
sat next to each other. And we would build
sample projects, and we would build learning
material all the time. And I'd be really
proud of myself because I'd build this
really cool demo thing or whatever sample project
that we'd be working on. And I'd have the
Blueprint Editor open, and I'd be working on this
really cool Blueprint thing that was going to do whatever. I was really proud of
myself for getting into work until I'd run across something. And I was, like, hey, Tom. Because he's really good
at tech art and Blueprint, and he was always such
a really good resource for helping me to
understand and improving my skills at Blueprint. Then I'd look over at his
screen and his Blueprint was five times the size
of mine or whatever. I was doing 10 times more. And so he would humble me
very quickly because he's very skilled with these things. And so today we're
going to be focusing I think more on this
particular aspect because I'm not a
programmer per se. And I don't think you have
a traditional background in programming, but
Blueprint, in particular, inside of Unreal Engine
is extremely liberating. And I did a lot
of null scripting and some Python scripting
when I was rigging as well, and the ability to automate
tasks with these tools are super critical. And inside of Unreal
Engine, Blueprint is threaded throughout
the entire engine. And it's super
powerful, and it's very liberating to an
artist or a designer who wants to do things. Why don't you share
a little bit more of your depth and insight,
Tom, because you're much more of a master
than I am with Blueprint. And today, you're going
to be talking much more in depth about Blueprint >>Tom: Yeah, so what
we're going to be covering today is that kind of tool
side of tech art. So we're going to be taking
a look at Blueprints, and there's-- a thing that tech artists
do is build new tools and build new workflows
or improve workflows. And so Blueprints has
some functionality that's been added in the
later versions of Unreal now that really allow you to
do scripting in the engine to do stuff that in a
kind of pipeline format. And I'm really
used to doing this. It's like I did this
with, like you said, MEL scripting, and Max
scripting, and Python. And just kind of
automating things that we've got to
do all the time or making sure that
everyone on the team just has a button
that they can push, and it does it the right way. So make sure everyone's
naming everything right. Well, what if we just make a
button that names it for them and how everyone will
do it the right way. So sometimes the tools
are just about removing error or the artists
refused to name it the right way because
it's some weird code, and they're art
brains hate that. So I'll just give them a
button, and now they'll do it. So we're going to look at
a couple of things here. So there's a bunch
of ways in Unreal for us to make things
happen in the Editor before we press play. So typically when we're
talking Unreal and programming, we're talking
gameplay programming. So it's the stuff you do when
you press play, stuff happens. And that's not my
kind of programming. I can't do that programming. I've learned it, but
that's what I would call gameplay programming. In Unreal, that's in
Blueprints or C++. And just so folks
know, if you're new to Unreal in the
stream, Blueprints are a programming
language that were created by Epic Games
for Unreal Engine. So it lives totally
in the Editor. You can't edit them outside,
and there's no other application that uses Blueprints. It's just for Unreal. C++ is a programming language
that's much more famous its. General purpose
programming language that tons and tons of
applications are built on. It's really very high end,
kind of complex stuff. And I'm so glad that there's
Blueprints because I don't want to have to do C++ too much. [LAUGHS] I'll do
it when I have to, but it's not my happy place. So, yeah, Blueprints are a
visual scripting language built in. So with Blueprints
there's no code-- well, there's code
but there's no syntax. So you don't have to
worry about mistyping things, or colons missing,
or things formatted wrong. It's all graphical. And if you connect
the wire, it happens. So it removes a lot
of that complexity, and that's the art side of me. That's like, I
don't want to have to deal with all that,
the header file and all of that stuff. I want it quick. I want that instant
gratification, but I still want to be
able to do some code. So Blueprint compiles
instantly in the editor. There's no compiling times. There's no wait times. You don't even actually
have to hit compile. Sometimes you can just
hit the Play button, it compiles all of them,
and you're game starts. So they give you this
instant satisfaction, and so that's
gameplay programming. So we use C++, and
Blueprints, and Unreal Engine. And as far as gameplay
programming goes, they're essentially the same. You can do a little more
with C++, and they're faster. But you can do so much with
Blueprints, like, I don't know, 80-- 90% of stuff is
exposed in Blueprints. Yeah, so that's like
gameplay programming. We talk about it a lot. When you type in programming
in Unreal engine. It'll talk about
gameplay programming, and that's making
triggers do stuff, collecting coins, dumping stuff. So what in-editor programming
is or in-editor scripting is building tools and stuff
that run before you press play. So it's stuff
that'll act on stuff that's in your Content Browser. I want to do is rename stuff
in my Content Browser, move things in the content
or organize things, change properties. Or I want to select a bunch
of things that are in my level and do things to those
before I press play. So they're tools that help level
designers and artists build games. And so there's a bunch
of different ways to do this in Unreal. We've exposed a ton
of this functionality. So we've exposed it, I
guess, there's previously, we had some stuff that you
could do called commandlets. And nobody knows how to do that
except for three guys locked in the basement at Epic. We have to keep
them there, so they can make us more commandlets. And there are C++ applications
that like tie into the engine, and you have to
compile them out. So they're not for-- they're not for me. That's for sure. And then there's some-- you
could do some bad scripting and some Python stuff. But all of this
stuff had a problem, that it ran outside
the Editor on content. And then you'd break-- open
up the Editor and work. And so we didn't
really have a way of doing stuff in the Editor. So we've added some
functionality to Blueprints. We took Blueprints. We opened them up, and the
first thing we did was we created Utility Blueprints. We used to call it Blutilities. Now, they're Utility Blueprints. And they're Blueprints
where we can make code that does stuff in the Editor. And they're pretty
cool, and you'll see they show up in
your right-click menu, and they're there. And that was great, and you
could do tons of stuff with it. But there was a
limitation there that you couldn't do a lot of options. You can only do so much
with a right click. So what we did was we took those
utilities and all the stuff that they could do, and
we combine them with UMG. So instead of
making a Blueprint, you make a UMG widget that has
all of that editor scripting ability. And we've allowed that
UMG to run in the Editor, so when you run it, rather
than making a UI for your game, you make a little
panel in Unreal. So now you can actually make
panels and tools in Unreal with UMG and Blueprints. So all those panels and
stuff that you can dock, you can make your own now. And you can do it
all with Blueprints, and it's really amazing. So you can build
different types of tools. So we're going to walk
through that process and look at the
differences between those. So any other questions
before I dive in? >>Luis: There were
a couple of questions that popped through. Let's see. Let's see. There was a-- >>Tom: There's so many. They're moving so fast. >>Mark: They're
going really fast here, yes. >>Tom: Some of
them have been answered. We can make T-shirts. >>Mark:
Yep, make T-shirts. >>Tom: UMG thing, can
it be used by the Player? That's a great question. So this is-- these
tools that we're going to be looking at
are totally in Editor. So they are not for
the Player at all. They're for the people
making the game. And these UMG interfaces
as you'll see, they wouldn't be exposed. As you probably wouldn't want--
well, it depends on the game. You probably wouldn't
want your player deleting assets or stuff
like that, maybe-- depends on the game. >>Mark:
Question here about-- scattering foliage. That's something which--
we have built-in tools, but you can certainly expand
on them on Blueprints. >>Tom: Yeah, absolutely. I've built scattering
tools in Blueprints myself. Because sometimes
what we've built is an exactly what we needed. I needed something
that like, put a specific tree with a
specific kind of foliage that fell from it and-- >>Mark: An ecosystem. >>Tom: Yeah, it
was an ecosystem thing, and I built in Blueprint. And it was just a bunch of ray
casts, and choosing things, and adding them to instant
static mesh things. So we do have lots of tools
that are built in to do it. There's the foliage
materials system that are automatically
put foliage wherever a certain material is. There's the ecosystem tool. It's experimental. >>Mark: Yeah. >>Luis: Yeah,
it's very powerful. >>Tom: Have we use-- it's really powerful. >>Luis: Paolo did a
really nice video about it a couple weeks ago. Paolo is also the
evangelist from Brazil. Shout out, Paolo. Nice job. >>Tom: So,
yeah, so there's lots of ways to scatter
foliage in a Blueprint, and Editor tool would be
a great way of doing it. >>Luis: There
was a good suggestion that popped through about
Python and the difference between Python and Blueprint. This is, I think, a
really important question because Blueprint has its very
special place in the Engine, and Python has it's very
special place in Engine. Would you talk about
that a little bit? >>Tom: Absolutely. So what we're going to be
looking at today actually is where Python
lives in the Engine. So when you hear that Unreal
Engine has Python in it, unfortunately, it doesn't mean
that it's got a text-based programming language built into
the editor like C# or whatever. Our Python is entirely
in Editor tools. So Python is a text-based
programming language, and it's hugely popular in
production-- movie production, game production. And it's because it can build-- you can really easily build
cross platform tools with it. So you can make a Python script. You hit compile, and
it'll run on anything-- Mac, Linux, whatever with
a nice interface in it. And a lot of applications have
added Python Sports-- so Max, Maya. Everything's got
Python support now. So it's the programming
language of choice for when companies and studios
are building pipelines. Because it integrates
with everything and then integrates with Unreal now. And so almost everything
and maybe a little more even that I'm going
to show today, you can do in Python as well. So if you're already
really great with Python or your studio has someone
who's great with Python, these are the sorts of things
you can do with Python as well, and you can build these tools. And the cool thing
about Python is you could build a tool that
runs outside the Editor, that kicks open the Editor
runs, all this stuff and edits the Editor. So that's something you
can't do with Blueprints. So Python is maybe another
step up or if you already know, it just is that. So what we've done is for
Python just kind of all the Blueprint nodes, we provide
it as functions for Python. So in Python, you can just
do all the exact same thing. >>Luis: Let me
ask you a question before we get into it a little
deeper into the actual editor work. If I'm an instructor,
if I'm a teacher-- this is an educator
stream, and I'm teaching art or teaching game
development or teaching film. I'm not teaching
programming per se. Do I need to focus
on this stuff? Should I-- where do
I send my students? Should I find a way to teach
these kind of tools in my art class? Should I find a way
to teach these tools in my filmmaking class
or in my VR class or something like that? Is this something I need to
send them out to a programming instructor to learn? Or why teach them
this in an art class? Or why teach them
this in a design class or in a filmmaking
class or a VR class? >>Tom: That's
a great question, and I think it's a
pretty philosophical one. It's why I don't see a
lot of tech art programs because you may have
a cohort that year and not one of your students
really has that bent. And if you've got a cohort of
really talented art students, maybe it's not worth
spending that time to teach the deeper tools. However, , I think at least
making sure that when you do have those
technically-minded students, that you have some
plans for them. So that they have something
a little extra for them to do to use that, utilize
that technical kind of bent that they have. I think that working some
tech art into an art program, especially a game art program
or a film art these days, is probably essential. Whether you have to specifically
teach a programming language, like Python, I wouldn't do that. That's a lot. And that's one thing that maybe
Blueprints are really nice at, is you'll see that some of
the tools that I make here are going to be really
simple and really don't lean on a lot of like
heavy programming concepts like, we're going to look at
some loops and some really basic stuff. And it's nice because they
don't have to learn syntax, they just have to learn
a bit of the logic. And I think it's essential
for everyone on the team building interactive
applications, that they have an understanding
of the application. So even if they can't
really build the tool or there's someone better on
the team that for building the tool, they can
speak the language, and they can understand what
can be done and what can't. If you don't know
what you don't know, you won't even know to go
to the tool guy on the team. But if you know, oh, that
I bet tools can do that. Then you can lean on
those folks and make sure that they're building
a cool reusable tool. There's nothing worse
as a tech artist than like finding
out that one team over on the other
side of the building has been doing it their way. They're like a weird setup
and you're like, oh, no. But you didn't know it's so
easy over everywhere else. And your stuff
doesn't quite patch. >>Luis: Well, and
then we travel around and visit lots of
schools, and so it was kind of a setup question. Because what we discover
is that the teams that-- you don't have to
teach programming but exposing the students,
we find lots of art programs where the students will find
this stuff on their own. And they become that much more
effective in their capstone projects, in whatever they
do become that much better because somebody on the team-- it's an amazing girl or
some amazing guy just says, this is the way. This is the path, and
they just blossom. And their projects blossom
because they go that much further. And another thing I
wanted to point out is that not every
instructor out there has to become a Blueprint
expert in order to expose their students to this content. We have material on our
online learning platform on learn.unrealengine.com. And if you go to our learning
section for instructors, there's a whole course that
you can go and download. And there's teaching
material for teaching Blueprint and teaching-based
fundamentals of programming. Because, I think, a lot of
what you're going to show and a lot of what
you end up doing is just some basic fundamental-- Boolean statements, and
loops, and basic logic. And programming in
Blueprint is not crazy, heavy memory management. And-- >>Tom: No, it's
almost pure logic-- >>Luis: It's just logic. >>Tom: --for learning
programming concepts. It's great because it gets
rid of a lot of that overhead. Yes, so that's why I prefer
to use Blueprints over text. >>Luis: Just expose
them, just do it, right? Go for it. >>Tom: Yeah,
and I think that's it. Make sure that when
you have those-- have it in mind and
have something available for those students
and identify them. And help them
identify themselves, so that they can know, hey,
you might be a tech artist. You might want to
go down this path. And here's what you can do. >>Luis: We need
them right, mark? >>Mark: Absolutely. >>Tom: We need them. >>Mark: One of the things
as well, I think, for any tech artist is don't expect that
you're going to know everything straight off. You need to actually
know how to use the documents and search for
the things you're looking for. As most people I know
don't know exactly the name of every Blueprint
node they're going to use. But they need to know how to use
the documentation to find it. That's really a critical
part for any tech artists. >>Luis: And Mathew
Wadstein's website. >>Tom: [LAUGHS] >>Mark: Yeah,
yeah, that helps. >>Luis: There's a guy by
the name of Mathew Wadstein who has a YouTube channel. And he is systematically
going through Blueprint. >>Tom: All
the Blueprint nodes. >>Luis: And he's
going node by node and doing a little base
project with that node and explaining what it does. That's one great resource. And another story is a website
by our Brazilian friend, Marcus Romero-- Romero Blueprints. And there's three compendiums
that Marcus Romero has built. And they're absolutely amazing
because, once again, they give you contextual
examples of how to use many of the
Blueprint nodes and how they can
be paired together to assemble functionality,
once again, without having to write a single line of code. So those are-- if I had to give
two resources for just getting up to speed and sending
your students down the right path, Romero
Blueprints and Matthew Wadstein's content on
his YouTube channel. >>Tom: Shall I build
some tools to help people? >>Luis: That
would be lovely. >>Mark: Build something. >>Tom: All right. I am sharing a screen here. Are we all seeing an
editor shaking about? >>Luis: We are. >>Tom:
Excellent, excellent. All right, so let's see. Where should I start here? All right, so I'm going to talk. We're talking in-editor tools. So I'm going to start with
maybe an in-editor tool. If you've been
using Unreal, you've maybe used one of be these
or built one yourself. And that's called a
Construction Script. And so this is-- that's Content Browser. Here we go. A Construction Script is a
part of any Actor Blueprint. And I'm not going to build a
Construction Script in this one because that's not
what I'm focusing on. But the Construction
Script is a function in every Actor
Blueprint that we have that can run in the editor. So when you place an
Actor into the editor, this Construction Script runs. And I can run this logic
and do stuff in the editor before you hit Play. And this is really
cool because it lets you build kind
of procedural Actors that you can plop in. So in this case, it's a
really simple Blueprint. And all it does is it takes
a For loop, and it loops through it, and it
places a mesh in a line. And so the way it does this is
that we expose some parameters. So we create variables here. And then if you click on
this little eye, what it does is it tells on real
that the user is going to want to change this. We're going to expose
this to the editor. And so I'm not going to
dig into this right now, but I'll show you how it works. So as I place this in the level,
I can define a Static Mesh here. Let's do that. Column-- and there we go,
bigger than I thought. And then what I can do is
I can say, how far do I want them to be spaced? I'm going to have them
at, like, 900 units. And then how many do I want? I want five of them. And it's not going to work. [LAUGHS] All right, I'm going
to try a different one. Apparently, I found a broken-- the broken one. Perfect. Let me do a different one that's
a little more complicated, but I know it works. This one, instead of just
placing it along a line, this Actor has a
Spline built in. So it's got this
Spline component. What I can do is try and
select on this vertice. We can define a path-- I'll add a couple points too. Come around. What we can do is here are the
variables that I've exposed. So as I built this,
I expose these, so that they can be changed. Though I want a different Mesh. Let's do our column again. You can see what it's done
is it's taken that column, and it's placed it along
that mesh in an array. And I can change
the spacing, and I can randomize it, so that
it's got different directions. And at any point, I can
just modify the Spline, and it changes the array. This is a super cool tool
that was built in Unreal, and it's intended
to run in the game. And then when we press
play, our columns are just there as if
they were always there. So this is the kind of
tool that it's really cool. It's a Construction
Script tool, and it's great for building kind of
procedural Actors and stuff. But as you're placing them,
they do these logical things. So you don't have to go place
all these in the Spline. So this is a form
of in-editor tool, and this is great for
level building and stuff. But what if you already have
a level with a bunch of stuff that you want to do
a bunch of stuff to? What if you already have a
Content Browser full of stuff that you want to do stuff to? The Construction Script
can't do anything with the stuff in
the Content Browser. When you run the
Construction Script, it only does it on this one-- this one Actor right here. So if I had another Actor, only
this one Actor's Construction Script is running
as I modify this. So I can only do
one thing at a time. I can't go and wholesale
change a bunch of thing. That's one of the reasons
for in-editor scripting, is oftentimes we have a level
and we need to rotate all of the whatever mesh-- 90 degrees to the left,
but only if it's red. So typically, that would be
an intern going and rotating all of them and making
a bunch of errors. So instead we're like, let's
make a tool that does that. So Construction
Scripts are built in. Every Actor has them. You don't have to do anything
when you create an Actor. There's a little tab for
Construction Scripts. To create what we're
going to be making here, you do have to enable a plug-in. So we're going to go
to Edit and Plugins. Now for those that
are new to Unreal, when I'm talking
plugins like these, these are built into the engine. They're more like
modules, so they're not like a third-party plugin that
I've gone and found somewhere and add it. All of this stuff
shipped with it. You can see it's
called built-in. So if I do add a
third-party plugin, it'll show up in another
section here called third party. So all of these
built-in plugins already shipped with the engine. We just don't have
them all turned on because not everyone needs
the adjust analytics provider. And that would
take up more memory and make things load longer. So what we've done
is we've selected what we think are the-- what we know are the most
common plugins and features that people use. And so anything that's outside
of that, you'll have to enable and in that editor, scripting
is one of those things. So I'm just going to come
on down here to Scripting, and you'll see we
have some things that we can do in Scripting. And this is what we
need to enable up here, and I've already enabled it. Helper functions to
script your own UE4 editor functionalities within Blueprint
or other scripting tools. So these editor
scripting utilities are the functions that are
used by both Blueprint, Python, and any other tool
that you wanted. So you've got to enable it. There are some other scripting,
things that you can add. You can add the Movie
Render Pipeline Scripting and the Sequencer Scripting. So if you're doing
movie rendering, you can create tools
that automatically say open up sequences and
render them out or do whatever that you need to [AUDIO OUT]. But again, only turn
those if we need that. If you're using
Python, of course, you just turn on the
Python plugin here. You click restart, and
you get this stuff. So with that setup, I'm going
to open up a level here. Don't say that. Come on, over here. So this level is
a level that you can get from the marketplace
with a couple of changes and stuff. We've been using it
to teach some stuff. And it's mobile optimized, so
it's actually already pretty performing. But there's something wrong
with this level that me, as a tech artist, I just can't. I can't let it slide. It's one of my jobs
as a tech artist is to make sure that our
projects run at frame rate. So one of my jobs,
my type of tech art is, I do a lot of optimization. Because I understand the
technology, how the engine is rendering. And I understand how
materials are made and how to make them faster. It kind of falls on
my shoulder a lot of times to help
with optimization and help make sure we
hit performance targets. And so what all these
measures are missing, I already know this,
is none of them have LOD or level of
detail measures built in. So for those that don't
know, an LOD or LOD mesh, the level of detail mesh,
is a reduced complexity or reduced resolution
version of a mesh that we can switch to
automatically as that mesh gets smaller on screen. Because as it gets
smaller on screen-- let's take for example
this statue here-- right now you can see,
it's got these vertices here and on its face. And we need all
those vertices, so that it has a nice
silhouette and all the detail that we want. But if I come way
out here, I don't need all of those
vertices anymore to show me the nose, and
the eyes, and the lips. They're all one pixel
from this far out. So a long time
ago, some smart guy was like, if we can switch
to a lower-res version as we get further away
from these things, we can have more stuff. Because now, we'll be
rendering fewer triangles. And so level of detail
has been in games since some of the
very first 3D games as a way of letting us have
a lot more stuff in our level because the stuff
in the distance is becoming less
and less complex. And so right now
on this level, I know already none of
these measures have LOD. And I can actually test that. As a tech artist, when I
got a scene that was not running great, the
very first thing-- one of the first things I do-- the
very first thing I do actually is I would turn on the
frame rate counter. I already know
we're at 60 frames a second because I'm running
a mobile game on a 2070 year something like that so. It's going to run OK. And the next thing
I'll do is I'm going to check what's
going on in the scene. And one of the first things I do
is I come down here in the LIT menu, level of
detail coloration, and I'll click on
Mesh LOD Coloration, and everything turns black,
and then it comes back. So it's compiling some shaders. Unreal does love
to compile shaders, and what we're looking
at is a visualization that helps me understand
if there are LODs. And I can tell because
I've used this tool before. There's no LODs. If there's one, there's
LODs, the meshes will change color
from this white color to different colors. And we'll see how
that shows us the LOD, but it's not exactly
the purpose of the box. So I'm like, oh. I can't-- believe they
built this entire level, and they didn't
make a single LOD. Probably unlikely, but
I've seen Stranger Things. So this team built
this beautiful level, and they didn't have any LODs. And so on mobile this
thing is chugging along. Well, fortunately, Unreal
has a built-in LODs system. So they don't have to
go back to Max and Maya, and build a million
LODs, and re-import them. Thank goodness for that, but
still someone at this point would have to go through
each and every one of these, open up the editor-- Oh, that's even a Blueprint. That won't work. They'll have to come in
here, open up the editor, find the LOD, type in LOD
group, and set it to the group that they want. But yes-- and do that
for every single one. And you can see now that I've
added LODs to this mesh here, it changes color. So red means LOD 1 or
the next step down. And then it'll go
green and blue, and so you can see
now as we get further away from these
objects, they're going to use much less memory
and resources to render. And wouldn't it be great if
everything in their level did this. So no one wants to go through
this because if we come here and look at how many we have-- just in this scene, there
are 113 different meshes. So you can imagine, it'll
take a couple of hours to do that, which isn't bad. But you're going to
do it a lot, and you want to make sure that when
this team comes back, no LODs, I can have to do this
again or whatever. We just want to-- I want to be able to add
LODs to all of these object-- all of these
measures all at once. And that is what in-editor
script is all about. So there is a problem. No one wants to do this. I don't want to sit there
and hit that a million times. And boy, I get the level of
error is super high on that because that in turn might
click the wrong group. They might miss half the meshes. They didn't click apply. Whatever it is,
someone does something that boring and
tedious for hours on end with that many clicks. They're going to
start making mistakes. And then someone has to redo it. That is where I start to like
go into tech art overdrive when I hear someone
has to redo a thing. I'm like, make it a button. So let's make this a button. Let's make a button basically
that will go and add LODs to all these meshes. I'm going to go back
to my Content folder, get rid of static mesh. And I will make a new
folder for organization. We'll call this my
tools-- whatever. And now I'm going to create one. So typically when you
create a Blueprint, you right click, and
you create a Blueprint and you choose a class up here. Well, for these Blueprints,
they're a little fancy. So you'll see now that we
enabled editor utilities, we can choose between two--
an editor utility Blueprint and then editor utility. Like I said, the widget is
like the advanced version where we can create an
interface, and we'll get there. For now, we're going to look
at these editor utility. I'll make one. And just like a regular
Blueprint, it's like, so what kind of utility would? And so you can see
there are actually a bunch of kind of utility
Blueprints that you can use, but the main ones that you
want to focus on typically are ActorActionUtilities
and AssetActionUtilities. Now if you don't know
your Unreal terminology, you go, oh, that's the diff. So anytime I teach Unreal, I
hammer these two terms home. Because if you know
the difference, things become so much clearer. When you're using Unreal,
and someone says an Actor, an Actor is one of the
things that's in the level that you can click on. So anything that's in
a level is an Actor. Anything that's an Asset
lives in the Content Browser over here. So an Asset lives in
the Content Browser. It's stored on disk. And then an Asset
gets instantiated into lots of different
levels, or a lot of times, in a single level as Actors. So multiple Actors can
reference a single Asset. So when you're here and you're
like, oh, which one do I want? Just think, do I want to work
on this stuff in the content browser or do I want to right
click on stuff in the viewport. I may want to right click on
stuff in the Content Browser because I want to
change the LODs, and that's where you do that. So I'm going to choose
an AssetActionUtility. Let's call this BPU
for Blueprint utility set LODs. We'll pop that open. And I'm just going to dock
this here for maximum screen. So here's the
editor, and you can see it's like the
Blueprint Editor if you're used to that, except
it doesn't have a Construction Script. And it doesn't have a viewport. It only has this event graph. And so what we do
is really simple. You create a new function,
OK, a new function. We give it a name. Let's call this one
set LODs or not. And I'm just going to, for
now, just do a print screen, so that we can see
that this is working. So I'm going to
compile and save. And then I have to do one
thing before I can use this. I right-click on
it, and I run it. So running actually
evaluates it, and it loads it up into memory. And now it's ready to use. And so now if I right-click
on any asset in the Content Browser, there's
a new menu here. What's that LOD? So I've now just made a
new menu in Unreal Engine. Me-- I changed my engine that
I use every day, which I think is really cool. The ability to make this
huge engine kind of your own is really cool. And when I click Set LODs-- it didn't. Why didn't it do it? Did it just not show up? It could be this View
mode doesn't allow. There it is. It did set it. I'm guessing this View mode just
doesn't show a screen message or something's going on. But you can see it here
whatever Is going on Blueprint. It's because I'm live. An hour ago when I did this-- fine. Now I'm live-- nah. So I'm unreasonably
happy that it's working. But now I can start to do stuff. So we have a bunch of
functions that we can use now. So when this calls,
there's a function that you're going to use a
lot for when you do this, and it's called
Get Selected Assets or I can just say,
Get Selected Assets. And now, I'll get an array or
a list of all of the assets that are selected in
the Content Browser. And so now, I can work on those. So I get a list, and I'm
going to do it For Each. For every one of those,
I'm going to do stuff. And I want to set the LODs. So if I try to do that straight
out of here and I typed in LOD, I'm not going to
really get anything. Because I'm trying to do this
to an object and an object is like the top class. Everything comes from that. Objects really are just-- they don't know
how to do anything. So I need the type of
Actor or the type of class that can set LODs and
that's a Static Mesh. I can't set a load to use on
an audio cue or on a Blueprint. That doesn't really make sense. But on a Static Mesh,
they need LODs. So I need to say,
hey, Unreal, I'm going to be working
on a Static Mesh. And we do that through casting-- Cast To Static Mesh. And casting is how in
programming-- if you're from C, this makes total sense to you. Blueprints is very much like
C. Blueprints and C are made-- C++ are made to work together. So Blueprints do
things like C do. And one of those things
that C do is casting, and it's a way of-- so rather than listing
all the functions that all the different
classes can do, we can kind of organize
them and we do that, by casting essentially. And so what we're
saying here is I just-- I want to access the
Static Mesh stuff-- stuff I can do to a Static Mesh. So I'm going to say, for
each object that I click on, Try and turn it
into a Static Mesh, or C if it's a Static Mesh. And if it is, this
top one will fire. If it's not, nothing
will happen or we can make stuff happen
with the cast failed. So now when I drag out
here, I get all the stuff that I can do to a Static Mesh,
and one of those is set LODs. Well, you can see that's under
the Editor Scripting there-- Set LODs. Real quick, if I come
down, open that up, and I go to editor scripting. Here's all the stuff
we can do with editor scripting the static meshes. So it's really a good idea often
to see this, dig in, and just look, and see what can we do. It's then you'll have an idea
of what's available to me. What can I build in these tools? And what can't I? And there's a ton of stuff here. I can insert UV channels. I can get the LOD out. So I can see if they
already have LOD, whatever. I can remove the LOD or allow
CPU access, tons of stuff that I can do just
the Static Meshes. I can change their metadata. There's ways to load
and save levels. There's tons of stuff here. So I really encourage
you to dig in. And that's how I figured out
how a lot of this stuff works or what I can do. It's just by looking at the
lists, and I'm like, hmm. And then months later when
I need to do something, I swear I saw that in one
of those lists that I read. Though anyway, going
to get back here and set the LOD on the sucker. This is a little weird. When you set the
LODs, what it wants or what it's asking for here
is the Reduction option. And so Reduction options are-- it's what's called a struct. And I can tell that
because that dark-- And so what we're going to do
is this weird chain of makes. And oftentimes this is kind of
how you'll set some stuff up in Blueprints. And so try and
follow along here. I'm going to go
from right to left. So what I want to do is
make one of these options. But what this does
is that it creates. Here you can see,
this options is a struct that campaigns
a Boolean and an array. Well, now I need an array
of production settings so I can drag out, and
I can make an array. So now I'm making an array. And this tie into
the LODs, and I won't get into the
weeds of LODs too much. But it lets you know that
LOD 0 is the high resolution, the one for when it's up close. And then one, two,
three, four, five-- as long as you want. There's usually three to
four LODs in most games. Some games have a lot more. It depends. And so LOD is zero. You want to tell it. Though, it's asking
for what goes in here. And a lot of times when I'm
like, I don't know what's going on here, you'll
see what I'm doing is I'm dragging a wire
out from that pin. And when I do, you
can see it filters the list of possible
actions that I can do just the
things that I can do to an editor scripting mesh
reduction setting structure. Well, that rolls off the tongue. Well, I can make an editor
scripting mess reduction strike shutting-- boom. And if you're used to LODs,
this is pretty common stuff. So what percentage of
triangles do we want and at what screen size do
we want it to transition? So LOD zero, I don't
want to reduce. I could if I wanted to. If I had all my measures
were too high, I can be like, let's crunch them now. So I'm going to set that
at one, so 100% triangles, change it's screen size-- one. So what I'm going to do
now is if I click Add pin, I get new LODs. So I'll make three LODs. All I have to do
is copy this over. So for LOD one, I want
half as many triangles. And we'll say, I will
transition at 0.5. We'll just keep going. So half of that is to 0.25. Screen size's the same-- 0.25. And we'll make our last
one, which is half of 0.25. And I don't like doing math. So check this out-- 0.25 divided by 2. Neat trick. 0.25. Here we are. So we've got are
our settings here. I'm going to compile. Go ahead and save. And let's see if this works. Let's go ahead and find
ourselves a nice mesh here. Let's add some LOD too. How about the bench? We'll find it in the browser. I'll right-click, Scripted
Actions, Set LODs. And just like that, it's done. And I can make sure that it
is by going to LOD Coloration, turning on Mesh LODs, and sure
enough, there is our bench-- LOD-ing away. So that's cool. So I could go to each one
and, right-click on it, and change it. Oh no, even better. I'll just take all
my static meshes. Oh, maybe I'll just
do the perky one. It's so great--
for ever and ever. And I can run that scripted
action on all of them at once. I'm going to sip my coffee,
and then I get to go home. Oh, my boss. It's taking hours to
set the LODs, boss-- hours. I'm going to need another day. Well, let's go and check the
coloration and sure enough, our stuff is transitioning. Now, it's not transitioning
fast enough for me. This is a mobile game, and I
want the stuff to transition soon. Like I don't want to have to
come all the way back here for that transition to happen. I want it-- I want it to be more aggressive. Now, let me show you
something cool too is when you do this, if you
want to edit your script, what's really cool is when you're on
here, you can-- and it says-- you can shift click and
it'll pop open the editor. So you can really come back
and change how it works, really nice. So what I want I do is there's
this auto-compute LOD screen size. So Unreal tries to
figure out when the best time to switch LODs are. And it works pretty well for
a higher poly LOD meshes, but when you have low poly like
this or you're going to mobile, sometimes you need to give
it a little extra push. So what I'd like the ability
to do is when my artists or when I right-click
on these, I want to be able to choose
whether or not I'm going to compute the LOD size or not. So the way I can do
that is by adding an input to our function. And when I do that,
you'll see what happens. And so here's
another great trick. Typically if I wanted to
add an input to a function, I've come over here
and that of a parameter and give it a name and whatnot. But the easiest way to do that
is to take whatever variable you want to set and just drag
it over to the terminator node. And boom, it automatically
adds one and names it and sets everything for you. So yeah, that was easy. And so now if I compile, and
I'm going to set the default value to check into default. Now, when I run this-- let's go to Content
Browser again-- and I say, Scripted
Actions, Set LODs. I get a little interface. Now it will ask me whether
or not I'm doing it, so I can build really
basic interfaces this way if I want to. So you can see now I'm starting
to make much more useful tools. And I can start to add
in more and more stuff. And all of my tools
have started that way. They all started
with like a button, and then I gave them to the
artists, and they're like, oh, can it do this? Can it do that? What about this? And I write it all
down, and then I go back and I add it all, and
make a version 1.1. It's got 10 times as
many buttons on it. All of the tools have
10 options, right? [LAUGHS] They all started
as like two buttons and ended up as this
like really long panel. Because the artists
are all like, oh, it'd be nice if it
could do this, and this. And it's so much easier for
me but just go and add that. And now they have
this tool that's customized for
exactly what they're doing on a day-to-today basis. Let's actually do
kind what I did-- We'll just run this again. And we'll turn this off. Click OK. And now you'll see right
away that those meshes are LOD-ing much faster. Though just like that,
I've done a ton of work, and I've really improved the
number of polygons rendering. I did a little test before this,
and ran it on all the meshes, and it dropped me from 2.7
million triangles in this view to 800,000 triangles, which
is for a right-mouse click, it's a pretty big win
with basically no drop in quality whatsoever. So these sorts of tools
are just so handy to have. And you can see how
easy that was to build. I just did my first example. And it's just a couple of
nodes, and of course, we can make them more complex. And we can really add all sorts
of logic and functionality to figure out if the
object is so big, it uses this set of settings. But it's great because
it's now like hardcoded in. And now every time you
run that on your project, it's exactly the same,
and all your meshes want the same settings. And no one had to stay the
extra day on the weekend to go set all the
LODs before you ship. The tools are great. So that's editor utility things I want to show
you one more thing because as it works, when
you right-click right now, if I right-click on
pretty much anything, this is a particle
system, it'll still see if I can set a LODs on it. And what if I wanted
to be a little fancier. And I wanted it-- I had a ton of these. I've been working on
this project for a year. And I want to make it
so when I right-click on a particle, system it
only shows me the things that I can do to particles. I right-click on a mesh, just
the things I can do to a mesh. Well, what's really
cool is that's actually built in already. So the way we get to that is
through a thing that's very, again, very common
for programmers, but for non-programmers,
they might not have ever heard of this. it's
called overwriting a function. So there's already
a function built in that figures out what
class you're clicking on and whether or not you
can right-click on it. And we can override
or we can decide we want to do something
different with that function. So you can see the
functions here. It says there's
three overridable. When I mouse over,
I can override. This first one is the
Get Supported Class. And so you can see, it returns
the class this Asset Action Sports. If not, it will show
up for all asset types. So in this case,
I don't want this to show up for textures
or particle system. So I'm going to get
supported class. And this is the function. So when I right-click,
this function will run, and it will ask, what
classes are supported? And it will send it in here. And I'm guessing right now,
it's set to like object-- pretty much anything. But what we want to do, we're
going to get rid of this. And we want to say, well,
what kind of class do we want? We want Static Mesh. Now if we compile, we right
click on our particle system, it doesn't show up. But we right click on a
Static Mesh and there we go. So they're very simple, but
we use these in production. We use these at Epic
to build our games. So we've gone through the
process of using them, and then-- how wouldn't
it be nice if we could-- wouldn't it be nice if you
could Shift-Click and pop the thing open? Wouldn't it be nice if we
could expose a variable, so you've got a
little quick interface that you didn't have to make? All of these things come
from us using these tools on a day to day basis. And so we make these
iterative improvements to them so that they just get a little
better, and a little better until they're at this
point where I'm like, this is a world class tool. I'd be happy to deploy
the tools in this. So are there any questions
about these types of Blueprints, or kind of anything
that I've done here before I move on to kind of, the
next step of the next evolution of these utilities. >>Mark: There
was one question there. Can you share these
between projects? >>Tom: Absolutely. So you know, the
easiest thing to do-- Yeah I guess, one of
the easy things to do, is you can always
Right-Click and you can migrate between assets,
or between the actions. You can migrate it to
another project that way. In that project I
do think you have to run them one time
so that they register, but I'm not entirely sure. I'm pretty sure you do have
to run them that one time, and then they register
with the project. So yeah, they are
pretty shareable. You could, if you're in a studio
that has a custom engine build, you can build these
into the engine, and then they're available
to everyone on every project, but that's only if you're
in that specific situation. Otherwise they
migrate just fine. So, any others? Or we can use 3D view ports
in Blueprint utility widgets. Not easily. I think someone did a
render target into one, and then did like
a camera control, and it was it was pretty hokey. Not that I know of right now. >>Mark: There's
another question about other functionality
from the Static Mesh editor. I would presume anything that's
scriptable within Blueprint, pretty much has access. >>Tom: Yeah I
think, a lot of the build settings you can't change. But LOD settings, collision,
materials, UV mapping. There is a ton of
stuff you can do. It's a really good point
that you should take a look at what's available. Because you can't do
absolutely everything. There are just some
things that only happen on import or kickoff. Some weird process where
we can tie that in. So, really do have a look. If you open up any Blueprint,
and go to the palette, you'll see there's a whole
section called editor scripting when you enable that plug-in. And then you can just kind
of see all the functions that you could do to
modify assets and actors. All right. Are UMAPs assets? Yes they are. Because they are in
the content browser, therefore they are an asset. Can you make a function
run continuously? Yes. It's-- you can totally,
dangerously have a function call itself, like with
a timer or something. It is fairly dangerous,
because then you've got something spawning something
in your editor forever. So do use care, but yeah,
I tried that myself. I was like, can I just
like spawn a bunch of stuff constantly? Yes. So, careful. Timers do work at least. At least last time I did it. All right. So cool we've looked at like--
so we can do stuff to stuff in our content browser. And you can imagine,
you can rename stuff. So you could write a script
that goes in and looks at if it's a material, does it
have an M underscore before it? If not, put one there. When we create
material instances it puts "underscore
inst" at the end. I wrote a script that
went and found anything that artists left that way. Got rid of the "inst" and
put an MI in front of it to fit with our naming. I just right clicked on the
whole folder, let it run and went and got some coffee. Came back, and was like, "And
all our naming conventions are fixed, sweet." Yeah, there's endless. If there's pretty much anything
that you do that's clicky in the editor and
you're like, "I wish I didn't have to
do this so many times." I don't know what that
number is for everybody, mine's about three. That's when I'm like,
"It's scripting time." Maybe two. Sometimes one. Let's shift a little
bit, and let's look at 1, what if we want to do stuff
to our actors in the level? We want to modify our
level in some way, and do stuff in the level. And 2, what if we want to
make it look a little nicer? What if this is something that
my team does every freaking day, and they're sick
of right clicking. And they've asked
me, "Can I just get a button right here
that I can just become?" Yes, yes they can. We did something really cool. So we have what's called UMG. Which is Unreal Motion
Graphics, and we designed it to make user
interfaces for video games. Because video games
need user interfaces. So, we made it. And it's a really powerful
user interface tool. It's hardware accelerated. Its multi-platform. So you make one UMG and it works
on mobile to high end consoles. Runs on a PS5 to a Switch. All with the exact same code. So very much in line with how
Unreal Engine [AUDIO OUT].. However, the editor
is not built in UMG. The editor was built in the
days before UMG with a system called Slate. And so up till now, if you
wanted to create a panel, or create a button in the
editor, it was not great fun. Because you had to master
the slate system, which is written in a version of C
that is specifically for slate. So it's like, it's its
own programming language. So you can imagine that
the number of people that know how to do that
at a professional level is pretty slim. And no one really
wants to tackle that, because the only time it's ever
really used is for the editor. So editor tool people
are totally into it. Everyone else doesn't
want to do it. And so our tools folks
went, "Well, what if-- could we make it so that you can
make a UMG thing as an editor panel?" Initially the answer was no way,
they're totally incompatible. But then magic happened,
and one day Lauren came down from the
heavens, dropped upon us the Editor Blueprint
Utility widget. And now we can create
interface stuff using UMG for the editor,
which is super powerful. And now that's been
extended so that even plug-in makers and
panel makers can now not have to use the
canvas, and can just use UMG which is
a little easier. It has like, a user interface. There's nothing quite as
fun as building a user interface in text. It's a special level of hell. So now we can take these
user interface stuff, and all the buttons and widgets,
and all that cool stuff that we made for making games,
and we can make interfaces in the editor. So when I created my
last Blueprint class when I went to editor utilities,
there was the editor utility. It's got the little UMG icon. So I'll make one of these,
and we'll call this UPU. Let's call this Randomizer. So what I want from this
tool is over yonder, and I'm going to
switch back to here. Over yonder in my scene, I've
got all these wrecked columns that I've placed in the scene. But they are all
exactly the same size, and they are all facing
exactly the same way. And of course you know, I could
go in and rotate and scale, and do that. Not that hard. But, let's say our game
is, "Columns, the game." There's a million
of these suckers. Or even just, there's
a lot of stuff in games where I'll drag it
out of the content browser, and then I want to kind
of add some randomness, and some rotation to. And up until now it's pretty
much been my workflow as I, you know, I drag it
out from the browser. Let it scale to what I want
it to be, and it's seven. And then I drag it
where I want it, and I get a little rotation,
and I get a little scale. I'll drag that, and I
kind of do the same thing. It works, it's not bad. I've done worse
things in my life. But it's pretty tedious. And if the stuff's already set
up, it gets really tedious. So it would be great if I
could just select all these and have them get randomized. Let's build that real quick. Go back to our editor here. Let's open this up. So now, this is a
slightly different editor. So this is our regular editor,
and this is the widget editor. So this is the UMG editor. This is a screen,
it's supposed to look like a game screen in 16 by 9. And over here we have
a palette of cool stuff that we can do like buttons,
and text, and sliders, and all those things that
you use to make HUDs. And we can drop those in. So we're going simple. I need a button. We're just going
button to start with. I'm going to drag
a button up here. I'm going to style it a bit. I'm going to make it 5 by 5. I'm going to size the content. And that content's
going to be text label. And we'll call this-- this one's going to
say, "Randomize yaw." We're going to randomize
the yaw of all these guys. And I'm going to name this
button so that it's not called button 209, because I'll
have a hard time finding this. Let's call it,
"Button Rando Yaw. So when we click
this button we're going to make stuff happen. To do that we now move
over to the graph. So this is the way UMG works. We have this designer
where we can lay out these widgets, these elements. And then a graph, which
is an event graph. So it's almost like two editors
kind of mashed together. We've got the layout editor,
and then you click over here to do your logic. So you can see over here when
I gave that button a name, it turned it into a
variable that shows up here. And when I click here, I have
events, and this is On-Clicked. So if you're used to making UIs
or this sort of stuff, these-- you are like, "Oh, On-Clicked
events, mouse over-- I don't understand all this." If not, as you work
with UIs and stuff, you'll start to understand
these sorts of things. So this is an event. So when the user clicks on
the button, and in this case they have to click
on the button, and then release on the
button for this event to fire. That's what On-Clicked is. They've completed the
full clicking action. So when they do that,
this is going to fire, and you can do stuff. So when we click this button,
what we're going to want to do is, instead of, "get
all selected assets," we're going to want,
"all selected actors." "Get all actors." Get-- did I not type it in? Oh, get-- there we go. And be forewarned,
there are two. One of them is the VR scouting
thing and it doesn't work here. So if you're trying this, like
I was yesterday, and I'm like, "Why won't it work?" I was using this "get
selected actors." Not this "get selected
actors," obviously. So with the correct
"get selected actors" now, just like before,
we get an array of them. So I'm going to do a 4 each. Now for each of these I'm
going to want to rotate them. So for each element
as we loop through, we're going to-- let's
do "add rotation." No? Oh, that's an object reference. I did it again. So, I'm trying to find
rotation, and objects don't have rotation. Objects are a class that
doesn't exist in 3D space. Actors are the class
that exists in 3D space. So I can't rotate an
object, because it doesn't have that variable. But I can rotate an actor. So like I did before I'm
going to have to cast, and say I want an actor class. I want to be able
to rotate them. So as an actor, something
that exists in the scene, I can now add rotation to it. "Add actor." And how much do
we want to rotate? Well, we're just going
to rotate in the Z. So I'm going to split the Struct
Pin so that I can get access to the Z. And I'm going to
rotate it a random amount. That's going to be, "Random
float in range 0 to 360." Just like that. So there's my script. When I click on the button and
I see all the selected, "Oh I got the wrong one." Look at that, they're
so easy to mix up. That's assets. That's going to give
me the wrong stuff. Because assets don't
live in the level. Assets are in the
content browser. "Selected actors." "Get selected level actors." There's so many of them. Set-- I want to get. That's more like it. And now I don't need this. I was wondering why I needed
that because these are actors. As you can see here it
says, "Array of actor object reference." So I can just get rid of this
because this now will return. Oh, no, it won't. Here we go. [LAUGHS] "For each." I thought this was wrong. So now when I do that, it
creates a different "for each" loop that now returns
actors instead of objects. And if you're new to
Blueprints and programming, I am sure some of this is
like, "What the, casting? And variables in classes?" Don't worry about
it, it'll come. As you use it you kind of, start
to see some of these patterns. Some of that stuff will come. So now, when I compile this-- yeah. So when I click this button, I
should get the selected level actors-- actors, not assets,
and for each of them, I will add actor rotation. I'll rotate them around. So let's see if this
actually works here. We'll go back to our level. And just like this
one, we actually have to run it for
the first time. And when we run it, look at
that, there's our button. So you can see this
is even dockable. I can go and you know,
put my tool wherever. Now I've got a tool that
sits in my interface, and I can keep
adding stuff in here. That's super cool. Well let's see if this works. I'm going to-- I might as well
select a few more of these. On hiding in the rubble. And let's randomize the yaw. Ta-da. Look at that, they've
all been randomized. And I can just keep
clicking, and now I've got that randomization. Pretty cool right? Pretty sweet stuff. So, when I did this, I
was like, "That's sweet". But I didn't do it right. And I went to undo
and look what happens. It doesn't have an undo. So by default we actually
have to program in the undo. And I'm going to just show this
because I want people to know that, 1, You can add undos. 2, it's fairly simple,
but it's a little obtuse. Or you're like, "Why,
and that's so odd." So I'm going to show it
to you just so that you know that it's there, and if
you Google search Blueprint utilities, undos, this comes up. So it's pretty straight forward. So yeah, I want to
be able to undo that. What we have to do is-- it took me a while, because
if I just come in here and I type in "undo"-- undie? No not undies, undo. Undo. There we go. I get this, and I was
like, "Oh that's the thing. What object?" I tried to use it. It didn't work at all. So I had to Google it. And it turns out that it's
called something else. It is called--
what is it called? The transaction? It's called the transaction. So then what we're calling it
is, unfortunately transactions. So if you come down here,
M, N, O, P, Q, R, S, transactions. So this is the undo system here. So, you kind of have
to like, begin and say, "I'm starting a thing, and
I need to get undo-ed." And then you tell it, "Here's
all the stuff I've done, and now I'm done." And that tells Unreal,
"This is all the stuff that is in that undo." This is what undo
means, this undo. So what we have to tell it
is, we're beginning a thing-- And we have to give
it a name, because we can have multiple undos. So in this case, we're going
to call this "rando yaw," and there's a description that
will show up if you mouse over. It will go "rando yaw," why not? And then the primary
object, who's going to store this undo-ness? It could be the level,
it could be whatever. We're just going to say, why
not have this script store all this information. So, we'll say, get a
reference to myself. So like I said, it's fairly easy
to do, but it's pretty obtuse. And I'm not expecting
everyone to be like, "I don't know how to do it." Just that they're going to
Google search and be like, "I saw Tom do an undo." So we begin the transaction,
and then every time we do something we
have to register it. There'll be undo system. This is the undo stuff. And that is done through,
"New Transact Object,"-- programmer language. So we're just telling Unreal
who's getting changed. And this seems a
little overly complex, but once you actually
get into tools, it's really nice to be able
to determine what gets undo-ed and what doesn't, and what the
undos are called et cetera. So out of the box I'm like,
"Oh, why doesn't it just undo?" But as someone who's built
a lot of these tools, I'm actually rather happy
that it doesn't just assume. It can also be fairly
dangerous for memory. So then, once we're done
with the whole undo context, we have to finish it by
saying, "End transaction," and we're good. So now, if I compile-- if I come back to my level,
and I'll just [AUDIO OUT]. Set the [AUDIO OUT] to 0. Now we will randomize their yaw. Now when I go to it Edit, Undo,
it says, "Undo rando yaw." So I even got to name
it a stupid name, and it actually works. So yeah again, these
are really robust tools. And we use them so we
thought through a lot of this kind of functionality. We can take this further. And what's really cool is,
if I close this project, and open it back
up, it stays here. So you only have to run it
that one time to register it with the windowing system,
and then it always runs. And there's even
an option in here if you want to provide
this to your team, and you don't want them all to
have to go to run to get it. There's actually an option
in your Class Defaults, right here. You can always
register with Windows. So, you can click on that,
give it to your team, and it will end up-- it ends up actually just
like our other thing. Now under Window, we have
Editor Utility Widgets and we can toggle our
utility widget there. We really treat your
tools like a first class citizen in the editor. So, they show up and they
can be really useful. We want to make sure
it's not clunky, and you don't have to build
a tool to fix your tools. We could keep going. There's some really,
really good-- we've actually added in some
additional functionality. I will wrap this
with a vertical box, and then I will grab
myself another button here. Whoops, I did that wrong. Wrap this one with
a vertical box. Give me both please. And now of course if I
compile, we'll see I come back and I have both buttons. So you can see, once it's
registered, it's live and you can keep working on it. So in this case, I want to
add another button, that one. Let's call this,
"Randomize scale." But I want some options here. So I'm going to wrap this
one in a horizontal box. I just want you to
see how cool UMG is and how quick you can just like
start adding this stuff in. And let's see, what I want is,
I want some text that says-- the horizontal box and
vertical box are cool. They just automatically
stack things horizontally and vertically. So using them in combos, you can
build interfaces super quick. So this text box, let's
have that saying, "in." And let's put an input
spin box next to it. So next thing in the
horizontal box is the spin box. That looks good. Add the minimum, which is 1. Then we need both
of these again. [AUDIO OUT], and this
one's predictably Max. Now just do a little styling. We'll do that. We'll do that. Not the prettiest, I
can make it look better. Now when I compile and come
back though, here we go. And you know these are
cool slidery things. Then you can go and set it
so it's all nice and even. It doesn't scale and
stuff but now, I'm doing stuff quick right now. Look cool? But what I'm going to do
is, with this button here called, "rando yaw 2," I'm
going to rename, and call it, "Button rando scale." Same thing. Now if I go to the graph
and click on, "rando scale," add an On-Clicked. I'm going to do this. I'm just going to take what
I've already done here, copy-paste, "rando scale." Those don't have to be the same. I'm just doing that to make
things easier on myself. So now for each one of these
meshes I'm going to set scale. And what I want is, up-- these are called spin
box and spin box 60. I don't know what that
means, but let me be good. Let me name these. So spin box, this is Spin
Box min, and this is max. That's a lot easier to see
which ones are which, all right. So what I want in
here is Spin Box max, and I want to get the value. Same thing for Spin Box min. This will give me
the value of what's in that slider box in max. We'll do a random float
in range minimum-maximum. Then I will just poke
that right in there. And what's really
cool is, I'm just making a float or a single
variable, just an x. And if I pump that into
the relative scale, which is xyz, or a vector,
Unreal automatically will convert that, and it'll
put xyz together in the same-- it'll all be-- all
three will be the same. Now I can compile. Ah, got my transactioning
or somewhat, the undo. Go, and then we are going
to have a transaction. Boom. And compile. And come back here, and
now randomize scale. Holy moly, well
that's not right, because these are already seven. So let's do six and eight. And you can see
tabbing even works. So I just tabbed between
those, and it works. And there we go. And now of course I can un-- so you can see that you can
build really nice interfaces, dynamic interfaces. There's lists, so you could
list all your selected objects, and change their
parameters there. The sky's really the limit. As flexible as UMG
is for making games, and if you think about all of
the interfaces in Fortnite, you could do anything like
that, as a panel in your editor. I've even seen people that
have like a set of Blueprints-- or classes, that they
just use all the time. And they go and make a
panel where then they just click on it, and
plops one into their scene. So it's not doing a
whole lot, but they don't have to dig through their
content browser all the time, and they're like, I never
remember the favorite. So I just made this panel,
and I put my classes in there. I click on them, it
spawns one in my scene. And why not? There's all sorts of
things that you can do. And then all the way to
like, the super complex, where I've built systems that go
and put down crosswalk stripes, and in between certain things. It's all kind of
procedural and dynamic. It's really sky's the limit. That's kind of what I've got. It's important to know
too that, everything that I did here, other
than the UMG stuff can be done with Python. So if you're building
pipelines, and you're trying to solve for
this stuff, this is-- all of this stuff
is exposed to Python, but you can't build
interfaces with Python. So at that point you're
using [AUDIO OUT]. So cool. Any questions from the crowd? I wish the Place Actors tab
is as customizable as this. Right? Well now you can make
your own Place Actors. There's even drag and
drop capabilities that are built into UMG as well. So you can make
stuff that does-- similar to this. I do wish that we could like-- I could go and modify
the existing panels, but I think I'd probably
do more damage than good. >>Luis: That
was pretty awesome. Good job Tom. A lot of people in the
chat were like, "Whoa." >>Tom: I watch people
do Blueprints all the time and I'm like, whoa, I didn't
know you could do that. >>Luis: Yeah,
so the VOD will be up. Usually it comes up after
the Twitch stream is over. Within the half hour
to maybe an hour tops. Though any of you
who missed, and were trying to follow along, you'll
be able to follow along. >>Tom: Oh yeah,
or shows that you have watched and wanted
to pause, and rewind. That is the true
power of the YouTube. I've spent many hours
pausing and rewinding Sjoerd's and Chris Murray's
videos-- Murphy's videos. How? >>Luis: And
then it'll go up on YouTube in the
next day or two, on the Unreal Engine channel. >>Tom: I also
want to let everyone know that, that example
that I did with the LODs is actually on our
documentation site. I didn't know that. I went and built
the system myself, and then I was searching for
help and I was like, "Oh, look. It's in our documentation." So if you follow the
documentation on In-editor Scripting there is
actually a tutorial that's not the most obvious. So this is the Scripting
and Automating the Editor. If you Google search that,
that'll take you here. And if you look over
here on the left, there's Editor
Scripting How To's. And this is also really cool. So you've got-- we've got two. We've got creating LOD
in Blueprints and Python. And if we come in here, it tells
you all about LODs and stuff. But what's really
cool is we show you how to do this in Blueprints,
but there's a button here and you can see how to
do it in Python as well. So it's a one to one between
Blueprints and Python for this, which I
think is super cool. I love being able to see exactly
how one works, or the other. So you can see and
hear pretty much-- you import Unreal, and then you
use the same function names. Editor Asset Library, Load
Assets, LOD counts, et cetera. Very much the same thing that
you're doing in Blueprints, just in a text format. And again this could run
outside of the engine load up the [AUDIO OUT] stuff. Each one has its benefits. You can use UMG with
one, you can run it out of the editor with the other. [AUDIO OUT] combo run
the best way through. Does LOD work the same way
for Foliage Instant Meshes? Yes. Foliage fully uses
LOD and you should be using LOD in your foliage. Foliage does do a bit
dithered transition by default, which can sometimes
look a little funny if you move really quickly, but
there's some ways around that. But yeah, totally be using-- LODs are really
important for anything that gets repeated a lot. So your wins on LODs, if you've
got that one big mountain in the background, and
there's only one of them, your LOD wins are
going to be OK. But if you've got 1,000 columns
and you can shave 500 triangles off each one, whoa, now you've
got 50,000 triangles out of your scene. That's a big win without any
obvious visual quality drops. Stuff like foliage--
and that's something that when I'm
looking at a scene, I look for those things
that are repeated a lot, or that are in my scene a
lot, using a lot of triangles. I want to tell people
though, if you don't know, because I always
forget this is here. You've got a window. You can go, View Statistics. There's this whole
statistics thing in here. That I always forget about. And it's a spreadsheet that
tells you about your levels. And you've got Primitive Stats,
Texture Stats, Baking Info. But in Primitive Stats
here, you can very easily see for example, which
actor is using the most triangles in their scene. And in our case, it's landscape. And then we've got
this large rock. There's 137 of them. And each one has
2,000 triangles, therefore I have
327,000 triangles. If I had to like, "Ah
there's this one thing." And I've very often opened
a scene and been like "Oh, that one glass that they're
using on every table has 50,000 triangles, and
there's 50,000 of them. No wonder the scene is bogging. I can fix that one,
and we're good to go. So this statistics
thing is great. Extra stats is
really useful just to make sure you don't have
any crazy big textures. I've found HDRIs that are
sitting in things, eating up tons of memory, that
aren't being used. A variable. Statistics, this
window, I always forget it's there
until I'm like, "Wish I could tell how many--
oh yeah I can, it's there." >>Luis: Looks like a
couple more questions popped into the chat there, Tom. >>Tom: Yeah let's see. Can you use UMG to
customize your own inspector for a specific actor type? Totally. There's some events
that you can tie into that will make it
update every time you click on a different actor. So you could totally have like
a custom details panel here, for a panel that has a bunch
of information about your actor and specific buttons to
change it or whatever. Shows it's metadata,
or whatever you want. I built like a simple
light Lister in here because I wanted to
be able to just see all my lights in the scene,
and turn them on and off really quickly without having to go
to the world that liner is in. I misspell it as kite. And then click on it, and
then go to the details just like, "Oh, I can just
put them all here and I can find all my lights,
and turn them on and off." Then yes, animations in
Widget Utility Blueprints. You can put materials on these. It's running full on UMG. So you could have spinning,
wobbling, shining buttons to distract your designers with. Curve input? I believe so, yeah. There is not a curve
editor widget that ships, but you could pump
curve data into It >>Luis: We're running
into the second hour-- two hours into the stream. So we're going to
start wrapping this up. If there's one question,
maybe more, two questions. One thing I wanted
to add is that, what Tom did here, it
was really impressive, and I think a great
example of how to use Blueprint Widgets
to make working inside of a level a little bit easier. But I don't think that it was
terribly intimidating, right? So if you are teaching Art
and Design or Filmmaking or something like
that, I think this is a great example of exploring
these tool sets and realizing. And some of the other
things that we've seen is people in film studios
using Blueprint Widgets to make their own custom burn ins, and
custom camera tools, all kinds of different camera tools. People in a variety
of different shops, not just game development
shops, using it to really help make tools for their
teams of people that maybe aren't quite
as active in Unreal Engine or whatever the case might be. Make their lives just a
little simpler and easier to get around inside
of the engine, specifically now that
you can dock these tools and make it easier to
customize unreal as a whole. So if you've got more dedicated
programmers, or people that maybe come into a program
with a little bit of scripting or programming
chops, this really helps liberate an entire
team in many ways. >>Tom: Yeah,
I think it's just key to helping
students understand that the tech art is a career. And just helping them along that
line, because the question that came up earlier comes up a lot
is, how do we teach tech art? Do we start a tech art track? Do we have tech art class? Maybe. I think everyone should
be exposed to tech art. But it really is about having
those avenues available so that when those students
identify themselves, they can have something to do on
their student teams that really utilizes that skill set. And you'll see that the team
ends up just relying on them. and they instantly become
a really valuable asset for whoever they work for. >>Luis: I want to remind
you all also that next week we have a great stream. Next Friday. We've got some really amazing
programmers from Epic that will be joining to talk about
programming C++ inside of Unreal Engine. So those of you who come from
a programming background, maybe are teaching programming,
and really want to understand the distinction
between gameplay programming and engine programming,
we're going to spend the whole
stream talking to gameplay programmers, to
engine programmers at Epic, to talk about the
work that they do. Maybe there are some
folks that don't know exactly the difference. Maybe you know the difference,
but don't know the day to day work. And so we're bringing in
some experienced developers. Some guys that have been
at Epic, programming for over 10 years. And some guys that have
some amazing titles, like Principal Mathematician. And some guys that are systems
programmers on current games, to come in and talk about
how they do their work. And so that's next Friday
at 2:00 PM Eastern time. That should be a
really awesome stream, because we've had I think, a
lot of streams focused on C++, but I don't recall off the
top of my head that we've had a stream where we've brought
in both engine programmers and gameplay programmers and
said, "What do you do everyday? What do you do every day?" And if you are
teaching programming in an academic institution,
what should you focus on? What is the distinction? So that'll be really exciting. >>Tom: Yeah, the
group that's coming has such varied backgrounds
and responsibilities in what they're doing. I think it'll be really
eye opening for folks to understand the breadth of
programming as well I think. Even I, when I
started out I thought, very siloed terms,
programmer, artist, whatever. Understanding the difference
between gameplay programming, and engine programming,
and graphics programming, all that is really key
to helping students figure out where they're going. And so it's going to be
really cool to talk to them and hear their stories and
really dig into what they do. >>Luis: Yeah, so that's
June 26, Friday at 2:00 PM again, Eastern time here. So make sure you tune in. Thank you once again for
participating with us this Friday. We had a great time. Thank you Tom. Thank you Mark. And I hope you all
have a great weekend. Stay safe, and join us again. I think we've been having
a lot of fun with these. And once again, keep an
eye out for the recording. Should be up in a little while. And come rewatch it again on
Unreal Engine YouTube channel. And take a look at the
playlist, because this I believe is our sixth or seventh
educator stream. And we've had some really
good ones in the past couple weeks as well. So thank you all. Have a great weekend, and
we'll see you next week. >>Tom: See you
next week everyone. >>Mark: Thanks everyone. [MUSIC PLAYING]
