VICTOR: Hey, everyone. And welcome to another episode
of Inside Unreal, a weekly show where we learn, explore,
and celebrate everything Unreal. I'm your host, Victor Brodin. And my guest today is Patrick
Wambold, solutions architect for media and entertainment PATRICK: How's it going, man? VICTOR: It's all good. I'm excited to have
you on the show. PATRICK: Awesome. Yeah, I'm excited to
finally get on one of these. So it's good. It's good timing,
just in time for Christmas. VICTOR: And you got
some really cool stuff to show us today. We're going to talk a little bit
about the DMX plugin in 4.26. PATRICK: Yeah. So I mean, this is something
that we initially put into 4.25 as an experimental feature. And finally, in 4.26,
we're out of experimental. I believe it's still
marked as beta. But we still consider it
ready for production use. So I'm really excited to
show some stuff about it. VICTOR: The floor is all yours. PATRICK: Cool, awesome. Well yeah, and again,
thanks for having me. I always love the
stuff you guys put out. So hopefully,
this will be as interesting to some other
people as it is to me. So just a little bit of background
on me and what DMX is used for-- I came from live entertainment. So any time you go to a
concert or event like that, or if you're at a theme park,
or most of the cases when you're seeing
lightning being done in a setting like that,
it's being controlled through DMX. So if you don't know what it is,
that's the general background. It's a protocol used
to control lights. And so we put in
some support for it, just on a protocol level,
and also created some example fixtures,
as well as the newest thing in 4.26 is actually the pixel mapping. So I'm going to show
hopefully all of that today, if we have enough time for it. And yeah,
I'll be looking forward to also hopefully answering
some questions because I know we've got a lot
of passionate people in that live events community,
especially with the state of
things this year in 2020. Yeah,
so I guess like the first part-- and I guess my desktop is visible,
right? VICTOR: Yeah, sorry, looks good. PATRICK: All right, cool. Yeah, so I, mean enabling
it is actually super simple. And I would assume most people-- if you have some
kind of interest in this, you already know this part. There's actually
like four parts to it. So the engine and the
protocol are the two main parts. The fixtures themselves
are just if you're going to do like visualization
inside the engine. They're just some examples. And then pixel mapping is just
then the newest kind of feature that we pushed
out that should allow you to take either a texture,
or material, or something like that and actually send
DMX from the engine using it. So you just need
to enable all these. It'll prompt you for a restart. I've already done that. So it's not going to-- I don't have to do it again. And then once you come back,
you'll actually notice a couple
things about your layout that might be a little different. So you'll get this little
toolbar icon at the top here. And so this will be
your main control point as far as IO and DMX. So if you take it down,
you have options to pause sending and receiving. So this is actually
extremely helpful, if you're doing stuff
like recording in and you want to play back,
you don't want to have a conflict
with something else that's on the network. And this also gives you
access to the monitoring tools. So I actually have one
of them that I usually keep just docked down here. But it's a dockable window. You can put it
anywhere you want. And so this will
give you a readout of what's either coming in
or going out on a universe. You can pick
which protocol it is. But it's just a single
universe at a time. That one's pretty cool. But then our internal team
came up with this other one, the Activity Monitor,
which I think actually gives you a lot
more information. But it shows you just every universe,
just what's happening,
but only the channels that are actually being affected. So it's actually just a
nice way to see, oh OK, stuff's coming in
or stuff going out, and where is it because
sometimes there is some discrepancy on are
you sending it on the right one. And so now,
you can just see all of them without having to just
pick between them. So that is super helpful. And then the last
thing that they added in with this output console-- and really, this wasn't
designed to be a control surface, so to speak. It was really meant
just to quickly test things. So if you had some
real-life fixtures and you just wanted to
quickly send something to it, that was the purpose of it. But since then,
it's definitely evolved a little bit. But still,
that's kind of the point. It's really meant
as a debug thing. You're not really-- it wasn't
designed to control fixtures in any meaningful way. But it's pretty handy, if you're
just trying to quickly bounce through some things. So those are the main parts of just,
I guess, the toolbar set. But in addition to that,
there's also a couple of new asset
types that you get. And it's pretty-- I hate to say self-explanatory
because that usually means it isn't. But if you right click to add
content into your Content Browser,
you can actually create DMX Library, which was similar
to how it was in 4.25. We had that as well. And then you have this new
pixel mapping asset type as well. So I already created
a ton of libraries that I was using for
some of my demo stuff. This is just some kind
of a little playground that I've been using. But I wanted to go
through this process and just show it
from start to finish, how you would do it if you
have never done it before. So hopefully, this-- will we
have some good docs online now. But still, sometimes, it's just
nice to see going through it. So what I'll do is I'll
just create a new one. And I'm going to name
at something nice. So we'll call this Live,
and there. So once we open it up, we'll
get a window, kind of like this. There may or may not
be an extra because you can have other windows in it. But these are the three
main ones that you need. So depending on if
you did a fresh install, you might see an extra window. But these are the three
ones that you need. So the first thing
we want to do is define what our input
output is going to be. So we're going
to tell Unreal how are we going to get DMX
in and out of the system. So we give it-- there's a couple
of options in here. If you're familiar with DMX,
these should seem very familiar. If you're not, basically we
support two protocols, ArtNet and sACN. We give options as far
as broadcast or unicast. If you go to sACN,
we also have multicast as an option, since it's supported. But I tend to just use
ArtNet because it's just what I've used forever
and I can generally get it to work. And then from here,
we're going to define what universes we're going to
send out because I think most people are familiar with this. But if not, DMX is subdivided
into universes and channels. And so you generally have
to tell it exactly what you want to talk to. So we'll give it a universe
number and a channel number. So this is where
we're going to tell it at what universes
are we actually going to use because there's
64,000 possible ones. We don't want to send them all. Let's just the ones we need. So I'll tell it here's
the one we're going to start with, the amount. So whatever, let's put in 10. And then we can
remap where we want this to go on the other end. So for example,
if I wanted to actually send it to universe 20,
I could make an adjustment here. Odds are good for easy stuff. You'll just leave it the same. But this can come in handy,
especially like with ArtNet,
you can actually send it to ArtNet 0, if you want. But I just like to leave it
1 because that's easier to deal with. So I have a little warning here. This is kind of a new thing
just to tell people that, hey, you have another library
that you have overlapping values on because you can
create as many of these as you want, and so to give people an idea like,
hey, you might have a conflict. You might be trying to send
two things to the same place. So this will tell you
which other libraries have overlapping addresses. So it's pretty nice. If you pick-- so
if I were actually to move this somewhere
much further away, it goes away because now
it's not overlapping anymore. There's nothing wrong
with overlapping, per se. But it's just to
give you an idea like, hey,
you might not want to do that. You might already have
something that you're already working with. So I'll use just this for now. And then the next
section is where you define what types of
fixtures you're going to use. So this is something that is
somewhat exclusive to if you're going to use Unreal as
more like a previs style thing. So if you wanted to
design a stage set, and use a console
and something like that, and you would
want to actually like control lights with a board,
that's where you would define, like OK, what fixture
types am I wanted to talk to and where are they,
like address. This is kind of what
we came up for this. So it's a little bit different
than the old patching system. Again,
if you're used to a console, all these things will
probably be familiar. But I'll just quickly
go through it. So if you create
a new fixture type, it just comes up with a
generic DMX fixture type. And then you can either
do one of two things. You can either just
specify it manually, what you want it to be,
or we also support what you call an
industry standard called GDTF. GDTF is an open protocol that
we participate with and support that has a common set of
defined properties for lights. So right now, we only actually
support the channel step and channel information. We don't actually import the
models or anything like that yet. But that's something
that hopefully will be in future releases. But for now,
this is just to help define what are the
properties of the light and what can we do with it. I'm thirsty today. So I have a few GDTFs
that I had imported already. I'll show how to
use that in a second. But first, I'll just show how
to make a really basic light. So the most basic
light is probably like an RGD light plus a dimmer. And so that would be
something kind of like one of these guys,
just a little LED par. It's three channels
and a dimmer channel. And that's probably the
most basic fixture anymore. And so when you come
down to the settings of it, you have a way to
specify what category it is. These don't really
mean anything. You can put them on static,
if you want. It's just more for grouping. So if you wanted
to do sorting later, you could say, OK,
give me all the static heads, give me all the moving heads,
something like that. So then after that, it just goes
down, moving across this way. Lights can have different modes. So you can define
different mode types here. So we'll literally just say this is,
whatever, four channel mode in this case. And then you can define
from there what things should the light do. So we'll add four
functions here. So functions on the left are really,
honestly not super important if you're
creating them from scratch. They're more important if
you're actually importing them because what you
import from the GDTF will populate the functions. And you have to
assign those internally to what we would
consider our attributes. So we define a certain
number of attributes that we just consider common-- like a light would
have intensity, a light would have color,
a light might be able to pan or tilt. So we're able
to add to that list. But we just give
people a predefined list. That's going to kill me. All right,
so hot tip-- don't use auto-tip to increase the frequency. Yeah, all right. Save manually,
you'll be much happier. So we have these predefined. So when you click the dropdown,
there'll be a list of them. But you can add to this list. And I'll show you kind of
where that is here, once I get through the last section. So I'm just going to add,
since it's a very simple fixture. So now,
I have everything assigned. We're all good. And then down here,
you can define some other, I guess, smaller details about
each function because DMX can be either 8-bit, 16, 24,
or technically 32, and probably beyond. I've never really seen
anything above 24, honestly. But you can change those here. You can also swap
the-- so in 16-bit mode, you can either have
most significant or least significant. So the port one can
come first or second. So if you need to swap it,
you would swap it here. If you need to offset
where the channel step is, you can also do that here. But for the most part,
we're just going to try and keep it simple,
all right? So essentially,
this is a complete light. Now, it's been defined,
what it is. And we've got all
the parts we need. The last step is to then
just add it to the patch. So my good friends at
Geodesic did a great job making this some of the best UI,
I think, in the engine. And so they made
it so that now when you add a light--
so hot tip-- if you want to duplicate a lot of these,
number it first. And then when
you duplicate them, you'll get a nice
incrementing number, which I find extremely handy. But they populate with
these little bubbles over here on the left. So by default, they auto-assign. So they'll just increment. So if you keep going,
it'll just keep patching to the next available. But if you wanted to,
you can actually just go and drag this around
and move it to a new patch. It automatically turns off
auto-assign at this point. But you can always-- whatever, I could to
drag it back in and click it back on, if I wanted to
keep having them shuffle. You can also change
the colors of the buttons. So maybe we'll go with
a nice red and green look for Christmas. That's a pretty
bad red actually. But you get the idea. And then you just use that. It's really just
visual at that point. You can change what
universe you're looking at. If you attempt to put
something into a universe that we didn't define,
because earlier we only said we're going to use 10,
it will tell you like, hey,
warning, this is actually outside of this. We can't get to it. And it'll tell you also up here
unreachable by controller, meaning that we
don't have enough. We should have set this to 20. So it's a pretty robust,
actually, system for patching
things together. At this point,
we have 10 lights that Unreal is ready to deal with,
if we wanted to use them. So backtracking just to
cover some other things that I glossed over, I mentioned
that these attributes here-- we can add more of them. So where you
would do that actually is inside your Project Settings. So if you go-- once the plugin's enabled
and you scroll down, you'll have this
DMX Plugin section. And you have these options
here that it would give you. So the first one is what
interface are you going to use. So if you leave it on 0,
it's going to pick whatever your
Windows primary is. This is generally
what I like to use. That way,
I have to think less about it. But if you look at
the dropdown now, instead of giving you
something to type in, it's going to find all
the ones that you have. So this is one of my ethernets. This is another one. This is our VPN. And then we have local loopback. But 0 will just pick
your primary one. So it's pretty handy. You can also set a
global offset universes. So if you needed to just
move everything down for some reason,
you can do that there. But here's also where we
have categories and attributes, right? So the static-- those categories
that I showed that are here, you can actually define more of them,
if you wanted to. So you could use that
for grouping or whatever. And then the attributes, right? So this is where we
could define whether we want to use red, green, blue. What are these words? And so what this keyword
is in here is that we noticed, when coming from GDTFs,
they have something in the order of like 280,
or something like that, types of attributes that
they support, which is a lot. And a lot of them are very
similar in a lot of cases. And so we tried to
make it easier so that, if you bring one in,
it will smartly look for these words. And then if it
finds one of them, it will automatically map
it to the attribute type. So it's quite a
timesaver because, if the wording is slightly
off or looking for just-- it just would take
a long time to map. So you can add more of those,
like I said. It's just as simple
as adding a new one and just making a new field,
super simple stuff. And then lastly, we have some
settings about what should we do with refresh rate. So by default,
DMX runs at 44 hertz. You can restrict that or,
I guess, if you really wanted to,
make it go faster. I don't see any
real point to that. But certain consoles
and certain older nodes do run at different rates. And so we give you a
global setting for that. These send and
receive by default-- what this actually controls is-- in here, we have a setting for-- we can pause, send, and receive. But if I tick this off,
this isn't necessarily going to package with it off,
right? And we can tell it,
through Blueprints or codes, to send or receive. But you actually just have
a setting in here where you can say, OK, you know what? I don't want you to send by default.
Unless I tell you to, don't do it,
same thing with receive. So by default,
they're both checked, which means,
as soon as you hit Play, it's assuming both
will be working. But there could be some cases,
for sure, if you recorded
with the sequencer, I don't want it to
receive by default. I just want to play
back what I'm looking at. So that's all the settings
that we have for it at this point. And so then I'll pop
back over to the patch. So I mentioned this idea
of importing a GDTF file. And what these are-- we can maybe post a link. But it's gdtf-share.com. Then again,
it's like an open source database of these fixture types. So I have brought a few of them. I already had a few. So I'll just use one
that I already had. So we're just going
to use a beamy light. Well, actually,
I guess technically it is a sharpy because beamy is another type. So I'll use the import here. And I had already-- so I'd
already dropped the file in. But literally, you just drag
it into the Content Browser. And so I'm going to use this one,
just because I know that it works. So I'll set my category
to Moving Head. It's not a matrix. And then so you can see the
two modes that already came in, so standard and vector. And it automatically detected
how many channels are in it. It's set up a-- and it did the mapping for me,
for all the ones that it understands. So if there is one of these
it says selected value, that means we don't have
something currently for that. So we're going to-- you can either pick something or,
if it's something that you don't think
you would use internally, you can just leave it blank. So again,
for something like fixture mode or maybe global
reset or lamp control, these aren't things that you're
actually going to visualize. So there's not necessarily
a reason to assign them. But you can, if you want to. Then same thing, it detects
if it's 8-bit or if it's 16-bit. It already determined
these things. And it also should read the
default values from the GDTF as well. So if you are working with
real lights and there is a GDTF, it's insanely easy. If you are working with a
light that doesn't have one, it's not too hard
to create your own. But it does maybe
take a little bit more. So I see stuff blowing
up in the chat, just out of the corner of my eye. All right,
so the last part of this that I'll go over as
far as patching is we added support for our
matrix fixtures in 26 as well. This is something
that wasn't in 25. So if I add a new
type-- and let's just say it's an LED
strip light or whatever. Let's do a 5 by 5 matrix,
like a cube x or something. So I didn't have
a profile for that. So I'll show you just
how to make one. So again, this category
doesn't necessarily matter. But just for the sake
of being thorough, I'll put it in this category. But this is the
checkbox you do need. This tells Unreal internally,
yes, we want to use a matrix
style for this type thing. So when I add this one,
I'll get a different kind of look in these two windows,
and the reason being a matrix is essentially just a lot of
copies of the same thing. So rather than having to define red,
green, blue, red, green, blue, red,
over and over and over again, you can just define it once
and tell it how many cells it has. So in this case,
we'll just say this is RGB mode. And then we can tell it
how many cells are in it. So we're going to go 5 by 5. And then this is the
sorting distribution because, if you imagine a 5 by
5 grid, it could go up and down, it could snake side to side,
it could go in rows. So this is almost every
conceivable combination, except maybe a weird
spiral or something. I don't know. I've never seen one like that. And then you tell it what
are the cell attributes that are in each one. So we can go through and say,
OK, this one is going to be our red. This one is going
to be our green. And this one will be our blue. And so then you'll see,
over here on the right, we're getting some different
information where it says, OK, we're starting at 1. We have 75 elements of-- so 25 times 3 gives us our 75,
right? Now, some fixtures also
have extra control channels that will sit in front or
behind of the main thing. So you still can add those. Currently though,
there is a limitation that we only support
them on the front, so before the matrix things. And it's giving me
a warning right now, like something's going on,
like you have an overlap here. And that's because I
told this guy it starts on 1. When, in reality,
if I have a dimmer there, I probably should start on 2. But what I'm,
I guess, talking about is if I wanted
this to actually be channel 77 and come after these,
right now we can't actually do that. They can only be before. So that's something
we're going to fix, but just to keep that out there. But again,
this is somewhat unique. It doesn't happen a lot,
but just in case you run into it. So I'm actually going to
delete this because, to me, it's just extra junk. And we'll save this. So now, we have one matrix,
one moving head, one static picture. And we can use this
to pop into the world and actually play
with these things. I think that was
mostly everything. Oh, well,
I should patch them, right. So if I don't patch them,
I won't be able to use them for anything. So we'll add in our sharpy. So we'll just add one of
these guys and put in a 5 by 5 matrix. And the only reason I
number them like this is that way,
if I want to make more and you duplicate them,
they just increment nicely. So to make it easier just visually,
we'll do that. So there you go. All right, so that's-- and obviously,
if you're a lighting person, you've probably done
lots of patching in your life. You understand how this works. You'll add a bunch
more of these. And you'll populate
your show that way. So if we come back out to
the viewport and look at then, OK, well, that's great. We have a patch. Now,
how do we do something with it? So one of the-- if we enable it in the plugins,
the DMX Fixtures Content, we actually ship some pretty
good example of fixtures. So we give an example of a
moving head, a moving matrix style. There's a moving mirror,
which I actually rarely ever use-- the static LED,
a strobe, a matrix, and a wash LED-type light. And then it goes through
what makes these a little bit different and unique. But one of our TAs, Francis-- big shout-out to
Francis because he did just an awesome job
making these things come to life. And not only that,
but he put in some nice little tools and nice little things
to make it easier. So in the previous version,
in 4.26, it was kind of like a big,
uber Blueprint that drove these things. And it was almost more like
a proof of concept, I suppose. And now,
it's turned into its own system. There's a DMX actor type. There's a class for it. And all the different things
you can do are components. So we wanted to
make it easier for people to create their own variants and
versions of things because part of what makes lights
interesting is that they don't all do the same thing. When you look at this one,
it has different capabilities than this one does. And so trying to
define all those-- I mean,
there's literally probably millions of light
types out there-- it's kind of daunting. So we wanted to
make this a nice system that people could
work on their own and develop their own libraries. Or possibly,
maybe some entrepreneurial-type will create one in
the marketplace. So if anybody's got a lot of
free time and wants to do that, I think it's a valid thing. So it might be
something to look into. But again, so I'll show how
the structure works and show, hopefully, some more fun stuff. All right, so if you are just
browsing through the thing-- and again, if you don't
see that for some reason, you may be missing Engine
Content or Plugin Content, right? So if you need-- if you don't see it. So I'll just-- actually,
what I'll do, I'll just start a new level. And I hope I don't
muck up this one. And I'll show everybody
my super secret sauce of how I make an awesome level. I literally just add in
the HDRI Backdrop, so another nice
another nice tool that came a little while ago. VICTOR: Do you still have
to turn on the plugin for that? PATRICK: Yeah, it is a plugin. And now,
there's actually some more-- I've noticed there's some nice
cubemap textures that came-- I don't remember
what version is. I like the ambient sunset. It's just I feel
like usually what we're doing is always dark. And then maybe
I'll bump that down. And I always feel
like I end up putting this kind of low because
lights work in the dark, right? So if I just drag
one in from scratch, this is kind of what I'll get. And we'll put them back at 0. And actually, I want them
to sit on the floor, right? So this is what will pop in. And by itself, it's not going to
do anything because we haven't told it which address are you. So all that stuff we
did in the patch earlier, we have to tell the
fixture which one you are. So I only added one. So I'll just leave it
at 1 for right now. And I guess, in the future,
we could maybe add in a couple more of these guys. So we have one of those. We had, if I remember correctly,
10 of these, right? I'll do this and do that. And then we had one matrix,
right? And so that's what I made in
my little pseudo-patch there. So looking at this
in the Details panel, you can see that structure
that we came up with for this. So inside this part just
being the actual meshes and the nesting order of it,
and then you have these
components that define what can this fixture do. So again,
this is just an example one. I happen to know it just
matches with the sharpy footprint. That's why I use it. But if you were
using a different light, it's not necessarily
going to grab the box because you have to tell
it what kind of parameters does it have. And actually, this isn't even
100% accurate for sharpy because sharpies don't
have zoom in real life. But I like to use it. So mine does. So these are all,
I guess in this case, inherited because we just
give you this one example. But you could literally just
remake this on your own, if you were super inclined. So for example,
if I create a new folder-- we'll just say a new fixture. If I were actually to go in
here and create a new Blueprint and search for DMX,
you have this DMX Fixture Actor. And you also have this
DMX Fixture Actor Matrix. So I could literally just go in here,
do one of these, and literally build it from
scratch if I wanted to. It comes with the hierarchy. It comes with the DMX component. But then I can manually
add all those components, if I wanted to. I honestly think that is
a really long way to do it. So unless you have a super
useful reason for doing that, I wouldn't recommend it. Let me save this,
in case something bad happens. I also wouldn't recommend
naming it New Blueprint. But yeah,
so I probably wouldn't do that. And also,
that means that I also probably wouldn't drag these directly
out of the Engine Content into the level. And there's a couple
of reasons for that. But mostly,
anything that's in here is subject to
updates and changes. And it's also local. So if I drag this out and
then I edit this master Blueprint and send this to somebody else,
it's not going to use my changes. It's going to use whatever is
in their local Engine Content. So not best
practice necessarily, to drag them all out. So what is the
best way to do this? So you have two options. One is that you can
either make a copy of it and put it in your
local directory. This is great if you
know you're going to make certain changes
that are going to be exclusive and you only want to have them. The other option
is to make a child. And this is the one
that I recommend. So what you do is
you right click on it, create a child class. And then we'll just say,
OK, this is going to be my live stream sharpy. And so by making it a child,
what I'm essentially doing is I'm able to use all that
are inside the main one, but able to make local changes. Also, if we happen to-- whatever-- find a
bug in the fixture-- if something's broken,
we update it. We push that in
the next version. Since it's still inheriting,
you'll get those changes. Now,
that's not 100% across the board. I want to make that very clear. It's possible that
something in-- if we change how
Blueprint Mode works, you may have to
reconnect some wires. But for the most part,
it's going to all update nicely. And I also just like this
because then you have this nice level of inheritance. It's one of the powerful things
about Unreal that I think maybe is not as well understood
and used sometimes. But if I were to then
make a change to this, it would then filter
down to everything. So this gets treated as
just what it is, as a parent. It's my parent class. But I can then override
it with things locally. And then from there,
every time I drag one of these out, I can make even more
fine-tuned changes. So it just gives you a level of,
I guess, control and structure. So what I recommend is I
actually make a different child class for every type of light
that I'm going to be using. So for example,
in addition to this sharpy, if this wasn't the only moving
head that I had and I actually had a different one
that was whatever-- let's just say this one was a beamy. I don't remember
how to spell it. These two lights are going
to have different properties, right? There going up
different zoom values. They're going to have
different max intensities. They may have different things. So in order to
define that nicely, I'm going to make two
different child classes. So I duplicate this one over. And I would just say,
OK, this one is a beamy. Now,
I can define these separately. So I can say, OK, sharpy,
your max intensity is actually-- these are in candelas. So just know that. And we could say,
all right, this beamy light, you actually don't go that high. We'll leave you at default,
2,000 or whatever it is. And so that way, I can have
two different versions of this. But they all have the
same functionality. And then I could
even make it even more granular inside the Editor,
if I wanted to. And I could have
two identical copies and just say, OK,
you're going to run at high quality. And you're going
to run low quality. And so it's just really,
really nice. I can make global changes. And that's how you
do it at the class level. So that might have
been a long explanation. VICTOR: Well, it's important. PATRICK: Yeah. Well, again,
it's one of those things where,
if you make these decisions earlier, you will run into
less problems later. And it's something
that when you're like, how do I affect all of them? And then you're like,
oh shoot, it's in Engine Content,
that kind of thing. VICTOR: Something a programmer would learn immediately, right? PATRICK: What's that? VICTOR: It's something
a programmer would learn immediately, right? But if you come into
the engine as a creative-- PATRICK: Yeah, exactly. Sometimes,
I feel like-- yeah, when I'm talking to a comp sci major,
they're like, well, duh. But yeah, you've got to remember
most of our people are artists. So they don't know this,
myself included. I didn't a lot of
this stuff prior to working in Unreal and
in game engines in general. So we have our sharpy light. So now,
we have our proper child. But just in the
interest of time, so I don't keep
making copies of things and you guys just watch me copy,
I'll just use these ones out of here. Just know that's
a no-no usually. So we've got those back. And then we've got
our stack matrix back. So now, I want to be able
to tell it what these things do, who they are, that kind of deal. So I know,
just because I've done this for-- I've been working on
DMX for like a year now. I just know these
things are going to work. But I'll show you why I know that,
I guess. So this one, the reason this
one I know is going to work is because it matches
the channel step and it has the right
components that match what I did inside my patch. So I know it has
these things on it. So by default,
this one comes up a lot. A sharpy just has a color wheel. There's no color mixing on it,
whereas a lot of modern lights do have some
sort of color mixing. So if I wanted
that functionality, I would have to modify
this and add it to it or do something else. So I'll show how that works. But first,
let's just go with the default. But the most important thing
I need to tell this thing really is what is the patch
reference that follows this. So I made that one. It was called live stream,
right? And then when I select it,
here are the fixtures that I patched earlier. So I'll just put it on Sharpy 1. And then technically,
that guy is good to go now. So you can get this idea
that this could actually be a fairly slow process,
if you have hundreds of these things, to go in here and have to
manually tell it each time where is it. So we don't actually
ship this with the Engine. But I made this
publicly available. And it's a nice
little utility widget. And it's very, very simple. I won't go into too
much how it works. But essentially, I can grab
all of these fixtures in order. So it's going to go in
selection order as best I can tell. And I can patch all
these things in one go. So I have to tell it first
what library and what is the first fixture
that I'm going to use. And then I can say, OK,
address them incrementally, go to the next one each time,
or address them all the same as this one. Or I can do address and rename,
which is nice because then it's going to grab the
name out of the patch also and rename it in the world,
which is more than likely what I want. So all that really does,
though-- it's just a fancy for each loop, essentially. But going through,
and it's just going to go through and incrementally
do each one of them. So super handy,
but you could always just go and do it manually. And same thing with this matrix,
I just go in and I could do it
manually and just pick Livestream and Matrix. It does the same thing. So just a couple of things to
note on the structure of these because it is a little
different than the old version-- previously,
you didn't see the patch on the root. You actually had to scroll down
and click on that component. We now have that
available on the root. You have these options
as far as quality level. So in this version, Francis-- again,
can't say thank you enough-- went through and got rid
of the old system, where we were basically just using a
mesh to create the beam shape and run a really cool
raymarched solution. So you got a much,
much better quality look to it. But that has definitely a cost,
right? So you can define
here how many samples do you want to use for it. So if you are incredibly
far away from the light, it's almost visually
indistinguishable between low and high. So depending on where
they are in your stream-- or I'm sorry, in your venue,
you may want-- you may just want to do
that for performance reasons. So you can define that. You can define the light
intensity max, the distance-- the distance is how far does it
go before we start attenuating. I know, of course, in theory,
light goes on infinitely. I've taken physics. But this is rendering. So we've got to at some point say,
all right, when should we stop drawing. And then also,
you can set a color temperature. And then you have a
couple other settings, like whether it should cast shadows,
dynamically occlude. And then these spotlight
and pointlight intensity scales are just meant-- you can use both of these,
if you so choose, if you wanted to have it
flare and do something else. And that was just a
little handle for that. But I generally don't use them. I just stick to these things. So on these components though,
they also have settings. But again,
I probably wouldn't want to touch it here because
then it's just going to do it on that one light. I would want to make sure I
go back and do that on my class. So if I was actually going
to make an adjustment to the dimmer and say, OK,
I want this to cap at a lower value, I'd want to do it here. That way,
it does it for every light type-- light that is deriving
from this type. Same thing with-- let's just say,
for example, like this frost one,
if I'm not going to use it, I can disable it. So that way, it's not going
to do any calculation with that if we don't need it. But for the most part-- and then also we can
add a component to it, too, if we wanted to give it
some extra functionality. So if, for example,
this light had color mixing, I could add this
color component to it because it comes only with
the color wheel by default. So if you scroll down in here,
there's a DMX section. And it should have these
options for you of the other things that you can add I've noticed that--
and I don't know if this is just because of
the version that I'm running-- that sometimes certain
ones will actually pop up here in this Custom section,
like this Gobo Spin. I know it's definitely
a DMX component. But as soon as you add it,
it seems to pop into it. So I'm not exactly
100% sure what that is. If you are unsure,
you can always search for it, right? We love search boxes. That's kind of our jam,
I feel like. All right,
so we've got this guy. He's addressed. He's ready to go. He's got some basic settings. So now,
let's make him do something. So what I actually
use to control-- I actually use this
ChamSys MagicQ. Since I don't have
a lot of real estate, I'm going to do most
of that work off screen. But it's essentially
just it's a free-- well, this version is free. They also make consoles. And they also make
other nicer things. But this one, they give you
a certain amount of universes that you can use for demo
mode and for reviewing things. So I had already patched
a show in advance. But in order to make this work,
I'm just going to go back-- and yeah,
it's easier for me to match these, honestly,
to what I did on the ChamSys. So in that case, these
actually were in the universe 2. And the sharpy was
actually the first one in the-- hold on, actually,
all these were in universe 2. And this was
actually the first one. And where was my matrix? Was it 101? Which kind of makes sense. OK. So in case you guys are
wondering what I'm actually doing, I just wanted to
make these numbers here match the ones that I'm using,
so I don't have to reprogram the MagicQ, too. All right,
so the lights only work either when you're in Play
or Simulate or obviously in Standalone Game, all right? So in this case,
I'll just pop into Simulate, so I can still do some
editor stuff as well. And so then I can start
to play with this light. So again, I'll show it. But then I'll move it,
just because I don't have a lot of real estate. But I'm actually
just adjusting what I'm doing the same way that
you would on any other console. And so you can keep as
much of this window as possible. So we can see a few things about it,
like what's happening here. So it does start to-- it does
have this nice little fall-off. But if I were to
adjust this distance, I can cap how far it
goes or increase it. Now, buyer beware,
with great power comes great responsibility
because the further out that it has to go,
the more it keeps drawing. This is just general
graphics optimization things. But you can make these
adjustments to them. And same thing-- now,
the intensity is set to like 5,000,
which is somewhat ridiculous. So if I was like, no,
it's really more like 2,000, I can make those
adjustments on it as well. But that's the basics of how
you would just get this guy going. And then again, because
this is in Scott's Color Wheel, that's cool. And then we also support gobos,
which are the beam shaping part,
which is the really interesting stuff, I think. This is what makes,
honestly, this new system, I feel like,
look so much nicer than the old one. The old one,
if you were to look at it dead-on, you would never
really get this effect because it's just a
double-sided mesh. It was not really
possible to get this nice look of like looking
down the barrel of a fixture. So that's the main
change that I felt like was so obvious
because before, if you were just sitting there
and the light would tilt down and sweep across the camera,
you just wouldn't really get this effect,
which is super nice. But I mentioned earlier that
I like to have zoom on this fixture, even though this
fixture in real life doesn't. However, if you were going to-- if it's just a virtual show
or something like that, you could definitely-- you can definitely do it. So all I would really
need to do is go in-- and so on this fixture type,
right now, I have focus hooked up to focus. Now, we don't necessarily do
anything with focus right now. So I'm just going to use that
channel and remap it to zoom. So all I'm doing
now is I'm saying, hey,
if I send focus on this thing, don't send it to
the focus attribute. Send it to the zoom attribute. So now, when I pop into Simulate
again and do the same thing-- wait, I'll dial this up-- so now, you can tell already
it's using the parameter, right? So the zoom settings here
start off fairly ridiculous. I can't remember where
those values came from. But I'm going to
adjust them down, just in the interest of
keeping it a little bit more sane. So you might notice that
these numbers seem reversed. That is intentional
because typically, on a console, when you first-- zero values are lower. And I guess the way
zoom is described is backwards of
what you would think. So that's why they
are backwards. You can put them the other way. It's not going to hurt anything. But it's just, if you want it
to match with a console right to the box, it's probably
better to leave it that way. But you could remap it,
if you felt like it. OK,
we'll pop back into Simulate. So now, we have a little bit
of a normal thing going on. And now, I can adjust my focus. And it's going to
adjust the zoom here. He also did a pretty
nice job of-- like I said, so we actually took the
publicly available gobo values. So we can go through and
use these beam shaper things for it. He also simulated what
would happen if you do a scroll. So these things have the ability
to do a gobo scrolling, which is pretty cool that it's
supported because that's somewhat what
it would look like, if it was actually
scrolling across the lens. Yeah, and then he also did
a little bit of a shake thing, too. And like I said,
it supports the color wheel because this one is a color
wheel function type of light. Oh, and then he also did strobe,
right? So you could always just
turn it on and off by yourself. But he's actually added a
dedicated strobe channel. So he tried to emulate-- we're not actually
looking at the real thing. We're just looking
at the documentation, what it should do. So that's the really
down and dirty simple how to get this light working. So similarly with
these LED pars, since they're already patched
as well, I can play with them. So I'll just turn those
on and do RGB dimmer. So there we go. All right, cool. So same thing-- I'm just doing it on my
console over here on the right. But these are
actually color mixing. So instead of using
the color wheel, I'm actually able to adjust
exactly how much of each color I want to have in them. And then they also have
an intensity master on them as well. So by default,
these things also have-- you can see they have a zoom. They have a strobe on it. I'm not using them. But you could use them,
if you wanted to. And then the last one
is going to be this matrix. So the matrix is
a little bit different, in the fact that we actually
made a procedural generating system for this because
we made the assumption, at least in this case,
that it's usually going to be a grid, right? So it's either going to be 1 by
something, or 5 by something, or whatever it happens to be. So by defining in here
what fixture you're using, it has the information about
how many cells are in it. So then on the base level,
we can say, all right, what is the overall dimension
of this light, and width, and height, and depth. And we can say,
generate a preview mesh. And so then it will
generate this mesh of what that fixture would look like. So it's a 5 by 5 grid in it. And if I change this and make
it bigger, that'll work as well. I could also make this 10
and make oddly shaped things. It just depends on-- obviously,
if you're going for realism, you would get the real word
measurements and do it. And then it's the same thing. It's got intensity setting,
all these other things. So it's patched. That one's good to go. We can pop into Simulate. And same thing,
where's my Cupix. I think it's this one. Yeah, there we go. Cool. And same thing,
these are color mixing. So you can dial in as
much or as little as you want. Or if I throw a red flick on
it and do include elements, yeah, something like that. So again,
they show up as individual cells. So it's kind of cool, actually. I like these
matrix-style things. It's a nice thing that we didn't
have in the previous version. It just wasn't really
easy to do before. So now,
we've made it pretty simple, I think, in that aspect. So talking about modifying
these-- because again, if you're into doing previs,
you probably know a lot more about
these lights than even I do. So there's a lot
of customization that you can do now that
before was somewhat much more complicated. So now, literally,
you can just come inside the class itself and define what
you want the meshes to be. So if I was going to swap
this out with something else, I could just change what the base,
the yoke, and the head are. There's also a separate
one for the lens. So you can use our lens, if you want,
or you could swap it out. And an example
of that would be we count this other wash-light
fixture because they have a different look. If you look at this,
the front of it, you'll see the
individual lights rather than just having like a lens on them,
so to speak. So this one just uses a
different lens in here type than this one does. But also,
you can also affect some other things depending on what it
is you're trying to do. So on this matrix,
for example, not every light has this octagonal-type shape. So I could actually swap that out,
if I wanted to, as well. Since, again,
I just drug it right out of here, I probably don't want to
do that because I'll modify it for the Engine Content
for every other project that's referencing it. So what I'll do-- again,
I believe I already made one of these. So I'll just drag
it out of here. I've done it a bunch
of different times. Matrix 1, sure. So now, I can edit this one. And so this one looks
like a copy that I actually-- oh, yeah. And so on this one, we had-- actually,
this was an undefined one. So you can see there's
nothing in any spots. So I'm not going to use
that one because I don't want to recreate it from scratch. Static matrix style-- yeah,
there we go. That one looks better. OK. So you can see how
these different materials apply to it. We have a lens material
and a beam material. So if I go to this matrix
lens material and open it up, you'll see what
I'm talking about. So if I put it in a cube view,
so that's what each cell is going to look like,
more or less. But if I wanted to, I could
pick a different type of lens. So we give you a
few different options. So I'll just throw
maybe a circle one because, if you're using
Cupix or something like that, it might look like
that or whatever. It's just you can
honestly pick-- let's see what else we have-- something like that. Or it could be
something even crazier. You can just put a logo on it,
if you want. I guess it defaults to circle. But I kind of like the-- I'm actually a fan of the other one,
the boxier looking one. Yeah, I like this one. It's got a thin little
edge around it. Yeah,
it's going to bug me about that. So right,
because I actually modified it. So again,
I don't know if that was obvious. But that's what happens,
in this case, where I'm trying to
modify Engine Content and it's being referenced
somewhere else. So I probably
wouldn't do that if you don't know what you're doing. You might want to
actually make sure that you leave these alone. And again,
you make it in a material instance, in that case. All right,
so that's the basics of getting these in, patching them,
modifying some certain parameters of them. So I'm just trying
to think if there is anything specific about these. Oh, right, we talked about
adding that color component. So if I had another
fixture that didn't have that, for example, on it,
what I would want to do is-- again,
on the copying class that I made, I would add the other component. So I would go-- and
I'm looking for color. So I'm just going to add
the color component to it. And then this would
give me this option for adding a color
mixing component to it. So if it has a color wheel,
great, we could keep it. We could just disable it. It just depends on, again,
what the light can do. And then we'd be able
to link this red, green, blue to something in the patch. Something I know that's
come up a few times is people have asked, well,
some lights mix in cyan, magenta, and yellow. But if I change these,
it doesn't do anything. And that's really because
this doesn't, by itself, do anything. It's literally just a reference,
like what's coming in here. So if I have a light that is
coming in red, green, and blue and I'm just sending it to cyan,
magenta, and yellow, there's no logic in here. And these are just names. So you'd actually have to
modify the Blueprint itself, if you wanted to actually
make this work because, even though technically red and
cyan are inverses of each other, it's not just the
same as putting the value in its inverse because
100% red to 0 would just be 0. So it's actually a
different format than that. There's nothing that would
prevent you from doing it. You just have to put that
logic into the Blueprint. So if you wanted to do that-- if I look at the actual
light fixture itself, so you can see
what's inside of it, the Blueprint is very,
very simple at this point. There's not a lot going on here. We initialize the fixture. We do occlusion if it's checked. And then literally,
we update it. And that's pretty much it. So if you wanted to do an edit,
this is the place you would do it
at because this is where we're defining, OK,
what's coming in and here's what's getting pushed to the fixture. So just as a different example-- so I'm just going to
copy and paste this one, rather than do a child, so I
can see still what's inside of it. But this value per
attribute that's coming in is actually going to
be different depending on what the fixture is. But it's in this part here that
we could actually determine what we want to have happen. So if we knew for
a fact that we were going to have red coming in
and we wanted to change it to do some math and then pass it
back to change it, to invert it, or something like that,
this is the area that we would do it in. So if anybody was trying to make
cyan, magenta, yellow happen, that's the spot
you want to do it in. And then I think that's it. I definitely want to cover
some of this pixel mapping stuff. Oh, I'd like to cover a
couple of other things. But I don't want to-- VICTOR: We've got time, Patrick. We're only an hour in. PATRICK: Yeah, I know. VICTOR: Would you like to answer some of the questions in
regards to these topics first? PATRICK: Yeah, I feel like I see a bunch of stuff over there. So yeah,
was there anything that you saw that was popping towards
the top or something like that or recent? VICTOR: Yeah,
since we've got some time, we can go through some of these. And then we'll dive
into the pixel mapping. PATRICK: Sure. VICTOR: This was
discussed in chat but, RawBengal asked-- PATRICK: Hey, Rob. How's it going, man? Yeah, I know Rob. VICTOR: Parentheses
fixed received DMX rate, how does that relate
to the actual rate packets that are coming in from console? Don't you just process packets
as they come from the protocol? PATRICK: Interesting. So technically speaking,
network timing is way faster than DMX would ever be,
right? And actually, technically,
on network received is faster than tick even. And so if we were to actually
process that every time, we'd just be doing a lot of
duplicitous processing work. So our guys came up
with this nice system internally that,
rather than just doing it at the fastest rate possible,
DMX technically can't go any faster
than 44 anyway. So we can actually
set a global speed limit as far as, all right,
how fast do we really need to update everything. And technically,
if you're coming out of GrandMA, I think it's even
only coming at 30. So what that
would actually do is it would be able to
have you be able to limit, if you wanted to, even further
and try and match things. But internally, what's actually
happening is everything is-- especially if you're
using our fixtures, we use this on
fixture patch receipt. So what this actually does
is it takes all the DMX that's coming into the buffer. We'll actually check to see,
OK, does the value that I'm updating match
this particular patch that I'm going to
try and update? And if not, ignore it. And it's really a speed
thing in order to do that. It's actually pretty nice because,
in the past, there was another
node that was-- shoot,
I can't remember what it was called-- on protocol received. And I think we
actually got rid of it. Oh no, it's still there,
on protocol received. And basically, that was always
grabbing the entire buffer. And then you'd have
to filter through it. And so this is already
doing it automatically. So for us, yes, we receive
it as fast as it can come in. But then we shrunk it down and say,
OK, if it can only be done at 44 hertz,
how quick do we actually need to update this? And so we pushed
things together. So if you get 10 zeros in a row,
we don't process 10 zeros. We just wait, buffer it. And then it's like,
OK, this is the value that we're sending,
and then send it. And since everything's
working off interpolation anyway, it just works much, much better. So hopefully that answers that. VICTOR: deadmau5 asks,
hopefully in future versions, we'll have the option to
enable or disable the spot flash pointlights in the C++
fixtures without having to turn their intensity down to 0
to save a wee bit of perf. PATRICK: Wait, say that again? That last part? VICTOR: Hopefully,
in the future versions, we'll have the option to
disable the spot flash pointlights in the C++ fixtures without
having to turn their intensity down to 0 to save
a wee bit of perf. So I guess the solution
now is to turn intensity to 0. But if we can actually turn-- PATRICK: Yeah. Well,
I think what he's referring to is we have this thing
in it now where this toggle light visibility,
which essentially what it does is-- yeah, once the dimmer is
actually all the way down to 0, it kills the light completely. And then yeah, you get back
all that performance, right? And so this brings
up an interesting topic, just in the fact
that why are these-- what makes a light
expensive to render. And really, what it is-- because
even though we have pointlights and spotlights on,
if it's not casting shadows and it's not doing occlusion,
it's not really that expensive at that point. It's just going to update
like the part that it hits, its color. And that's not really that
expensive of a process. But for us, the really
expensive part is the beam itself. And that's based off
a number of samples and this complicated math
as to what goes into that. And that's why we give you
that control over this quality level. But at the end of the day,
all this stuff is just materials inside of Unreal,
right? So something that I've
have been playing around with-- if you actually
want to dive into it and if you're nerdy like me,
there's this material
instance for the beam. And here is the actual
masters themselves are in here. So if you open up
the Beam Master, you can actually
see what all it's doing to create this
nice looking beam. And it's definitely
more complicated than I would have
been able to write. But as far as materials go,
it's not too bad. But what is actually
determined is quality level is actually this node here. And then I believe it's
used one other time here. So this is actually
the main one. This one over here is just to
do some jittering to try and hide, I guess, part of-- do some of the blending
to make it nice looking. That one's not
quite as relevant. But this one right
here is the one that really determines
what is going on, how many samples are we
using to make this light look nice. And it's just
something I've actually done in a personal
project is actually written some other code to modify this. Really,
you only need a lot of samples when the beam is
extremely narrow or it's got something in it. So a quick just example
on this because this is something that's just
new that I've found out-- so if we zoom this
beam way down-- I mean,
probably even thinner than this-- that's when the quality
becomes more obvious. So if I drop this down to low,
you can see it gets noisy and crunchy,
especially at the most narrow parts. But when you're up higher,
further away from it, or, even better,
looking straight through it, it's not as obvious,
especially depending on what your intensities
are and what you're doing. So you can actually
modulate that differently maybe than we are, if you want to. And so I think if
people are really looking to try and get
some more perf out of it, that's where I would tackle it. But as far as turning on and
off components, you can do it. I mean,
there's nothing necessarily that prevents you from-- because right now,
we're not even using the pointlight, I don't think. You can just turn them off. I actually, in mine-- generally speaking,
because you'll notice if these are facing-- let me grab the actual light. I did it again. If they're facing down-- if you have a lot of these,
this gets kind of obnoxious. They will be all over it. So actually, in mine,
I actually just go in and turn off the spotlight component. That way, when I'm
lighting them up in the world, I don't get hundreds
and hundreds of these-- oh, I did the wrong one-- light balls on the
ground because it will get-- all of a sudden,
your scene will be very, very bright. And it may just not
be very easy to do because, at runtime,
of course, if we do something, we're going to turn it back on. But that way,
it's off when you're in the Editor. So cool. Another question maybe
on any of this stuff? VICTOR: Yeah, for sure. A little bit on the same topic-- cmndrmusic asked,
how many fixtures could reasonably be
driven by the engine on a single computer? PATRICK: That really
depends on the settings of the fixtures. But we've done
some tests internally. So especially if it's
something like matrix fixtures, or magic panels,
or something like that, where there's not a lot of beam-- I have another--
let me save this. I have another level in
here that I do my tests on. This is what I'll do. So I have like 120 of them here. And this will actually run
at 30 FPS at 1920 pretty handily because it's all CPU. Now,
something you will notice when you're doing this kind of stuff is,
in Editor, not so much because
we're drawing all the widgets and stuff for the UI. You'll notice a lot more-- so again,
this gets a little nerdy. But you'll notice a
ton more game time when you are in Editor versus
when you are in Standalone. So if you're getting
hit on your game time because you're just
processing too much DMX stuff through Blueprints and the UI,
if you go into Standalone, it'll be like almost negligible. Usually, where I find,
though, most people get hit is on the GPU. And that is based off-- it depends on how many
lights are in the scene, what the widths are,
and how much overdraw you have because that's really just
the main source of this is it's all translucency being added. But that's why I was saying,
if you're running into that,
dropping the quality level drops the number of samples. So it's being added less times. So if you go in and
modify that material-- I literally just did
some tests on it. And maybe I'll actually
do a separate thing, where I show how I did it. But I just clamp the range so that,
OK, if the beam is very narrow,
make the quality high. If the beam is wide,
make the quality low. And so that way,
when they're overlapping and they're really wide,
it's not that bad. It's almost indistinguishable. And so it's a nice way you
can get some perf back there. So hopefully,
that helps answer that. But it really just depends. I have the other
demo level that-- I guess I could
show that one off. Why not?-- where the
fixtures actually came from. So I have a different
MagicQ file for that. So let me just quickly save. VICTOR: I can
also add-- if you're looking at Patrick's statistics
here for performance, Discord does eat up about 20%
to 30% of his GPU at the moment. PATRICK: Yeah. I mean,
there's a lot of factors here. I run dual monitors. I run everything at
terrible resolution. And as you can see,
there's a bunch of junk open on the bottom that
probably shouldn't. But yeah,
it really just depends. If you want to do proper
benchmarking on it, we recommend definitely
run it in Standalone and pick the res you want. Try not to do DPI scaling. And you'll get a much better
metric for trying to do stuff. All right,
but if I go into this and I just plug in the selected
viewport-- and let's see here. Oh, I think this one I
turned everything on Ultra. But I mean,
so you can see like our frame time is decently high. We're hovering
here a little bit. But still, I mean,
that's a decent amount of lights, I'd say. And again,
a lot of it just depends on, from there, what are they doing,
how much overlap is there, stuff like that. So just by default, if I take
these and start zooming things out,
you'll definitely notice that time start to creep
up pretty rapidly, depending on how much
they are overlapping. But in a lot of cases,
it's pretty good. There's-- I can't remember-- maybe about 200
or so in this scene. So again,
it's at a slightly lower res. I can do a 1920 x 1880. And this is windowed. But I mean, it just depends. We're still hovering above
30 with all this other gack running. So it's pretty good, honestly. But distances is matter too,
right? So all these are probably set to
relatively modest draw distance probably, if I had to guess. Yeah, 1,500, right? So if you put all these to 10,000,
then yeah, it's going to take a little. So hopefully that helps. VICTOR: DJ_MidKnight asked,
can you apply a custom gobo projection? PATRICK: Yes. So that's a really
good question. Thank you for bringing that up. So all of our lights-- oh, sidenote-- we also included
some fun little stage props. I don't know if anybody
noticed they're in here. I know there seems to be some
discussion on whether or not pipe and drape is
actually a lighting thing. But we'll leave that alone. But yeah,
these are also in here as well-- so some trusses, some corner blocks,
and just some little pieces that make
your stage look nice. But if you were going to add
a custom gobo-- so right now, if you look at the Blueprint
for the moving head and look at the gobo component,
you'll see what we have is
actually to a clean disk and a frosted disk. So this is the way we deal
with frost is, rather than using a blur function,
which is super expensive, we just create a frosted
version and a clean version. So if you look at it,
what it actually is, is it's just a strip of all the
gobo textures in a line. So that's how we can also do
the fade or slide between them. So you can either
create this on your own, if you feel like it, or-- again, big ups to Francis. He wrote this Bake
Disk Textures tool for you. So it's actually an
Editor Utility Widget. So if you run the widget,
you'll get this nice little thing here. And so you have to make
your effect table ahead of time, like what it's going to-- and that might be a
longer topic than this. But if you look at effect
table that is provided, this is how we control this. So we have this gobo
table and gobo wheel table. So if we open it up,
this shows what this thing is doing. But here are the texture
assets that we're using. And then you can
use his Baker widget to bake out your own strip. And there's one
for colors as well. So same thing-- our colors are
based off these color swatches. And then we just bake them
into a little strip, which would show up on the color wheel one. Same thing-- so you
could also do that as well, if you have a known color
wheel that you wanted to. One thing to keep-- yeah,
you'll notice on this one, the size of it is very small. Again,
that's for performance reasons. But on the gobo, you might
want to make it a little bigger, just so you can get a little
more resolution on what these things are
when they're being projected onto the ground. Cool. And also,
maybe I just realized something else I didn't mention. But we also have
sample assets for pyro, sample assets for lasers,
fireworks, water fountain. And if you want to see just
a quick demo of all these in action, there's actually
a DMX template project. So when you first
launch the engine and you can pick First Person
Shooter and stuff like that in the game one,
inside the [INAUDIBLE] one, there's a DMX sample. And it's just the guys
recorded in some DMX. And it just plays
back in Sequencer. That way, you don't have
to have a console hooked up, or something like that,
to make it work. VICTOR: Cool. I didn't actually know that. PATRICK: It's brand new, yeah. I would show it,
except I don't really want to show my launcher. But yeah, so I can do one more. And then I can pop
in the pixel maps. VICTOR: Sounds good. Let's pick one last one then. ridderhasp asked,
when using ray tracing, the light beam
goes through objects when using volumetric fog. Is there a way to fix
this without being hacky? PATRICK: Probably not. Honestly, I don't really
run ray tracing that much. But more than likely, we're just
drawing a mesh or a ray march, I guess. But essentially,
it's going to go through objects unless we specifically do
something to have it not do it. But again, if it's going
straight down, super simple. But if it's on an
angle like and you're getting a cut off at an angle,
then probably not. But it's something you
could definitely look at. But similarly,
just if you turn on shadow casting and occlusion, it just depends
on how many lights you have, if you can get away with it. I would say that
plus ray tracing, you're probably
in for a bad time, if you have hundreds of them. But if you only have 10,
sure, maybe you could. Cool. VICTOR: All right. Yeah,
let's go into pixel mapping. And then if you have
more time in the end, we'll get to some of
the questions in a bit. PATRICK: Yeah, yeah. We can press on in that. So yeah,
pixel mapping is super cool. It's a new feature
that we put in. And really,
what I wanted to show off was just how it
works in general, and then maybe
a virtual production use case,
because I think this is where I'm seeing a lot
of good use case for this. So yeah,
this is my old test bed. I was playing around
with some strip lights. And this is the octobeam. And these are
what the lasers look like when they're just in
level not doing anything. So for pixel mapping,
again, all you need to do is create a pixel mapping asset. So I will just make
one from scratch again. I'll call this Livestream Pixel. And when you open up,
you're going to get this new-- let me close some
of these tabs here-- this new window
that launches up. And again, if you are at all
familiar with pixel mapping is, this stuff should
look very familiar-- a grid, some stuff you can do. But how you interact with it
varies from program to program. So the first thing
that you'll notice is we have some
different options for what you can put on it. By default,
we just start with a texture. But you can also use a
material or a UMG widget. Now, as you might imagine,
what in the world-- how would a material-- exactly. The important part is they
need to be in the UI domain. So if you don't know what that is,
don't worry. You're not necessarily alone. But inside of material,
you will specify what type of domain it is. Is it surface, decal,
function, whatever? We need to have it be UI. Why? Because materials by
nature don't necessarily have to be bound
to two dimensions. So this way, we're like,
OK, we know it's going to be a certain size. And we could do some
certain things with it. So they need to be
user interface if you're going to use material. If you're going
to use a texture, it's just going to take whatever
the size of the texture is. So I made this simple
panner material. It's just a noise with some
speed controls and some stuff that I could do. And so if I put
this guy in here-- I'm just going to do it,
so we get a little bit of movement. Just a little more, actually. So this actually has a size because,
again, materials don't have a size. It's all just based on
whatever they're covering. So you actually have
to tell it how many pixels should it be using. So then from there,
we can start defining what do we want to map. So the most simple
one is a DMX screen. You drag this thing in. And it has a little handle,
so you can draw. It's just going to create
a grid of x by y cells, and then just help with that
data based on what I said. So if I pick the remote universe
30 and go back and open up a-- so we'll pause that. And I'll open up
the Activity Monitor. And once I hit Play,
I guess it'll probably populate. Actually, you know what? I'll use the other one. That way,
I know exactly what it is. And I'll set this to 30. I'm going to start running
out of room, 1920 by 1080. All good. So yeah, if I hit Start,
I should be able to get what. What I'm going to send,
I should be able to see it over here. But what I'm
noticing is I don't think I have any controllers
that are set up that high. So it might actually not work,
in this case. But we'll press on. So if I just click this
Show Addresses, it'll show me what the
address of each cell is. I could also have it show what
universe it should be as well. It is just whatever. You can size it to
whatever size you want. And it's just going
to spit out whatever happens to be in that cell. So it's not actually
using anything with the patching system. It's not actually doing
anything with that. It's literally just going to
be sending the raw values. So if you just had a super
simple grid or something like this, this might be
the way you want to do it. If you are going to be
using fixtures, which is more than likely the case,
you have a couple of other options. And I'll try and get the
window bigger again. So you can actually
drag out a fixture group and then define, OK,
like what pictures do I want to have inside of it. So if I pick that Livestream
one that I made earlier, I can grab these individual
LED fixtures and put them in here and arrange them. So I would say like
this and like this, right? So now,
I have these three fixtures. And they would do whatever
color is going across them. So you get a
little visualization down here of whatever
you have selected. So if I select the group,
you can see, so this is the value that would
be going out based on this. So if I go back and I set
my monitor back to 20-- that's where those
are patched at-- I should get some-- I'm not getting my
information out right now. I shouldn't need
to have Receive on. But I'm wondering if it's
getting stomped on because I'm sending values from my MagicQ. Oh, you know what? Aha, all right, I do think I
know what's going on here. But anyway,
I'll come back to that issue. So this is what you would
do if you had him in a group. So you're going to-- you can then just take the
group itself and drag it around. It doesn't actually like
scale the things inside of it. It's just more meant like a handle,
so I could do that. So I can put that guy up there. And then the
other option we give you is for matrix fixtures. So if we take that Cupix
5 by 5 matrix example that I had, and then tell it,
OK, we are this in the 5 by 5, then we'll get that layout, too. And it'll tell you which
numbers they are. So something to note-- this layout is based on what
we set earlier in the patch. So if we go back to this asset,
where I defined this, this is what
defines what it does. So if instead we want to do-- you know what? Actually,
this one does one of these, I say this and go
back and update it. I think I've got to like-- huh? I think I just have to pick
something up and pick it again. Oh,
it doesn't-- it's not doing it. That's a bummer. That should do it. That should change
the sorting order of it. VICTOR: Sometimes,
it's useful to-- PATRICK: Oh,
you know what it is? I'm just stupid. It is 5, 6, 9. It is doing it. So previously, it would go
1 through 5 and then 6 to 10 this way. So it is. It's thinking back and forth. I just had a brain fart
there for a second. So if I call it back over-- yeah,
OK, 1 through 5, 6 through 10. All right, perfect. I was like,
I know they made that work. So that's how you
determine the sorting order. The only real difference on
this one is, when you bring it in, we don't know what the
matrix is going to be beforehand. So you do have to map
these colors to tell it what it is. At some point,
I think we'll probably figure out a better way to do that. But for now,
you've got to do that. So these other things-- these extra channels are in
case what we talked about before, where maybe there's a
dimmer channel in there that we're not using. So we could add
this extra cell attribute and say, OK,
there is a dimmer in here. And we just want to make
sure it's always sending 255. But because
when it's calculating this step of output,
we're only using RGB. We can only sample RGB. We can't sample other colors. And this has come
up a lot of times. If I have a picture that's RGBA,
why doesn't it use the A? Well,
we don't know how much amber is required to make colors. So unless you have a CIE
chart and a super fancy formula for us that matches
that exact fixture, we can't know that because,
in computer graphics, everything is just RGB. We don't need ambers,
or whites, or multiple blues to create colors. We only need three. So you can do this
stuff on your own. However,
there is no magic formula to convert RGB to RGB
Amber or RGB White. It just doesn't exist. So you have to use a chart. And it would be something
fairly complicated. That means that there
are generic formulas. But I guarantee they
won't work for every case. But if you had RGB
dimmer and you just wanted to send dimmer all the time,
this is how you do it. If you had-- like,
per cell there was an extra channel. And then if you had
a whole matrix fixture and you wanted
to make sure you're accounting for that
in your channel step, you could do it here as well. So that's the main
idea of how this works. And then you can-- like I said,
this controls whether you're
sending or receiving DMX. So one thing that I want to
do before I go too much further actually is I'm
actually going to-- I have a couple
of LED tube lights that I'm going to show how I
would send DMX data to those. But in this case,
since it's going through my router and it's not on
the same local PC, I actually have to
change my plugin setting here to use
the actual Ethernet card rather than just
loop back internally. I want to make sure
it's using that and not sending out something else. So that's something that has
come up in the past for me, is I want to make sure that
I'm sending to these things. Normally, you probably wouldn't
have your fixtures on Wi-Fi. But because of COVID and demo,
we're going to do it. So what I actually have
here are a couple of these-- these are actually Voyagers. They're made by Digital Sputnik. And they're like an insanely
bright for my camera. And it's like 83,
I think, RGB nodes. And it also has a
temperature control. So it's got a four channel. And we can actually use these
in combination with pixel mapping to do some interesting just
lighting and various effects. So in prep for this,
I already made one. So let me make
sure this is stopped. And so this Pixel Mapping
1 should have these in here. So here was just
some tests and stuff that I was doing earlier
with a different setup. But these are these two. So I have two of these Voyagers,
right? And so it's an 83-pixel thing. And it just makes it
a little strip like this. And that's actually
what I'm going to use. So once I hit Play,
you can already kind of see it and working sort of. So obviously,
exposure settings-- like, wow, Patrick, that doesn't
look like it's doing anything. That doesn't look anything like it,
right? So important things to note--
camera exposure still matters. But you can imagine
something like this for virtual production,
where you would have maybe several
of these in front of your talent or near them. And you can get this
nice little scrolling effect as if it's like, oh,
they're walking through a forest or whatever it happens to be. Now,
a lot of times in entertainment, we just use these for effects,
but especially in things like film
and things like that, this is extremely powerful
because LED walls are extremely expensive. This thing is like $500. So I could buy a ton of these,
get some nice glow and stuff from the front, and not
have to build maybe that front or whatever. And you can use any
different type of light for this kind of thing. But on the note of
that exposure thing, we give you a master
brightness control. So I can actually dim
this sucker way down. And so then you
might actually be able to see a little more of
the finer nuances in the color, depending on what's going on. If you're seeing some
skipping or lagging, it's from sending
ArtNet over Wi-Fi. I don't recommend that. But it's a pretty cool effect
that we can do with this. And the guys, like I said,
at Digital Sputnik was super nice to be able
to send us a couple of these and play around with them. So what I'll do just for
the sake of example, we can go back to the logo. And then you can see the clearly
defined black regions in here that you would get
from this being on here. So depending on where I move it,
I'm going to get different
levels of what's happening. OK, that's super cool. I love it. What else can I do with this? So knowing that
this can be a texture, why couldn't we do
the scene capture? So that's what I
would anticipate most people are thinking,
if they're thinking virtual production. So if you notice the Editor chugging,
you are not-- your eyes are not deceiving you. Having the Pixel Mapper open
is quite heavy on the Editor. Now,
if you're running it in Standalone or doing something like that,
it's fine. It's literally just
because it's drawing real. So just a note
on that-- if you're going to run this
in Virtual Production and you intend to run this on
an editor machine or something like that while you're
doing other things, be wary. Maybe put it in Multiuser. Maybe put it on another
machine because if you leave this window open and
it's doing this and you're playing, you will notice a
considerable hit. So just as a side note. But for the sake of
what we're doing-- so all I did is I'm using a
regular scene capture. I'm going to get some water,
bleh. Regular scene capture, 2D-- I set up a render
target and picked-- I think I just used
the default settings. So now,
wherever I move this thing, it's going to draw
to this texture. So if I go back into my Pixel
Mapper and grab that texture, which hopefully should be
named RT_something, right? Perfect. So now, I have this texture
of that render target coming in. So I could scale these lights
appropriately and put them in the scene. And sure,
let's do something like that. And I'm going to hit Play. So now,
I should get some light color that's going to match the
scene coming from these. So one important
thing to note about this is what you're doing,
as far as color temperature and color space, everything color matters. So before you get too crazy
with just throwing things in here and putting colors on them,
it's super important to know what color
temperature you're using and do some little basic
calibration stuff because, especially when you're
working in film and television, that stuff, if you're going to
try and use it to light talent, is going to matter
a lot more than if you're just aiming lights
in the camera for a show. So for example,
it's kind of tough to see again. This comes out
fairly white-looking. And at first, I was thinking
there's actually like problem. I was like, huh,
I wonder if our algorithm is bad. But what I actually
didn't know right away is that these lights
actually don't use a dimmer. This is isn't a
dimmer channel at all. It's actually color temperature. So if I set this to 0,
you can see how amber it gets. It's adjusting the
color temperature based on a scale from 2,600,
I think, all the way up to 56K. So if I put this at 255,
it's going to be at 56K. So it's literally sampling
the exact same thing. But internally,
the light has a mechanism to determine color temperature. So this is pretty critical
to just note, if you're doing this kind of stuff. So if you're using really
nice lights like these, or RE lights,
or sky panels and things like this, they'll have
calibrated color modes. And so you don't have to
think about this much stuff. You say, hey-- you ask the DP,
what temp are we at? OK. You set it. And then you go
and everything should match because, as I was
talking to you about earlier, I literally thought
there was a problem. But then I had to look
at my little chart here. And I was like, no, if you're
at 2,600, that's pretty average. That's actually pretty correct. And so I just use that
as a little reference check in my head. It's like, OK,
that's what's happening. But if you ever want
to do a sanity check, just throw out color
bars or something like that to make sure, OK,
this looks great on camera for what I'm doing. But other than that,
it's pretty cool. So the cool thing about this,
though, like I said, it's like, all right,
it's just using that scene capture. So if I were to go and
go to my HDRI backdrop and swap this out
for something that's a little more colorful, boom,
we get the same effect from the light as well
because all it's doing is it's just going to render
that scene capture here. And now, we get this thing. So you can't see my
one on the ground, but it's a little green looking. So I got two of them
that I have in here. So super, super powerful stuff. And actually,
I'm moving the other one. Let me do this one. So depending on where it gets,
it's going to start to dim down
considerably to match what is happening inside the scene. So really, really fun stuff. And this is definitely
something I think a lot of people have seen in other
demos and stuff like that, where people
have written this custom logic. And now, we provide that
just as an engine feature. But yeah,
I was thinking about, well, can I use this for other things,
too? Does it have to
just be these things? And of course, the answer is,
yeah sure, why not? So you could-- in the case of this,
for example, this doesn't necessarily
have to just drive colors. We're using colors. But it could be anything. It could be motor winches. It could also be actually
like gameplay elements. And so I was just toying
around with it on another project. But I can take this
and read it back and use it to drive something. Cat ragdolls, exactly,
something like that. I just saw that pop up. So that was pretty funny. Yeah, why not? Because at the end of the day,
it's just values. So if I look at it like, right now,
I'm not playing anything. So there's nothing coming in. But if I do this-- actually, 20's the other one. You've got to be
on the right mapping. Material, there I go. I'll play this. And so now, I'm getting
all these values coming in. And so yeah, I could use this
to drive whatever I wanted to. So it's pretty fun stuff
to play around with. I'm really excited
about what they've been able to come up with for this. And there will definitely be
some more improvements. We do our best to make this
UI feel nice, and responsive, and stuff. But there's definitely
a few changes that I think we're going
to make going forward. But I think Pixel Mapping
is still technically beta, I want to say. So I haven't had any
major problems with it. But at the same time,
you may encounter some bugs. I do of one, for sure. So if you start
dragging in this box, you'll notice the range
seems way out of whack. It is not correctly normalized. So just know that it should be
based on whatever your max value is for DMX, all right? So that is one
that I know about. But other than that,
it's been pretty nice. And again,
you can set up multiple mappings. You can use different
fixture setups and configs. And there's a bunch
of Blueprint nodes to control all this stuff as well,
if you want to. Cool,
so how much time do we have left? VICTOR: We've got some time. I do have a couple of
questions I'd like to go through. But if you're good to
stay on for another-- I don't know-- half hour or so? PATRICK: Yeah, sure, absolutely. VICTOR: Cool. PATRICK: Yeah,
I want to get as much of this out as possible. VICTOR: Yeah, let's do this. We're here. We're live. PATRICK: I've got
a knowledge dump. It's like, all right,
I'll go in the wild to see some people
do some stuff. VICTOR: Did you have anything left that you wanted
to go through before we dive into the questions? PATRICK: Maybe
just one other little thing because I made a
video a while back about how to control
other objects with DMX. And that has changed
somewhat in this version. And it's actually become much,
much easier to do. So just for the sake of it,
I'll just create just a regular-- so I'll just call this
DMX Receive-- I before E, right. That still looks wrong. I don't know. So all we need in order
to look for a patch is a DMX component on it. But inside the graph-- like I said,
before we had this like on protocol received. And there was all this
stuff on that you had to do. We actually made
it so much easier to just receive information. So in the same-- I'm going to use the same node
that we used inside the fixture as well. So I'm going to add an on
fixture patch receive event. So what this is going to do is say,
OK, if the patch that
we're looking for-- if this matches,
we're going to do some logic with it. And this has made everything so,
so much easier, I feel like, to work with than
the old way of doing things because now we
don't have to worry about filtering and these
other kinds of things. So for example,
something that has come up a decent amount of times is like,
all right, we want to whatever. We want to-- I don't know-- control
something else with RGB. So if I just grab-- I'll just grab like
a simple LED bar. And so now, I have a patch
that is associated with this. Now, I can actually do
this nice attribute map. And I can just do a find. And I can say,
hey, with the red. I want you to do
some kind of logic here. And it's going to be
based off whatever the red channel is from here. And it's just so much easier
than the other way of doing it. In my other video,
it was so complicated to do this kind of stuff. And now,
we're just going to get a value out of whatever red is like
for this particular patch. And so that's how,
in the octobeam thing here-- so I've got to load
up another show file. But if somebody
had asked me before, how are you
actually controlling it? Because I did do
a little video where I was like I want to
have it fly up and down. And I was like,
I want to control this now with DMX. So on my little MagicQ here,
I had some default things that I was doing with it. But I wanted to
be able to control how does it go up and
down and do this kind of stuff. So in order to do that,
I had to just be a little clever, like, all right,
I want to use just something simple that I know. So red, green, and blue was
what I came up with for that. And inside this
control Blueprint, basically I use the same thing. So I'm using this
on patch receive. I'm getting the values. And then I'm using red, green,
and blue to do something else. So I use that to
set my location. So here,
I'm just remapping the range because position
could be anything. So I just wanted to match it to
something that could be useful. But this is exactly how I
did it for the same thing. So honestly,
it's so nice because before, yeah, you definitely had to do
a lot more stuff like this. And it was just kind of a mess. This just made
it so much easier. Big thanks to the guys for
actually doing that for us. So if I turn on this receive again,
in theory, I should be able to affect this. Oh, you know what? I'm a liar again. I've got to do this, so I can
do some things internally again. I was like, huh, it doesn't
seem like it's doing anything. So I had this default
position for this guy. But if I wanted to like move it,
all I really did was just make a red,
green, and a blue for this guy. So then I could
just adjust where I wanted it to be in space. So I used 16-bit bodies,
so I could get a little more use out of it. But that was the idea. And then I made another thing,
so I could turn the top on it. And then most of the
other things that I did are just using the existing
things that we ship now. We have the washbeam lights. So if I grab the-- I think I used XB as the thing. So I could do D
and just whatever. So those were that. And I don't know. It was a lot of fun to do. It gave me a
little bit of just fun to be able to try and create
something different that wasn't your normal fixture with it. And then same thing,
I just mapped that to just a dimmer channel, so I could-- that's actually the Pyro
asset that we ship with it. So I had a lot of fun with it. And then you'll see the laser. Again,
I think I just mapped it to a color. I did the exact same thing. So it's just like-- oh, actually,
that's that laser, I guess. But yeah,
so if you're trying to use Blueprints to do other things,
this is now the preferred easy method of doing it. So cool. Now, I can take some questions. VICTOR: All right,
we've got plenty. So if we are not able
to tackle some of them, I'll make sure to send
them all to Patrick. And if any of them
were valuable, we will go ahead and answer them
on the forum announcement post that you can find on
forums.unrealengine.com. Go to Events. And that's where you find
all of the announcements for our live streams. So greentoppings asked,
so when does an equivalent OSC subsystem come out? PATRICK: Aha!,
That's an excellent topic. So in the future,
that is on the road map. So where this is
actually going to apply-- and I don't want to get derailed
too much from DMX on this one. But since it is still in this
live events controlled area, inside of 4.26,
you have this option now. There you go, under your
plugins and do remote control API. And this is what I was
talking about yesterday. And so I won't-- and then this remote
control web interface is something that will
come to the market place. It might actually be out,
but if not, really, really soon. So what this gives you is this
miscellaneous remote control preset. And so if I do Remote
Control Preset 1 2 3, whatever it is, inside here,
if I open one of these up, you'll notice,
on the right-hand side, I get the option to
expose properties or any object inside of Unreal. So let's just say it was the-- I could expose
this rotation location and whatever, visibility. And so you get this nice little
grouping of those properties. So if I come out of Edit,
you lose the eyeballs. But I can actually just use
this as a nice little hot control spot, which is kind
of handy just by itself. But this actually becomes
exposed to a web server as well. So inside my output log,
it's probably bugging me about it somewhere
in here that it's doing it. But this is also going to be
the route in for OSC, hopefully MIDI and the ArtNet DMX also. So you'll be able to
just quickly say, OK, I want to bind this position
to this channel and ArtNet or this channel and
MIDI or this float in OSC. So that is something that is on
our roadmap and on our radar. I can't give exact times
or dates or anything, but it's coming. VICTOR: All right. AndyFilms1 asked,
when we get to Pixel Mapping, can you ask if we can
attach a Live Link controller to the light to control
its position in real-time via something like
an optitrack system? PATRICK: Ah, interesting. So I guess the-- I'm a little bit confused about
the pixel mapping part of that because-- pixel mapping,
you have to light based on a location in
the environment. So if you were to
move the scene capture, I guess that would pick
up what's happening based on your movement. But it might be something
that you have to-- I think you'd have to
think about that a little bit, what you actually want to
have happen in that case. But there's no reason that
you couldn't do something like that. No,
I was just thinking in my head because,
if I just moved it slightly, would I even be able
to tell the difference? Probably not if it's like
an environment, right? But since it's
capturing anything that's in the environment,
what would happen, though, is,
if you had say whatever, hopefully not a cube but
something more interesting that went in front of the camera
and went across the viewport, you would see that. And that would affect the lights
that are mapped to that area. In theory,
I don't think you would move the lights around positionally. You would just have them set
up how they would be in my head. VICTOR: RawBengal
asked another question. It feels like the DMX
library includes both fixture definitions and patches. Can these concepts
be separated or shared, since we might want to reuse
the fixture definitions a lot but a patch is really per show? PATRICK: Yes. So Rob,
you're going to really like this. So literally, if I just create
a new blank DMX library-- you know what? Whatever. And it's like
completely blank here. I can actually just go in here
and Control+C Control+V from one to another. You can do it from
different projects. And I've actually done it
between different versions. And so yes, you can keep
these fixture definitions and drag them in and copy
and paste from other projects, if you want. We don't have our own
system of specifying it, though, because we were hoping people
would lean on GDTFs honestly, if they want to use
real-world fixtures. So you probably just create a
GDTF for it and there you go. But yeah, copy and paste
for the win is exactly right. I was like,
I had no idea if that would actually work initially. And it works in
the same project. And if I open up another
instance of Unreal, I can just copy and
paste into that one, too. So it works pretty good. VICTOR: The amount of
times I come across that the solution is Control+C plus
Control+V has been surprising. PATRICK: I know. I had my doubts
because I did make-- in one case, I may-- I'll just delete that guy. With the Magic Panel,
that was a fairly annoying one to do. The first time I was like, gosh,
I don't want to do it again. And so I just literally grabbed
it and copied and pasted it in another browser. I was like, oh, that worked. Great, perfect, done. So cool. VICTOR: Let's see... finalpixels_ asked, is DMX fully compatible
with in-display Quadro cards, et cetera? We're getting tearing,
and random stutter, and lag. PATRICK: So I would be
willing to say that that has little to do with DMX
and is likely to do with the lights themselves
because the actual DMX-- we're not synchronizing
it over live link right now. So if it was receiving on
each individual machine, that would just be
up to how accurate is the timing between them. So I will say this. I don't know how
accurate that actually is. We've all seen it,
where especially if you have ArtNet
fixtures and things like that, there's delay. They're not necessarily
100% in time. And if we're only
updating ArtNet at 44 hertz and your stuff's
been locked at 60, I can definitely see there being
some room for error in there. But more than likely,
it's not so much the DMX is being
received at different times. It's how the beam is actually
being drawn across them that may not be synchronous. So that will take a little bit
of troubleshooting to find out where that thing lies. But as of right now,
we don't push DMX over live link. So there wouldn't necessarily
be a mechanism for that. However,
what I would probably do, if I knew I was doing
an in-display project is I probably would send
DMX to the master, and then use internal protocols,
like cluster events or something else,
to push the updates to the nodes. That way, I can make sure,
OK, that part I know for sure is synchronous. Rather than sending
DMX individually, it's a separate node. I think that is probably
not going to work as well. So just a side bar. VICTOR: Earlier
during the stream, Epicoptimist asked,
in the DMX template, the lights utilize a level
sequence to animate. Is it better to program
the animations in dot2, or another LED program,
or use the level sequences? PATRICK: Oh, cool. So actually, I totally
forgot about this part of it. You can record DMX
into level sequences. So that's actually what we did. So I'll run through that
expeditiously quickly. All right,
so if you create a new-- actually, I don't even need to
create a level sequence. You use Take Recorder. So if you're not familiar
with Take Recorder-- actually,
I guess that probably gave me-- let me remove this monitor here. So now,
we have the ability to record in. There's a separate
type of DMX track. So if you go to
add a track and you have the DMX plugin enabled,
you'll see this DMX library
track as an option. But you don't actually even
have to set anything up here ahead of time. If you just open
up Take Recorder, which, again, is a plugin-- I don't believe it's enabled
by default. So Take Recorder, you just turn that guy on. And then you'll add your source. So I'll say, all right,
I'm going to a DMX library. Pick which one. So in this case, I don't even
know what I'm using anymore. I've got too many of them. Livestream is
on the other level. I had the octobeam working. So I'll just go with that. So then from here,
you can define what patches you want to record. So you can either
add them manually, which sounds like a
big headache to me. Uh oh,
I don't think it liked that. VICTOR: There we go. PATRICK: Hey. It didn't like my clicking. Yeah, that's kind of pain. Or you can do this
Add All Fixture Patches. Click that, it's going to
add every patch that you have in that library as
an option of something to be recorded. You can tell it to
record in the subscenes. But I think that part actually
doesn't work properly for DMX. It does work for other
things but not for DMX. And so then, OK, cool,
we're ready to go. So I can actually set your
rate and stuff, if you want to. So let's do this. It's enabled. Good, OK. So we'll pop in to Simulate,
so we can see hopefully that it's doing something. Yep. OK, all right. And then I'll Record. So that's going to go 3, 2, 1. Right. So now,
we're plotting keyframes. So if I do this-- so now, it's going to start
plotting keyframes only for the things I change. So once it stops, you can
see it stops recording because I haven't made a change in value. So then if I tell it to bounce,
then it's going to just start recording
tons and tons of keyframes. Right now,
I'm just triggering sequences I've already programmed. So cool. All right,
so let's just say that that was good. So we'll stop. Now, we want to go back
and review this recording. This part burns me
almost every time. I'm glad I remembered. So right now, if I were to just
go back and review this and hit Play, I get some weird results. The reason is
I'm still listening to DMX coming in as well. So I need to pause receive. And then I can come in here. And again,
if I pop back into Simulate and I hit Play
and play this back, I should get back
exactly what I recorded. So that's where I
snapped it down. And there's where this is going. And I then stopped and
was yakking about something. And then I turned on
the bounce and whatever. And so this is super,
super cool because then you could have somebody
who recorded a show. And you don't have
to be there for it. So when you click it down,
you can see where all the keyframes
are and what's going on. And it's a pretty performant. Flo, the master from Geodesic,
wrote some pretty awesome optimizations for this. So it's actually
extremely efficient playing back because,
as you can imagine, if you have hundreds of
lights and each one of these has dozens of
parameters inside of it, it can get pretty
unwieldy really fast. But he did a pretty
awesome job optimizing it. So yeah, that's how the CMX
sample was made, though. So they actually ended up
recording it in from a console. And then it's just plays back. That way, he didn't have to
have a console to use the sample. VICTOR: That's awesome. And you can also
edit them afterwards. PATRICK: Yes, you can. So by default, when you-- obviously,
if you've used Take Recorder before, you'll know they're
locked by default. So it may seem like
you can't do anything. That's just because the
sequences are locked. But then from there,
yes, you could actually just move keyframes around. And everything
should be good to go. Let me just see something. Yes, OK. Awesome. So I'm using a slightly
ahead version of this. So I build from source code. If you're using the
Launcher version, it may be slightly
different behavior in here, but it's pretty much
the same thing. But if you go from Source,
it will look identical to this. I can't remember.-- I think
it nested in a subscene in the main version. But now, we've taken that out. Cool. Anything else? VICTOR: Yeah,
we've got a few more. You got time? PATRICK: Yeah, totally. Let's keep going. VICTOR: BenevolentDreams asked,
earlier, you guys were going
over the timing data. The audio guys are working
on the quartz timing stuff. Is there a way to
tie the two together to get lights to do
things on beats? PATRICK: I don't see why not. I mean,
I don't specifically know I guess what he's referring to,
which maybe that's just my ignorance. But again, since they're all
Blueprint's, using the logic that I used for this as an example,
yeah, there's no reason that
you couldn't write something so that, OK, if this is happening,
do this thing. For sure. Hopefully,
that answers that a little bit. Might be a little vague. But yeah,
I don't know exactly what the hooks are for that quartz system. VICTOR: I'll ping the audio guys and see if we can get-- PATRICK: Yeah, now you've got me curious
because I know there some audio reactive
Blueprints floating around on the Internets. And I definitely used those
to hook them up to lights. So yeah,
you can definitely do it that way. VICTOR: I'm letting them
know about it right now. PATRICK: Cool. VICTOR: Let's see. plnrnd asked,
do you support black lights or just LED lights? PATRICK: I'm a little
confused by that question. Did they say input or output? VICTOR: That was the question. PATRICK: OK, I'm not sure. Yeah, I'm not really-- if that was on Pixel
Mapping or what that was for. It was at the end of the stream. So I would think so. OK, yeah. I mean, I think black light,
LED light-- I don't know. I'm not sure about that one. VICTOR: Let's see
we've got a few more. PATRICK: The
answer is always yes. It just depends on how
much work you want to do. VICTOR: Right. When you have the source code-- PATRICK: Yeah,
I hate to say it that way. But yeah, that's how it is. It's like, well,
you can kind of do whatever you want. You could technically
write another version of Unreal inside of Unreal,
if you really wanted to. But I don't know. VICTOR: DocanZa asked, can you show us how you made the
strip lights in your sandbox map? PATRICK: Oh yeah, totally, sure. So all I did,
in this case, was I created a patch
for the strip light. So I'll just show
you what it looks like. So it's all just based on
what you define inside here. So in the LED strip,
I just told it that's 5 by 1 instead of being
5 by 5 or something like that. And then when you take
the static matrix light out of here,
once you tell it what it is and then give it
some dimensions, then you can generate the mesh. So I just told it
that it's 300 by 20. But if I made it 20 by 20,
it's going to be this nice, small little-- and if you don't
like those things-- well,
a couple of ways to fix it. Let me pop into Game mode. So then you see it's
really skinny now? But yeah, so if I just grab
that thing again and put it back to 300 and regenerate the mesh,
then we've got that again. So that's all it is. You just have to, I guess,
be cognizant of is it this way or this way
because it may affect what you did in the patch. If you told it, OK, it's an x-- it's 1 by-- it's 1x by y,
you may want to have it go
a different direction. That's how you do it. And they're pretty cool. Actually,
they're pretty nice looking. VICTOR: Grid21 asked,
can you override the lighting program if you
wanted to freestyle your DMX for an extra touch? PATRICK: Yeah. I mean, well, because obviously
you have this override of your send and receive. So you could just
literally stop receiving, if you wanted to do
something on top of it. Or I mean, I guess the other
possibility would be here-- would just be if-- you can always read some
logic as well to sit on top of it because we have all kinds of
Blueprint nodes for everything you would ever want in DMX,
for the most part. So you could definitely
read the incoming signal and modify it in some fashion. Yeah, definitely. VICTOR: Dendrolis asked earlier, do the fixtures actually
cast lights on other actors? And can it render
without volumetrics, like an FOH system? PATRICK: You definitely
could turn off the beams if you wanted to, yeah. So the main reason that
we have the beam shader is just because,
internally, if you weren't using the
beam shader and you're using just a default light-- let me go back to my
ambient and my dark one. So if you just pull in a spotlight,
for example-- whatever, I can just describe
what I'm talking about. But the beam itself
coming out of a spotlight-- what determines what it
looks like is actually the fog. It has nothing to do necessarily
with the light part itself. So you have to play
with the grid pixel size and deal with atmospheric
height fog and this kind of stuff. But what we noticed was just
since that's what's driving it, there is no way to actually
shape that currently. Light functions
don't affect fog. It only affects what it hits. So that's why we have it. But if you don't want
the beam to be shown and you just want to
have it just cast light, absolutely you could
just go into the Blueprint and just literally remove
the beam instance material or just modify the
shader to not draw that. So actually, in my-- not here,
but in some of the other setups, I've actually gone in and
modified the master material. Let me see. Where is light fixture materials,
master, master, right? So I mean, essentially,
it's just going into this missive, right? So I literally just
put in an inhibitive. Inhibit and multiply here. And balance guy in here. And go like that, right? So now, I have like a
master inhibitive to this. So I just cut off the beam. Or I could put it to
something very small so that it would not
draw as much beam. And you get more
stuff on the floor. That's totally valid as well. I will put it back, though. VICTOR: I think that
was the last question. And we are almost
out of time here. PATRICK: Good. Well, that's really good. VICTOR: There were some other-- I know y'all asked
some other questions. If it's not related to the
topic or Patrick's expertise, then they unfortunately aren't-- they don't get
asked on the stream. So we get all the questions. Yeah, but unless I know
Patrick is potentially able to answer them, then just
receiving a sorry I don't know is not too interesting. That was really good. PATRICK: Probably a lot
of those because nobody knows everything. VICTOR: Unreal Engine 5,
it's coming. I don't know what
else to tell you. PATRICK: Oh yeah,
yeah, that's tough. VICTOR: I know
everyone's excited. Patrick, thank you so much
for coming on stream today. Chat, please give it
up for Patrick spending quite a bit of extra
time here as well, just answering most
of your questions. That's super exciting. If you joined us
from the start today, thank you so much for watching. We hope you enjoyed the stream. Make sure you give us
some feedback in the survey that we'll go ahead and
drop the link in chat for you all. Let us know what you'd
like to see in the future, what kind of topics, as well as
features and things that you'd like us to cover,
also how we did, what we could do better,
et cetera. Just go ahead and speak
the truth right in there. If you are new to the
Unreal Engine community, make sure that you
visit unrealengine.com. You can download anjo for free. It's right in the Epic
Games launcher, if you already have that. And you can get
started immediately. I do want to make a shout-out
to Unreal Online Learning. We have about 160
hours of content right now, where you can follow along
from getting started into more in-depth courses into some
of the features and topics-- general game development topics,
but, of course, specific to Unreal. If you are a member
of a community and you're producing
content already, make sure you let
us know what you do. If you've seen this
from the beginning, we do air the news spotlight
as part of our live streams. It also goes up on YouTube. And we pick spotlights
from the community. And so if you go ahead
and submit projects, whether it's on the forums-- we check Twitter,
Unreal Slackers, which is, by the way,
our unofficial Discord community, great place to learn, share,
and discuss everything Unreal. We're also looking for
new countdown videos. They are 30 minutes
of development captured from the editor. Speed that up to five
minutes and send that to us separate together with
an image of your logo. And then we'll go ahead
and composite that together with the little countdown. It's cool. It's a good way to get some
attention for your project repeatedly on the stream. If you stream on
Twitch like we do, make sure you use the Unreal
Engine tag as well as the Game Development category. That's the best way
for us to find you, as well as other people
interested in watching you stream and work
with Unreal Engine. It's quite cool. We're going to go ahead and
make sure we raid someone after the stream here as well. Make sure you follow
us on social media. And if you are watching
this on YouTube, make sure you hit that
notification bell so that you get all of our updates
and everything else that we release there. We do have a lot of
things that don't go up and Unreal Online Learning,
such as these live streams, our webinars, all of our content
from our events like Unrevealed Virtual Production. We also have 50 videos
from Unreal Fest Online that we did earlier this year. There are loads and
loads of content over there. Next week, we are doing
the Year In Review stream with Tim Sweeney. And so if you're excited
to come and join us for a little bit of a
recap of the year, we're also going to have Brian
Karis as well as Grayson Edge and a little bit of a
surprise at the end. So I would highly
suggest you tune in for that. It's going to be
same time next week, Thursday at 2:00
PM Eastern time. And I'm quite excited. I can't tell you more than that. But tune in. It's going to be great. Patrick, anything else you'd
like to leave our viewers with? PATRICK: No, I mean other than-- I was just going to
say we really appreciate any kind of feedback
and information you guys can give us. I know I'm in contact with a
large portion of the community. But it's by no means all
of it that's in this space. So if you have ideas,
suggestions, this is by far never-- it's never the last version,
right? There's always
more stuff to come. So if you have some other stuff,
definitely reach out and let us know. We're always up for trying
to make our product better. VICTOR: You can add us
@UnrealEngine on Twitter. But the best place for feedback
is the Feedback for the Unreal Engine team on our forums. That's what I'd recommend. Awesome. Patrick, thanks again so
much for coming on the stream. I hope I get to see you
at some point again here. PATRICK: Yeah, totally. I'd love to do it
again for sure. VICTOR: Awesome. And with that,
I wish you all a great weekend and a great rest of your week,
as well as a good weekend. And then I'll catch you all next
week, same time, same day. Take care everyone. Bye-Bye.
