>>Amanda: Hey, everyone!
Ready for more Unreal
learning topics?
This month, four new courses
arrived on the Unreal Online
Learning portal.
Explore the fundamentals
of the Material Editor
to assemble Master materials,
harness the power of audio
in tandem with dynamic
game events and conditions,
create VR walkthroughs of
architectural visualizations,
and find out how to teach core
school subjects with the help
of Fortnite Creative.
Visit
unrealengine.com/onlinelearning
to start today!
Want to know why filmmakers
are flocking to real-time?
Join Co-Founder of fxguide and
Director of the Motus Research
Lab Mike Seymour--together with
award-winning speakers from
Stargate Studios,
Happy Mushroom,
and Epic Games--to explore how
production and post are merging
at the beginning
of the pipeline,
with experts deploying new
ways of creating and managing
content.
Episode 2 of The Pulse
- Virtual Production:
The Transition to Real-Time
Filmmaking debuts September 9
at 4PM EDT.
Register now and
participate in the live Q&A.
If you're a Mutant
Year Zero fan,
get ready for even more time
with Dux, Bormin, and the gang.
Directed by indie filmmaker
Hasraf 'HaZ' Dulull,
the full-length animated
action adventure film
will feature the dark
post-apocalyptic future
as the mutant band of
misfits search for Eden.
Watch the full trailer!
Now to celebrate our top
weekly karma earners!
Many thanks to:
Clockwork Ocean,
Everynone, Tuerer,
stuck compiling, Okarii,
chrudimer, B3P, T_Sumisaki,
Shadowriver, and PAVI_PAVI.
Heading over to our fun and
helpful community spotlights,
first we recommend you
checking out Game Dev
Pantry from Lucid Tales.
In their tutorial series, the
Montreal-based five-person team
of graduates reverse
engineer game mechanics
such as the grappling
hook from Sekiro
and the telekinesis
powers from Control.
Check out the
Lucid Tales YouTube
page for all their episodes.
For the French speakers
in the audience,
be sure to follow
Evans Bohl on YouTube.
The French Polynesian teacher
hosts several tutorials
on Unreal Engine and general
game development topics,
ranging from character creation
to level design and VFX!
And we're closing this week out
with an impressive Batman fan
film created by Hans Ter Torst.
Reallusion hosts a
thorough interview
with Hans on their
blog where you
can learn what
inspired him to create
the film, how he's building
his characters, animations,
and so much more.
Read the full interview
and watch his test videos
to see his workflows in action!
Thanks for watching this week's
news and community spotlight.
>>Victor: Hey, everyone, and
welcome to Inside Unreal--
a weekly show where we
learn, explore, and celebrate
everything Unreal.
I'm your host Victor
Brodin and today,
my guests are from the amazing
team at Terrible Posture Games.
Let me introduce to you Joseph
Mirabello, CEO and Founder.
>>Joseph: Hello.
>>Victor: Nolan Eckerman,
Senior Engineer.
And Chris Zukowski, who I
will be referring to as Zuko
for the--
>>Zuko: Woo!
>>Victor: --remainder of the
stream, Technical Director.
>>Zuko: Good luck.
>>Victor: Welcome
to Inside Unreal.
>>Joseph: Hi, thanks
for having us.
>>Zuko: Yes--
>>Nolan: Hello
>>Zuko: --thank you.
>>Joseph: Do you
want me to tell you
a little bit about
the studio real quick?
>>Victor: That's what I was
going to ask you to do.
>>Joseph: Awesome, sure.
So Terrible Posture Games has
been around for a few years
now.
Our first game was a game
called Tower of Guns, which
was pretty much a solo project.
Then we grew up a little bit
and we made a follow up game
called Mother Gunship,
which we co-developed
with a studio
named GRIP Digital.
And then, after Mother
Gunship, we began growing again
and started working on a bit
of a different project, which
is called 3 Out of 10.
And 3 Out of 10 is a
little bit strange for us.
We were used to making
randomized first-person
shooters, which is what Tower
of Guns and Mother Gunship was--
both were.
But 3 Out of 10 is
essentially a playable sitcom.
It is a heavily narrative
based show, really,
with gameplay interjected about
the world's worst video game
studio ever.
Where this game studio
has never made a game
that has ever scored
better than 3 out of 10.
We're releasing these
episodes, this game,
in episodes for free
on the Epic Game store.
Every single week
there's another episode,
and they're released in
very bit-sized, lunch break
sized experiences-- about
30 minutes a play session.
And the fourth
episode just released
like an hour and a half ago--
2 hours ago,
something like that.
Very, very recently.
So you can play all four
of the current episodes
and then another so will
be released next week.
So yeah, if you want to quickly
show the trailer, Victor,
I'd love to show
people what it's about.
>>Victor: Yeah, let's
go ahead and play it.
>>Ben: [VOCALIZING]
>>Joan: Morning, Ben.
Lovely day, isn't it?
>>Ben: Morning, Joan.
Yeah, it-- holy [BLEEP]!
Man, what the hell?
Y'all know there's a big
ass dinosaur in the middle
of the office?
[MUSIC PLAYING]
>>Kevin: So it's an endless
runner, but the twist is--
wait for it-- there's an end.
[MUSIC PLAYING]
>>Francine: What's the problem?
It looks fine.
>>Viper: It looks fine?
It looks fine?
I'm going to go
floss my eyeballs.
>>Ben: You'll get
used to it, Viper.
>>Jeb: Circle up, everyone.
We announced Surfing
With Sharks today.
Reception has been wonderful.
The internet loves it.
That's totally not true,
but it's good for morale
to tell you that.
[MUSIC PLAYING]
>>Pylon: The new Shark
batch file name
was to temp_final_final2_complete.
>>Kevin: Ah, the naming convention
of an experienced developer I
see.
See that counter up there?
That's tied to an
algorithm in order
to create a predictor
of expected score.
>>Speaker 1: It says 2 out of 10.
That's terrible.
>>Kevin: It is.
>>Ben: Just get the
damn keys already.
>>Speaker 3: Is there a video
tutorial about this somewhere?
>>Viper: Just reach
out and grab them.
>>Speaker 3: With a shovel?
>>Viper: What the-- do
you even see a shovel?
>>Jeb: Blah.
>>Ben: Pylon!
>>Jeb: Francine, I need
you to hold all my calls
for the next half hour.
>>Francine: Sure.
>>Jeb: I'm signing things.
[MUSIC PLAYING]
Sign to the left.
Signing to the right.
Gonna sign this [BLEEP].
Woo.
>>Francine: Jeb does
this sometimes.
[MUSIC PLAYING]
>>Kevin: This project
is different.
This game will be a hit.
[BEEPING]
[DING]
>>Pylon: I've never seen
that number go up before.
[MUSIC PLAYING]
>>Joan: I don't know.
I thought it was a cool
announcement trailer.
>>Ben: Yeah, it was
something all right.
>>Victor: All right,
every time I see
that I find it almost even more
fun to watch it every time.
>>Joseph: Thanks.
Yeah, we've had a lot
of fun making this game.
And as you can see,
it's a little bit--
visually, it's a little bit
different for an Unreal game.
It's this heavy
mix of 2D and 3D.
And because it is kind of made
like this combination of show
and game, we've had to really
kind of explore a lot of--
one, a lot of building
our own custom stuff
and then, two, a
lot of using what's
in Unreal in really kind of
creative and unique ways.
So we're going to be talking
about that a little bit today.
Each episode is kind of divided
into three main pieces--
three real branches
that make up an episode.
Those are the cutscenes,
which every episode
has a significant
number of cutscenes.
And then an explore phase, which
is more like an old adventure
point-and-click game of yore
and then actual mini games.
And we wanted to make
a tech that kind of
tied all these things
together and allowed
us to really iterate quickly.
We needed to build these
episodes as fast as possible
so we spent a lot of
time figuring out how to,
essentially, iterate quickly.
So we're not going to talk
too much about the game stuff,
because that's probably the
most conventional Unreal path
and we follow a lot of
standard Unreal processes
and tech there.
Instead, we'll be diving mostly
into the animation systems
that we've been leveraging
and then the character system.
So Unreal, while they've
got a lot of tools,
we want to really
emphasize showing
you what's different
about 3 Out of 10, which
is this cool blend
of 3D and to 2D.
So that said, we're
going to be talking
about what it takes to
actually make an episode
and why we kind of built
things the way that we did.
And we actually do pretty
much everything in-engine.
We skipped out on a lot of
traditional animation tools
and did a lot of stuff
directly in the engine and that
includes the animation work,
the rigging work, compositing,
the editing.
We'll talk about
this more later,
but we did this all for
iteration and then all
for being able to work parallel.
Again, everything you're going
to be hearing throughout today
is how we were leveraging--
how we were
leveraging the skills
we had to be able
to set ourselves up
to make an episode
as fast as possible.
So that said, we'll be talking
about mostly one scene and kind
of dissecting it
and pulling it apart
and going from script to final.
This is a scene from
last week's episode
where the team gets in to
an office wide battle royal
with foam dart guns.
So Zuko, do you want to actually
play the scene real quick
so people can see what
we'll be talking about?
>>Zuko: Yeah, first off,
can you guys hear that?
>>Viper: --any more that I have.
>>Joseph: Yep.
>>Victor: Yes.
>>Nolan: Yep.
>>Zuko: Cool.
Awesome, just
wanted to make sure.
[MUSIC PLAYING]
>>Viper: It looks
like they haven't
renovated this area in a while.
>>Kevin: So have you
thought about how
you'd proposed changes to Jeb?
>>Viper: Whoa, whoa,
whoa, the winner
has to propose
their idea to Jeb?
No one said anything about that?
>>Kevin: It's not like we
can just change the game
without getting him on board.
>>Viper: We do that all the time.
>>Kevin: True, but this
time Jeb asked about it.
So we've got to talk to him
about what we want to do.
>>Viper: I actually
don't want to do that.
>>Kevin: No?
>>Viper: I don't like to talk
to Jeb any more than I have to
and I don't care
that much about this.
>>Kevin: I thought you wanted more
blood in Surfing with Sharks.
>>Viper: No amount of violence
makes talking to Jeb enjoyable.
Might as well shoot me now.
>>Kevin: What?
>>Viper: That's right.
Shoot me.
>>Kevin: Stop joking around.
>>Viper: Oh, what?
Never shot anyone in a foam
dart battle royal before?
Bleh, this your first time?
>>Kevin: First, I think Pylon
said it was a scuffle royal.
And sure, like, all the time.
>>Viper: Lies!
Shoot me, you coward.
>>Kevin: No!
>>Viper: Shoot me!
>>Kevin: I can't, we're
on the same team.
>>Viper: I'm pivoting.
I quit the team.
Shoot me.
>>Kevin: No.
>>Viper: Shoot me, damn you!
>>Kevin: Ah!
Get away from me.
>>Viper: Coward!
I'll find you!
And make you shoot me.
>>Joseph: All right, so we've
got a lot of stuff going on
in that scene.
There's a lot of cool
animation tech going on
and, to give you
kind of an overview,
I'll be doing a little
talking, but most the talking
is going to be done by Zuko,
the tech director, and Nolan,
our senior engineer.
But to kind of give
you an overview,
we're going to be talking
about how the scene starts
with a script, how we
auto generate as much
as possible, a little bit
about how we create levels
and connect everything
together, and then we'll
be deep diving into
some of the tools
that we've made or our
leveraging from Unreal,
including some cool rigging
and manipulator tools
and really creating a cool,
unique approach to animation.
And at the end, hopefully, we'll
have some time for some Q&A
so you all can kind of
ask us more information.
But that said, we may
also answer things
as we go as things come up.
I also want to mention that
this particular scene has
the voice actor in the chat
right now hanging out with us.
So if you want to pipe up there
[INAUDIBLE] and say hello.
Not only is he in the scene, but
he's actually every character
in the scene.
Which is kind of fun.
But anyway, that
said, do you want to--
>>Zuko: Yeah, I can
take it from here.
>>Joseph: --kind of dive
into the dissection
of the scene a little?
>>Zuko: Yeah, so we'll just kind
of do a high-level overview
of this first, because
I believe we're
going to jump into it a
little bit more in detail.
But the whole entire
scene is in a 2D, 3D mix,
so our rigs on the
characters are all 2D.
We'll go over that more too.
And we use Sequencer
to drive our cutscenes.
So everything in this scene,
we have our characters
being added to the scene from
a pool, which they kind of just
live below the world somewhere.
Oh, wait, they're over there.
They're far away.
And everything
inside of this now
is being driven by rigs
inside of Unreal on Sequencer.
So you can see if
I scrub around,
the animators actually
use this Sequencer
to drive all the animation.
So if I kind of
dive in here, you
can see we have the
ability to add attachments
on to everything.
When you click on
the attachment,
you get like a little
manipulator to move it around.
There's also the--
each character
has their own specific rig.
So I can go ahead and move the
character around and get them
in place.
And you can see
it's pretty complex.
That the animator
has a lot of power.
They have a lot of
power to control
a lot of different regions.
So our rigs they expand quite
the vertical space on Sequencer
with all the keys that
animators use to drive it.
And they use like a little
animation helper, which
we can talk about more as well,
but the whole point of this
is just kind of showing
you the outline of what
the scene entails.
So if I go to the part where
like he's saying, shoot--
>>Viper: First--
>>Zuko: --me--
>>Viper: --time?
>>Zuko: --bitch.
>>Kevin: First, like--
>>Zuko: Yes, like, right
here, that's fine.
I can turn on the camera cuts.
We can see that the animators
will also key each camera.
We decided to go
with one camera.
We know that Sequencer
has multiple camera cuts,
but for us, it was just
easier to just kind of key
when we needed to do a shot
and just copy the keys over.
Then also, we have sub-scenes,
which all of these will be--
these are kind of
like the lip-syncing
and it's separated a bit.
So we have our main animation.
Right here is Viper's
main animation.
Then later, we'll actually
have the sub-track here
control the dialogue.
And all of this
stuff is separated
so that we can do lip-syncing
and all that stuff
in tandem with actual animation.
>>Viper: Ah, what?
Never shot anyone in
a foam dart battle--
>>Joseph: And you're in not audio
mode right now, right, Zuko?
>>Zuko: I thought I
was in audio mode.
>>Joseph: Oh, OK, cool.
Great.
>>Zuko: No, I hear it.
>>Viper: Never shot anyone--
>>Zuko: Yeah, so you
can actually see
like that we have keys
for each different part
of the lip-syncing process.
Then, I believe, on
top of this we have--
the attachments
are also in here.
And then the audio team has
their own separate section
as well, where they
can go in and they
have their entire setup
of individual audio actors
that they can use to place
around in the scene to actually
spatialize and get things to
sound like on the left or right
and actually organize
it to their needs.
So they can see in here--
you can kind of see
and here we have some
stuff for Viper where
we can trigger like his actual
footsteps in and rustle sounds.
All that stuff is kind
of handled in our system
where we can place
all the stuff.
And all this stuff like you're
seeing here can be edited
and is edited real
time inside of Unreal.
We don't go into
Maya for any of this.
And that was a huge win
for us, because, basically,
what you see here is what I
just showed you when I hit play.
There's no real
difference in most cases.
There might be
like one off things
here and there where like
effects might look different
if they play, but other
than that, the main really
important stuff--
how the shot looks,
where the characters are,
the lighting-- is
all in the scene
and ready to go and composited
the way we want it to look.
So yeah, I believe that
pretty much is the main stuff
we wanted to talk about there.
>>Joseph: Kind of the overview.
And we'll get into
a little bit more
of these different
pieces in detail.
We'll be deep diving into
some of the different tools
and also into the general
2D hybrid approach itself,
because there is a lot
leaning on Paper 2D
and there's a lot of
cool custom stuff.
So we'll get into that.
That was kind of a
high-level, "Here's
what a scene looks like."
But if you want to switch
over to the script,
we can kind of start from
the beginning about what
an episode is involved with.
>>Zuko: Yeah, let me
change over to the--
>>Joseph: What is
involved in an episode.
>>Zuko: --full screen here.
Circle.
So now you should
see my taskbar.
So this is where Nolan is going
to talk about this script.
>>Joseph: I'm going to
talk just briefly just
kind of an overview of it.
>>Zuko: OK, all.
>>Joseph: OK, this is the script,
which may look pretty boring
and it is, but this is
where the episode starts.
>>Victor: Hang on.
>>Joseph: Everything.
>>Victor: One moment.
Sorry, Joe.
Zuko's stream is not
coming through on my end.
>>Zuko: Oh, because it switched.
>>Victor: Let's see, I'm only
seeing loading Discord squares.
>>Joseph: Do you want to stop
streaming and stream again,
Zuko?
>>Victor: Let me see if I can.
Hmm.
See if I can stop--
>>Joseph: Because I see it on--
>>Victor: --stop--
>>Joseph: --my end
>>Victor: --and stop again.
It's not working.
>>Zuko: I can kill it
and try it again.
>>Victor: Yeah, let's try that.
>>Zuko: Do, do.
How's that?
>>Victor: There we go.
Awesome
>>Zuko: Cool.
>>Joseph: Cool, right,
this is the script.
You can see we even
have a little thumbnails
for storyboards in there.
We essentially--
everything starts here.
This script is not just a place
where we record the story,
this is actually where
the brain of everything,
of the entire episode, happens.
We have a lot of, not
necessarily logic in here,
but we do have kind of a
roadmap for how all the auto
generation happens.
And we realize
that if we're going
to build these
things quick, we were
going to need to
emphasize, one, lowering
iteration time on managing all
the refinement of the episode.
Two, paralyzing as
much as possible,
so that people could
be working in tandem.
And then, three, auto-generating
as much as possible.
And so as much as possible,
we have the decisions
and the roadmap
for what scenes get
connected to what, which VO
stuff gets connected in here.
And that's what Nolan's
going to be talking about.
But essentially, we
will start writing here,
format everything from there
on, and kind of designate
where the games are
going to be, where you're
going to jump into
an explore phase
and kind of the high-level
level objectives of the episode.
And from there, we can
pass it off to Nolan
to talk about generation.
>>Nolan: Sure.
Yeah, so, like Joe was saying,
this is where he starts.
This is the kind of the
beginning of an episode.
He opens it up, does all
the writing, everything.
Once he's satisfied with
that, he hands it off to me
and it's pretty much
just a blank script.
And there's several
tools that we actually
added into Google Sheets.
Yes, you can see right there
where Zuko is hovering, just
like different
scripts-- things to help
to validate for common errors,
do a lot of auto population.
In the first column, there's
like a bunch of Real IDs.
It just generates
all that to make
sure you avoid errors that would
happen when you're hand-setting
things up.
The overall idea of
all this is to try
and make the iteration time
as fast as possible, right?
We wanted to make it so that
the time you actually spend
setting up a new
episode, there's
not really much downtime.
That way, animators and artists,
everybody who wants work on it,
isn't waiting on a new creation.
You don't have to
like stagger a ton
between the different episodes.
So just trying to make
it as fast as possible.
As you continue to, if you
scroll to the right, Zuko,
there's just paths
that are set up
for where the dialogue
is supposed to be,
where the different sequences
are going to be generated.
So a lot of stuff so that,
eventually, this gets
exported into Unreal.
So actually, the first step
after Joe creates a script
and I take care of a
few things, we actually
have something to export--
VO scripts for the voice actors.
So these are formatted like
a screenplay-- something
that the voice
actors are used to.
You can see this is Viper's.
It highlights his
role automatically.
Just something to make it
as easy and comfortable
as possible for the voice
actors since we are obviously
heavily reliant on them.
So there's that.
And then, at this point,
VO scripts are generated.
Joe goes and does VO
sessions with all the actors,
however long that
takes eventually.
We get back audio and we
import all the dialogue
into the engine.
As you can see,
here there's a lot.
Zuko is scrolling through.
So now that the dialogue is
imported from the Google Sheet,
we export a couple
of different CSVs.
We just do a little bit
of pre-processing stuff
so that Unreal can
handle it nicely.
And as you can see
this one is
connected to there to the sound
waves and everything like that.
It's already got the references,
scene IDs, and everything
like that.
So using these, now
we're pretty much
ready to generate the
episode at this point.
So now that I've got these data
tables, the first thing we do
is we actually generate
all of the sequences
that the animators
are going to be using
and all the dialogue is
connected to everything.
So there's about 500
to 1,000 sequences
that get generated per episode
depending how long it is.
>>Joseph: So you can see thousands
of thousands of these things
across the whole season 1.
>>Nolan: Yeah.
>>Joseph: Doing it by hand will
not have been a good idea.
>>Nolan: Yeah, a lot of this
was to avoid hand generation
errors, allow things to
automatically be connected
and set up.
We really wanted promote the--
a lot of time to be able to spend--
Yeah, 6,500 you said?
>>Zuko: Oof, yeah, that's what's
in our engine right now.
>>Nolan: Yeah, it's a lot.
There's a lot.
But basically, all
these are generated
as a blank slate for
animators and artists
and anybody who needs to
jump in here and do stuff,
so that they can come in
and everything's already
set up for them.
Can you open the master
sequence for me, Zuko?
>>Zuko: Yeah, yeah.
I'll just grab--
>>Nolan: Scene 7--
>>Zuko: The same one, yeah.
>>Nolan: Yeah.
>>Zuko: Don't remind
me of that stuff.
>>Nolan: Again, Zuko overviewed a
little bit it's what's in here,
but there's a lot going on.
So what we used to
generate this is
we actually use the Python
scripting plugin for Unreal.
I think that came out
in 4.21 last year or so.
And so using that,
it's pretty convenient
to go in and generate a
lot of different stuff
for these sequences.
So we've got a camera cut track
that's automatically added,
all of the characters
are set up as spawnables.
Again, this is all
based on what's
coming from the script, so
everything that Joe wrote.
>>Zuko: You can see like we have
the actual roles on the script.
>>Nolan: Yeah, so everything
is pulled from there
for all the script sequences.
And then if you expand
a character-- can
you just expand Viper,
Kevin right there?
So you can see, again, here's
all the different tracks.
So what's cool is
that, all these tracks,
these are all
automatically set up
and attached to that character.
And which track gets
generated is actually
specified by the rig and what
the rig supports and exposes.
So for different
types of characters
that are animating different
ways, those tracks,
they'll look different.
But it's all it's all fairly
automated just depending
on what the rig supports.
>>Zuko: So where did it go?
>>Nolan: That's nice if Zuko
goes and adds more support
for the rig, adds more controls,
as a third arm to Kevin,
something like that.
You can just think of sequences
and it adds these new tracks
right away and they're
immediately animatable.
>>Joseph: So I think it's
important to really
quickly mention, like,
doing the stuff by hand,
this may only take
the animator a minute
or two to actually important
and setup these tracks, maybe
a few minutes, but now multiply
that by 6,500 sequences
and then you start
to see why automation
is super important for even
these things that seem trivial.
>>Nolan: Yeah, sure.
So even more so if you
look at the sub-sequences.
There's even more of these
relative to the masters.
So if you open one
of those, Zuko.
This is where each individual
dialogue file gets set up.
So in here, the nice
segmented area, again,
it's its own sequence,
so that this is where
we do the lip-syncing thinking.
You know, an animator
comes in here
and, in parallel
to everything else,
all the other work
go through, and do
the whole lip-syncing
pass on the episode.
So we'll go into that a
little more with the tool
that we use to do that later on.
Also in there,
it's automatically
set up with captions.
We don't have to do anything
with captions beyond what Joe
writes in the script.
Just a little string track.
And then Zuko mentioned
the audio sequence.
So there's that.
That's kind of the own
area for the sound guys
to go add sound effects, music,
footsteps, anything like that.
Anything they want to
throw into the sequence--
their own little
playground for that.
We have things such
as sequence settings,
so the game fully supports being
able to fast forward, rewind,
skip scenes.
>>Victor: All right.
>>Nolan: It's almost like a
DVD or a movie or something.
You can skip around so.
Inside of those, oh,
thanks for opening those.
Yeah, you can see we
use a data asset here
to actually pre-calculate the
various skip times that we
want, depending on exactly
how we want to space those,
whether we want it at the
start of every dialog is,
actually, for the most
part, what we do right now.
Just so it's nice, clean
moments where you fast
forward and rewind to.
Also, a few other things.
We store play playtime in there.
Just some of the
things we might not
have access to at runtime
that we have at editor time.
So just exposing a few of those.
Let's see, you can--
we've added support where
you can add new characters
through right click menu.
If you just show that right
quick, Zuko, on sequence.
>>Zuko: So many things
I keep forgetting.
>>Nolan: Yeah.
Yeah, so this--
>>Joseph: We've done a
lot of cool things here.
>>Nolan: --this whole right
click menu or all this stuff is
connected to a little bit of
C++ and Python to create these
dynamic menus.
So basically, if we add
support for new characters,
they're automatically
thrown in this list.
You can go in and animators
can add an extra--
if it's a non-speaking
role, not in the script,
and they want him walking by
in the background or something
like that, it's
really easy for them
to add it and animate them.
So at this point, the
sequences are all generated,
we're ready go with that.
I still haven't unleashed it
to the animators, everybody.
Yeah, it's just still just me
kind of prepping and getting
everything to go.
At this point, using
one of the data tables,
again, that we imported from
Google Sheets, from here,
I get like another menu on
the right click of the scenes
table.
Just something that, again,
was exposed by Python.
Yeah, right there.
Generate episode level.
So that goes and goes through
and actually generates
the entire episode
framework at that point,
based on the script.
It goes and creates all
of the different UMAP
files, which is a around,
I think, 40 to 50 levels
per episode about.
We use level streaming
to kind of seamlessly
go between different
scenes and everything
like that and embedding
scenes within each other.
So this, Zuko, how
long did it take
you to set one of
these up by hand
before we did any sort of--
[INTERPOSING VOICES]
>>Zuko: Yeah.
Just getting
everything connected.
>>Nolan: Yeah, and
that's if there's
like no errors and stuff, right?
Like that's hand setting
it up all already.
>>Joseph: Can we back up a
little bit, Nolan, real quick?
And just describe--
>>Nolan: Yeah.
>>Joseph: So this, just
in case it isn't clear,
this map right here--
this is a visualization
of it here,
but essentially, the setup is
they're talking about now--
we talked to you about how the
scenes themselves are set up--
this is what connects the dots
between the scenes and says,
play scene 1.
We're done?
Play scene 2.
Scene 2's done?
Play the explore plot
phase or the game.
Now go back to scene 3 or even
logic jumping back and forth
between different scenes.
This is that setup phase, which
we also wanted to automate.
>>Nolan: Definitely.
Thanks for pointing
that out and everything.
Yeah, there's different
scene managers.
You can see those
little pick nodes.
Basically just the identity
of the different scenes,
the different games,
different explore phases,
stuff like that.
So this is as each of those 40
to 50 levels were generated.
All the actors in
those levels are
basically pre-processed
to establish connections
between the different levels
and then kind of, again,
make it so that we don't need
to hand set up a new episode.
This is all done--
I think it takes about
15 minutes or so?
It takes a good amount of time
to actually generate new levels
and saving them and everything.
That's most of the time.
But then, shove what
used to be a day's
task with potential
errors down to 15 minutes
of just generating,
which is really nice.
And at end of this, after
you're done generating,
you can now play through
the episode start to finish.
Obviously, there's no art you
see some of the characters,
but they're just standing there.
There's no animation.
But it's got-- it starts
off, it generates a menu,
it's got the intro
to the episode.
It runs through the whole
thing kind of like a radio
play or something.
You can listen to it.
You've got captions.
And at the end, it goes to the
leaderboard and everything.
And so it's just nice
to be able to have
that whole complete framework.
And then at this point, I'm
pretty much done on that part.
I get this all checked in,
hand it off to the animators.
And I guess more specifically,
I hand it off to Joe first.
And then, Joe, if you
want to take over.
Joe basically does a
director pass at this point.
>>Joseph: Sure.
Yeah, so I get handed back--
and just so you know, there's
an awful lot to Terrible Posture
Games than just the three of us.
While all this
stuff is happening,
the animators will start
diving into lip-syncing.
The artists and tech
artists will start diving
into building up the levels.
Even the sound guys
will be finishing up
the previous episode
while everyone else is
diving into these ones.
We kind of, again, have
the multiple tracks
going at one time.
It's kind of a
logistically exciting.
And what I get at this
point is, essentially,
one of these sequences
with no animation
and it's almost
like a radio play
where all of the sound
files just linked up one
after each other.
Which, for a comedic
game, means that you
need to go in and kind of refine
timing and get some delays
and there, some
good comedic beats.
Or even having people
interrupt each other
at times or
occasionally you'll find
a sound, a combination
of dialogue lines,
just doesn't work.
And so you'll be like, you
know what, let's edit this
and change things
around a little bit.
So that's the director phase
that happens right here.
I'll go in and
essentially take it
from being very linear to being
much more like stop and start
based off of where we
want the comedy to be.
I'll go in and add gaps,
spaces, take away gaps.
I'll go in and I'll
take the dialogue lines
and smoosh them up
against each other.
So what comes out of here is
basically a vocal performance
of the scene as if it had
been more like read naturally
in a live environment.
And then the animators can
start animating to this
and they kind of know where
everything is going to fall.
So that's actually a pretty
quick part of the process,
but it is one of
the few manual parts
before we hand it off
for the spoke animation.
This is kind of where the by
hand artistry begins to happen.
So Zuko, you want to
kind of dive a little bit
into what else is going
on during all this?
>>Zuko: Yeah, I think I'm
going to go ahead and explain
kind of what we're
even looking at here.
Nolan kind of touched
on a few of it,
but I'll just jump into
the actual scene management
systems.
So after Nolan
generates everything,
we pretty much get all of these
levels here generated for us.
These are scene levels.
Then on top of that,
we have geo levels.
Geo levels are like
supporting levels.
I can't show them all in the
world map or else my machine
will kind of cry a
little bit, but the idea
is that we actually split the
scene into two different parts.
And each scene has a system
that I created called the scene
manager.
The scene manager
is a node based--
actor based node system
where you can kind of connect
to different actors together to
talk to each other from scene
to scene.
And the way that they're
linked to each other
is just simply like right here.
If you see the top
node here, this
is the scene manager itself.
And it says, hey, I'm E05 scene
02 and next I'm going to go
to E00 SGD forced.
For us, that's
studio game forced.
So that's the shark game.
That's what we kind of
coined the studio game.
And then after
that, then there's
actions that can happen.
Most of the actions
in games are--
most of the action in
our game are cutscenes.
So we'll see like,
"Play cutscene."
And this is literally
saying, "Play the cutscene."
And then after the
cutscene finishes,
it'll go to the forced game.
So with this, I can kind of
visualize the entire episode
in a tool that I
created for seeing just
how these links actually
work with each other.
So this is the entire scene map
of our episode for the battle
royal episode.
So from here I can
validate whether or not
a [AUDIO OUT] dub.
So we have the intro episode.
I have a bunch of actions
underneath the intro episode.
Then I have scene 2.
An action for playing
the actual cutscene.
Then the forced short
game and on and on and on.
It's all linked together.
It's all ready to go and
it plays all the way down.
If I go and scroll, I can
get to the leaderboard.
And then once I see
the leaderboard,
I know that, pretty
much, it should
be able to play from beginning
to end in an entire world map.
And now I think a really good
way to kind of show this off--
really the reason
why we went down
this like node based structure
more than anything else is
because actors
will kind of allow
for the flexibility of just
being able to sit in the world
and have other things
connected to it.
So that's why like
we can quickly set up
"Play cut scene." we don't have
to go into other blueprints
and throw these nodes
in all over the place.
We can have a tool actually
like generate all of this stuff.
And that's where a lot of
the automation comes in.
So the scene itself, if
I go back to scene 17,
you can see while all
the animation is starting
to ramp up everything, we
also have, like I was saying,
the geometry levels.
Like everything that requires--
every visual element and
a level is separated,
so I can just kind
of like hide it.
You can see that some
things aren't, so we kind of
have some extra,
like, fog post effects
that kind of are added to the
level on a per case basis.
And I shouldn't
read chat right now,
because it said I head
Zuko ate a penguin.
>>Joseph: Oh, no it looks
like memory isn't the same.
It's hard to tell where Zuko
ends and scene manager begins,
which I appreciate.
>>Zuko: Oh, yeah, the
entire level is--
we have the 3D, 2D art style, so
all of the environment artists
will go in and they'll
place their assets that we
can use in different scenes.
And the reason why we
split it out this way
is so that way
the animators have
free reign over whatever else
they want to add to the scene.
So they don't kind of clash.
It's easy with Unreal
to, like, the levels,
you can't have two people
working in one level at a time.
Yet, I'm sure in the
future there might be that.
But at the moment, you
can't have two people
in the same level working.
So the decision to split
it out was pretty easy.
Along with that, the
idea behind the animators
having full control means
that they can add things
into this into this level.
So what they are able
to do is they can go in
and, in this scene--
we're back to the
"shoot me" scene--
animators have the ability
to actually add like the guns
to the level.
Or really in this
case just the guns.
The doors opening,
windows opening.
>>Nolan: The helmet.
>>Zuko: Mhm.
>>Joseph: Helmet.
Well, the helmet
is an attachment.
>>Zuko: The helmet actually comes
with Kevin in this episode.
This episode was
kind of experimental.
This was this was
the first episode,
we actually got
attachments working.
Because we wanted a way--
you can in Sequencer--
you can attach anything
to something in Sequencer
simply by doing like--
If you add it in, you
can go to here and then
do attach to a binding.
This is something
that it can work,
but for us, we needed
something more controlled
and something that was
easier for like an animator
to kind of like get
in and do stuff.
So if I wanted to add an
attachment in the scene,
I literally just go to
here and I can go to Kevin.
Well, he has like a sprite.
So I can add a ketchup a
bottle and now, in this scene,
the animator has
a ketchup bottle
and they can just go ahead
and do whatever they need
to do with the ketchup bottle.
They can switch hands
and all that stuff
with the attachments.
>>Joseph: Can we actually take a
little a little sidestep here
though?
Because like--
>>Zuko: Yeah, for sure.
>>Joseph: --we leveraged
this system pretty heavily.
In this episode, this
battle royal episode,
there's an explore phase
where you can pick up
all the different armor.
You're playing as the green tech
artist guy named Pylon and what
you pick up is up to you,
but the rest of the episode
can propagate that.
So essentially, it's
like, suddenly, we're
starting to take the dynamic
benefits of being real time
and apply them to the cut
scenes and creative visual ways.
The rest of the
episode, that character
will have that variety of
armor you've picked up on.
Which, when you're speaking
about just pure games,
that's pretty standard.
But when you talk about
the show side of it,
that's something you don't
really see generally in--
well, I mean, you don't
really see that in shows
because they're not interactive.
So it's kind of a
cool little thing that
came along with the system.
>>Zuko: Right.
I think that's really important
to mention, so thanks.
>>Joseph: Sorry, we were
actually, at this point,
you wanted to talk a little bit
briefly about the scene origin,
I believe, right?
>>Zuko: Right, yes.
I was like, there's
a lot of things,
so getting the
order correct here.
So yeah, the scene origin point.
This is kind of where
all this stuff happened.
You just saw that I have
some extra stuff in here.
They're like buttons.
These are these are
editor buttons that you
can use with customer events.
But this kind of was old stuff
before the we got the Editor
Utility Widget system.
So you can see that that was
like the scene manager tool
that I showed was.
So thankfully, the
Editor Utility Widgets
are basically lifesavers, so you
don't have to do this anymore.
>>Nolan: Yeah, they're awesome.
>>Joseph: Right, so if you're
keeping track, Victor,
that's Sequencer, Python,
Editor Utility Widgets.
We are big fans of those
three systems pretty heavily.
>>Zuko: Yes.
>>Victor: Which version of
Unreal are you currently on?
>>Joseph: 4.24.
>>Nolan: 4.23.
Oh, is it 4.23 or 4?
1?
4?
>>Joseph: I think
we're on the latest.
>>Nolan: No, I don't know.
>>Zuko: 4.24.
>>Joseph: 4.24.3.
>>Nolan: 4.24.3.
I just looked.
>>Zuko: Yeah.
That's the latest 4.24 version.
>>Nolan: Oh, yeah.
>>Joseph: Now 4.25.
>>Zuko: Oh, 4.25?
4.20!
So yeah.
The animators have, at this
point you can pretty much--
I'm going to keep saying it.
The animators have
full control of what
they are able to do in
the scene in editor.
The other thing, too, is
with the level separated,
environment artists are going
to go and do their thing.
Animators are going
to their thing.
On top of that, the
animators can actually
change the entire
scenes position
just by using this scene origin
that is created specifically
for this purpose to have some
sort of relative location
that all of the characters
are using to have position.
And this means that they can
move the entire scene around.
And now this whole scene
will play in this spot.
They can even animate so
that this scene origin,
if they needed to
do it at the end,
they can animate it like this.
Then at a certain point,
they can move it over here
and it'll play the two
different spots just like that.
So this is something
that we found really
[AUDIO OUT]
>>Victor: All right, I
think we are back now.
OK, sorry about that.
>>Joseph: I thought I
saw you disappear.
>>Victor: Disappear and
waving frenetically
to try to get you on.
Oh the interface crashed again.
I promise, chat,
before next Thursday,
I am going to buy a
new audio interface.
I'm a little disappointed
with this one.
All right, let's get back to it.
Sorry about that.
>>Joseph: Sorry, is everything--
Are we moving along
at a decent pace?
Did you want to actually
take the moment to pull out
any questions, Victor?
>>Victor: We had a few.
If you want to go
ahead and answer them
I think chat would
appreciate that.
>>Zuko: Sure.
>>Joseph: Just since we had that
good break, maybe now we can--
>>Victor: For sure.
Yeah, some of them are relevant.
One of these were
curious if the ice
were a shader because
it seems like they
blinked automatically.
>>Joseph: They do, but--
>>Zuko: Yeah, the eyes
are actually Paper 2D,
but they're switching
which sprite
it is based on logic in
their animation blueprint.
>>Nolan: Are they tied
into editor Tick
right now, so that's
why they're blinking?
Not in play mode?
>>Zuko: Yes.
It's weird because they
just constantly blink
while the animator's
going and doing stuff.
You can also turn on, turn
off the automatic blink
and like make them
blink manually too,
but yeah they aren't
blinking via a shader.
>>Victor: Except for Viper,
who is inverted, right?
Like Viper's always closed,
but sometimes opens his eyes.
>>Zuko: Yeah, Viper,
that's just on purpose.
>>Nolan: He's got a weird set up.
[LAUGHTER]
>>Viper: Shoot me!
>>Joseph: He's got the, like,
Clint Eastwood action eyes.
>>Victor: Since you
mentioned paper 2D there,
there was a question if
Terrible Posture Games used
a custom system
for the 2D assets
or a modern form of paper 2D?
>>Joseph: Whoa, we're
going to get into that.
[LAUGHTER]
>>Zuko: Well, I mean, we didn't--
we just kind of made Paper 2D--
some aspects of it there's
a little bit of bugginess,
but we kind of made it a little
bit nicer but not too much.
But yes, all of the assets for
the characters are Paper 2D.
They are sprites
using flip books.
>>Joseph: Which we'll dive into in
a little bit heavier of a topic
in a minute actually.
We wanted to kind of--
>>Zuko: I think we're just
about getting there, yeah.
>>Joseph: Yeah, just about.
Anything else you wanted to ask?
Or do you want us to go
right into that stuff?
>>Victor: Those are good for now.
I have a few more later,
but they're more general,
so we can in for the end.
>>Joseph: OK, great.
I think we've probably talked
quite a bit about lip-sync
already.
Do you all just want
to kind of move right
into the custom
tools, since we're
kind of looking at about
50 minutes in right now?
>>Nolan: Yeah, I'd say let's
show off the tool at least.
>>Zuko: Yeah.
>>Nolan: It's pretty quick.
It's a few minutes.
>>Joseph: All right,
let's do it then.
>>Nolan: People were asking
about our because custom tools
and everything earlier too.
>>Joseph: Yeah, we got
a lot of custom tools.
Mm-hmm.
>>Nolan: Yeah, so
this lip-sync tool,
we've basically decided
early on that we wanted
to do our lip-syncing manually.
We didn't want to have
an automated process.
We really wanted
it to feel organic
and be able to do really
big exaggerated results.
And we felt like in
order to do that,
you really needed to get
an animator involved who
could go through and do this.
Because of that, we
needed to make sure
that the manual process was
really fast and easy to use.
And originally, I think it
took about 10 minutes per line
for somebody to go through.
And there's like a dropdown
through the mouth type
that they have to
go key and it's just
a list of probably 10, 15--
just the names.
So you can see there
these different phonemes,
And you didn't have any visual.
It was just text.
You kind of had to
really know what phonemes
correlated with what sound.
So it's a lot of just
being really used
to that list and
just a lot of having
to go back and forth
in the sequencer
and it just was a little
clunky in that process,
especially where we wanted
it to just be really fast.
In this, here's another editor
utility which I whipped up.
And this basically has
nice big visualizations
for all the phonemes
you can choose.
It actually has--
I did a little bit of a hack.
So Editor Utility Widgets, at
least right now or as of 4.24,
don't support the custom input.
So there's no hotkeys
for those specific tool.
It's really difficult
to get input to it.
So actually, what
we use at the top,
you can see there's a
text area where you just
click into that to get focused.
And then we just parse
the keyboard input
in a really kind of old
school way for handling that.
So it works out pretty
well for the animators.
So now, essentially,
what you do--
you can hear as scrolls through
that, he's using hotkeys.
And it's almost like playing
a video game when you
go through the lip-syncing now.
You put your hands
on WASD and you
get your mouse hovered over
the different phonemes.
And you're scrolling through
the different-- a bunch
of different hotkeys.
Go forward by one
frame, five frame.
Next key, previous key.
You could see the
buttons if you forget.
You can hover over those
to see that tooltips.
We can't see the tooltips
actually right now
because the way
Zuko's streaming.
>>Zuko: Yeah, I'm trying to
familiarize myself again.
>>Nolan: Yeah, but there's a few.
There's preview the
sound on that exact frame
so you can really see, like,
is Kevin saying like, fuh, fuh,
fuh?
Exactly, so you don't
have to sit there
and scrub back and forth
using the timeline.
I think this is
quite successful.
As you can see,
it plays through.
It highlights the
active phoneme.
I think it took--
Liam's in the chat.
He could comment how
fast it takes to do
an individual line on average.
>>Joseph: Yeah, it took like 8
to 12 minutes before per line.
And you're looking at 350
lines to a 400 to 500 lines
per episode.
How long does it take now?
Maybe he'll respond.
Maybe he's not
listening anymore.
>>Nolan: Well, it was--
I think it took about--
>>Zuko: A minute.
>>Nolan: --a week or so.
>>Joseph: Two now?
Awesome.
>>Nolan: Yeah, we had
a few less animators
and it did take about a
week or so to fully lip-sync
the episode.
It was way too long.
So now you know we have
like a lip-sync party where
all the animators come
in and in just one day
they bust out all the
lip-syncing for the episode
in one day and it's really fast.
And as far I've heard,
all their feedback,
this process is
working pretty well.
Certainly keeping an eye out
for any improvements we can do,
but I really like it.
Anyway, we can
move on from there.
>>Joseph: Well,
actually, real quickly,
we should drop in why we didn't
go with an auto lip-syncing
route.
There are auto lip-syncing
tools that you could use
and you get results that
are varying in quality,
but we didn't go that way.
Why?
>>Nolan: Yeah, well, I
mentioned that earlier, right?
We just wanted the organic--
be able to have nice,
exaggerated things.
Especially, because
we really need things
to be funny to get that comedy.
A lot of times it depends.
It depends on the
mouth lining up
with the different facial
animations and everything.
And so to have that disconnect
of like the animators having
full control over the face
and the eye expressions,
everything like that
and then just the mouth
is completely automated-- it
would be a big disconnect.
>>Joseph: You'd probably spend
more time cleaning it up than--
>>Nolan: Yeah.
>>Joseph: --doing it this way.
>>Nolan: Definitely.
So that's really why
we went with that.
Just trying to make this
process as easy as possible.
Yeah, so I think I
think that's about it.
>>Zuko: Yeah, I'll
quickly show just so
that people can see how
the actual graph looks
for that tool.
The hotkeys.
Just because I
think it is a hack,
but it is something
that I think is
very important for people
who are interested in tool
making to know, because
having hotkey power
is really powerful.
[LAUGHS]
>>Nolan: Well, it's nice.
Like you said, if you don't want
to have to come in and do code,
this lets you still live in
the world of Editors Utility
Widgets.
I think if you wanted to make
a slate or a window that--
>>Zuko: It would take--
>>Nolan: --would be
able to take hotkeys--
>>Zuko: --quite a bit more time.
>>Nolan: You have to make
a full slate window,
which is a lot of C++ to be
able to get to that point.
So people who are really
Blueprint only developers,
correct me if I'm wrong,
Victor, if I speak wrong,
but I'm pretty sure that
this is a good way if they
want to make tools
where they can get input
hotkeys like that.
>>Victor: Especially since it
doesn't require any code,
you can just Blueprint it all.
>>Nolan: Yeah, it's really nice.
>>Zuko: Yeah.
>>Nolan: And I will say--
I'll shout-out-- I actually
really like Blueprint.
I think that you
guys have taken that
in a really good direction.
So I'm curious--
>>Zuko: That's a
programmer saying that.
>>Nolan: --for that
looks in like--
No, it is, it is.
[INTERPOSING VOICES]
>>Zuko: A programmer from Unity
side of things, no less.
>>Nolan: You know, I love C++
on that too, but I think,
especially in this game, it's
really important for Blueprint.
We've got a lot people--
the tech artists, everything,
people can hop in and do stuff.
>>Joseph: Yeah, actually, to
get super high level here,
a game like 3 Out
of 10, a game which
is designed to be made
episodically with tons
it for many games where
every single mini game
is a different kind of
game-- it's actually
like a ton of different
kinds of actual games.
This just flat out would not
be possible without Blueprint.
Blueprint puts
power into the hands
of a lot more
people, which allow
the removal of bottlenecks
about who's creating the logic.
And I mean, yes, you do have
to kind call the standards
and you do have to
think about how you're
going to put a framework
around these things,
but there's always
this argument about,
like, non-programmers
shouldn't be programming.
Learning how to work around
constraints is not as--
people are smarter than I think
programmer programmers would
give them credit for.
And they can adapt
to constraints.
That's my soapbox.
I like Blueprint.
>>Nolan: At least my
experience, everybody here
has been doing a
pretty good job.
And we have we have some issues,
but train them up, get them
out.
It's not like a lot
of the Blueprints
that people are making
are super, super crazy
technical or anything.
So I think it's good.
I think it fills a good niche.
>>Joseph: I think I'm probably
the most dangerous Blueprinter
on the team because I come in
and out only every few months
and the standards
you all have been
rolling with have changed--
>>Zuko: You are pretty--
>>Joseph: --by the time--
>>Zuko: --dangerous.
>>Joseph: --I come back.
>>Zuko: We have to
keep an eye on you.
>>Joseph: Yeah.
>>Nolan: Yeah.
>>Zuko: Yeah, so
this hotkey thing.
I'm going to reel
this back into what
we were talking about here.
It's an edible text box.
That's all it is.
With using the vent on it
to look for on text change.
When that text changes,
there is the event over here.
I believe it's this one--
on text change event.
And all they're doing--
all Nolan was doing
is just straight up saying
when that text changes, it
has an input text
variable, and then
you use that on, I believe,
on Tick, probably, somewhere.
You'd use that basically
as your way to--
>>Nolan: Yeah, there is that.
It's on Tick.
It's just detecting what
your keyboard input is
and just parsing it out.
>>Zuko: Yeah.
Process input right here.
>>Joseph: Do you
flush it after that
so that it becomes zeroed again?
>>Nolan: Yeah.
So it basically just continually
wipes out the text area.
So you never see what you type.
It just kind of
takes that stuff.
I think that's an old
school technique maybe
I used in like some of
my first programs written
in like command prompt to make
little games in the command
prompt and stuff.
I think that's the
last time I used that.
>>Zuko: Yeah, it's just a fun
little hack that you can use
and it's and it's totally
available and really easy
to do in Editor Utility Widget.
So that's why I think it's
really important to just show
that off, because--
>>Joseph: I think we should
also stress though, that's
Editor Utility Widgets, which
means this is essentially
a tool for your dev team.
It's not like this is
how we're releasing
the input for the game.
>>Zuko: Oh yeah.
>>Joseph: This is tool side
for us internally to be able
to do our job--
>>Zuko: That's going to be--
>>Joseph: --faster.
>>Zuko: --a weird question later.
"So is all this in the game?"
Nah.
So yeah, I think now we can
move on to the actual rig.
>>Joseph: Yeah, let's talk
about this right here.
We've got some cool stuff.
So let's show that off.
>>Zuko: Cool.
So as you've seen,
everything is all in Editor.
It's all real time and
animatable and everything.
The way that we kind of started
with this is, on any Blueprint,
you can designate already--
you can designate any property
value to have a widget.
And to do this,
it's literally just
a checkbox on the property.
So if I go and I like--
you can see all the
Blueprint stuff, yeah.
Cool.
>>Joseph: Yeah.
>>Zuko: Just making sure.
So on a here--
>>Joseph: The high
level here, you're
talking about the
manipulators, which
are the foundation of this rig.
>>Zuko: Yeah, I'm getting to it.
>>Joseph: Mm-hmm.
>>Zuko: So right here,
this head FK transform,
is using a show 3D widget
checkbox with that on.
Unreal already has the support
to be able to click this head
FK, and you can even see it
says head FK, and move it around
and do whatever it needs to do.
I took that idea and was
like, well, I kind of want
more power than just that.
I want to be able to
take this and make
it visually what I
wanted to make it,
almost like a rig in Maya.
If you've ever seen
a rig for Maya that
is set up like from
a technical animator,
it has all the visual
elements to make
and animators life less cringe.
So then, with that
power, I settled
on this, what I call
the manipulator tools.
So the manipulator
tools is a system
which allows you to add
components onto any Blueprint.
So if I select Kevin
here, these are just
components that on Kevin.
Oh, I got rid of my viewport.
Hold on.
I literally just hit the X on
something I wanted to keep.
Get into there do it.
Cool.
So we have our actual rig
and these manipulators
are something that can
be added to any Blueprint
and controlled as to whether
it's a transform vector, bool,
or an enum that is manipulating.
And these, just like the
show 3D widget checkbox,
it is the exact same
type of like linkage.
You tell it which property to
look at and then from there,
the actual rig sends the
data to the character
after moving the manipulator.
So all that stuff is really
cool to have to make something
as robust as this and
customizable inside
of the engine.
And I can kind of give
you a little preview
of what all of these
manipulators look like.
Inside of here, all these
green icons you can see
are the manipulator components.
And each one of these is just
saying which property should I
link to, what type
of property it is,
and then it has all of
the visual elements that
allows it to display.
This allows us-- and they're
literally just added components
that changes.
And this allows us
a lot of versatility
when it came to making the rig.
And you can see,
I can move around
and actually, as an animator,
I can move and get his arm
into place.
I can screw up his elbow.
And now, inside
of the sequencer,
it's auto keying as well
while I'm doing all this.
So if I actually play,
you can see it goes back
and he'll pop into that spot.
Yeah, all of this stuff--
>>Joseph: Can you do
that a little bit more?
Just like play around with
some of the controls there?
Because you--
>>Zuko: Yeah.
>>Joseph: --have kind of different
controls on that thing.
>>Zuko: I do.
So we have the hands.
We can stretch them
to a certain length.
We have the actual
torso control, which
can be also scaled in fun ways.
>>Nolan: Oh, his neck.
>>Zuko: We have to be
careful about the neck,
because the neck
is a very weird--
has to be weird type of piece.
And he can kind of
do his thing now.
I'm not an animator,
so my poses are not
going to look nearly as good.
>>Joseph: I think
that looks great.
What are you talking about?
[CHUCKLES]
>>Zuko: Yeah, yeah.
I mean, we might.
>>Nolan: That shit belongs
to the [INAUDIBLE].
>>Zuko: So the other thing too
is that all of these characters
as you kind of seen, they
have four different views.
So if I link all the
views, you can see--
maybe I should put Kevin
back before I show this off.
>>Nolan: What are
you talking about?
That's great.
We'll get him to--
>>Zuko: Big head mode.
>>Nolan: Good luck.
>>Zuko: In the kind of
something that was--
>>Joseph: We're going to
do a big head episode.
>>Zuko: I'll go to
a different frame.
So we can see that
we can actually
control the actual
views on the character.
And if I linked the
head, he'll actually
turn almost as if he's 3D.
And all this stuff is using
Paper 2D's Flipbooks, which,
hindsight, if you ever have
the thought process of, hey,
I should use Flipbooks
to quickly change between
different sprites, and you're
not actually using them
for Flipbooks, don't.
You'll run into a lot of issues.
But we are using
Flipbooks to do it
because that's what
we started with
and it's really hard to
go back at this point.
We would just-- and now,
instead, I would probably
just have a sprite and I would
just switch between the sprites
manually.
Instead of putting it all
in a Flipbook like this
and then telling
which frame to play.
>>Joseph: There are benefits
that come along with it too,
especially when it
came to the culling
that you do around the
edges of the sprite.
>>Zuko: Yeah, that's what
the benefits of sprites.
I'm just saying,
Flipbooks themselves--
because Flipbooks
operate on Tick.
That's the issue
that we ran into,
is that these characters
have 26 pieces on them
and they're all running on Tick.
So we had to go in and actually
optimize the Flipbooks custom
in code and actually tell
them to kind of shut up
when we wanted them to shut up.
So you can see that the mouth
here, this is actually--
we can go to Kevin's pieces.
All the Flipbooks books
are set up in here
as the different views.
So if I go to like Kevin's
head, the way we kind of do
our views, we have a front
side, back side, and back view.
And all of those just
play depending on whatever
the animator decides to do.
And from here, these are
all individual sprites
that are based off of an
atlas for each of the views.
So we have like a front atlas
and corresponding atlases
for each of the different views.
From here, we have the
full power of Paper 2D
to be able to put in
custom rendered geometry,
the collision, and the
actual source region
stuff and the pivot points.
And really, the only thing
that we did custom in Paper 2D
is, just to kind of piggyback
off of the earlier question,
was we, by we I mean Nolan,
went in and actually fixed
the pivot point so that when
you modify the pivot in custom
pivot it actually updates
while you're doing that,
instead of waiting for
you to stop the movement.
That was one of the
big changes that
saved us a lot of
time for Paper 2D
when setting up
all these pieces.
Because before, it
would basically do this.
And then you do
this and then you'd
have to wait and then do
this, wait do this, wait.
>>Nolan: After all, there's not
really too many modifications
you did to it, right?
In the engine?
>>Zuko: I think the
only other thing
we did was when you're going
into edit a source region,
the camera would
reset sometimes.
And that's just a visual bug.
>>Nolan: Yeah, like
quality of life stuff.
>>Zuko: Yeah, so we
didn't really do any--
sorry, what, Joe?
>>Joseph: I was going to
say, can you pop open
one of the explorers
so people can actually
see as you're talking here, you
walk around and show the views.
>>Zuko: Yeah, I can get there.
We can go to--
>>Nolan: Click on Pylons.
>>Zuko: Yeah.
>>Victor: Just to clarify, there
were a few mentions of Control
Rig, but the entire
animation system
is actually based on your
custom components system, right?
>>Zuko: Correct, and we
actually looked, when we first
started 3 Out of 10, it was
around a year and a half,
two years ago.
So Control Rig was basically
in baby steps or baby format
at that point.
And we open it up,
we took a look,
and for our needs
at that point, we
decided to move forward with the
components over the Control Rig
just at the at that moment.
We are we are evaluating
it constantly,
and we would love to see it--
I think it's almost in a
finished state at this point.
>>Joseph: I think it's something--
>>Zuko: I had way more official
to say about that and I totally
didn't.
>>Joseph: Well, Control Rig is--
is just so you don't--
you all don't know--
excuse me.
Just in case you all
don't know, Control Rig
is a kind of a cool
way to also animate
within the engine like this.
It's focused little bit
more on skeletal meshes
and it's very cool.
And like Zuko said, we come
back and take a look at it
every couple of months
or every version or two
and we're like, OK,
has is it evolved?
When we set out to
do this, Control Rig
wasn't really an option.
And each time we look
at it, we're like, OK,
it's a little closer
to being an option.
>>Zuko: Yeah.
>>Joseph: Now we've
gone down this road.
>>Zuko: It's probably
the closest it's ever--
I've been seriously
considering it more
lately because of
all the improvements.
>>Joseph: Yeah, but
that would be like--
now that we have--
>>Zuko: It would be a
pretty big change--
>>Joseph: --spoke solution--
>>Zuko: --for us.
>>Joseph: That'd something we'd
have to look at, being like,
OK, so down the road.
>>Zuko: Yeah.
>>Joseph: Zuko Rig 3.0.
We would lean on that.
>>Zuko: That's what everybody
calls the rig, Zuko Rig.
>>Nolan: Yeah.
>>Zuko: To kind of piggyback
off of like the views
stuff in the Paper 2D
system with changing views,
not only is it possible
for the animators
to just change views on a
character during animations,
we can do it in the game too.
So this is kind of an example
of an explore phase where you
can walk around as a character.
And we're doing this based off
of one animation at the moment.
Where we have the
animators, that's
what the animation kind
of looks like by default.
Just at left or
right idle animation.
And then when I hit
the different look
like movement
directions, I change
that on the fly, which is
kind of good and bad thing.
You can see like Pylon's legs--
they look a little
weird in the back views.
But it's one of
those things where
we had to decide
like time over making
four different animations
for each views,
versus having the
ability to just change
the views on the fly.
Because there's a
lot of power in that.
And that I think to us was the
decision that we made for that.
>>Nolan: Man, you got to
pick up some attachments.
>>Joseph: Yeah.
>>Zuko: Right.
>>Nolan: Give me Vegas.
>>Zuko: Got that armor.
So you can see here,
I can pick things up.
We can put on the helmet.
I can dance around.
Typical battle
royal stuff, really.
[LAUGHTER]
[INTERPOSING VOICES]
>>Joseph: This is what I
was saying earlier where
this stuff will save
throughout their entire rest
of the episode.
>>Zuko: Yeah, so I can
show that actually.
So if I skip past
the explore phase,
this is how I tested it is now
in the next scene afterward,
you can see he's got his stuff.
And then this is actually
set up right now to refresh.
So now I just refreshed.
>>Joseph: This was the intro
to that explore phase,
so that's why he didn't
have a stuff yet.
And that one.
>>Zuko: And then I can
pick up more stuff
and I can test again.
He's got a grenade this time.
So that type of stuff
is really cool to us
to be able to transfer that
throughout the entire rest
of the episode.
I think--
>>Joseph: We've got a
fun question here.
How similar to your in real
life studio is the game studio?
We actually don't--
>>Zuko: Pretty much one-to-one.
>>Joseph: One-to-one?
Yes, our animator did
explode spontaneously.
That's how the show starts.
>>Zuko: Animators are
expensive because of that.
>>Joseph: We actually don't
have a physical location.
We've been a remote
studio since day one.
And while a bunch of us have
worked in studio environments,
so we're pulling from
our personal experiences.
Terrible Posture Games itself,
our studio meeting rooms
and offices are all
on a Discord server.
And so we are spending
a lot of time chatting.
But we're also-- we don't really
get the benefit of this office
culture in our
particular studio,
so that's a huge difference.
On the plus side
though, we can be
spread out all over the place
and it's totally not a barrier.
So like Nolan there is in
Nevada, Zuko's in Alabama,
and I'm in Boston.
Right there, we're hitting
three points of this country.
We've got people
all over the place.
>>Zuko: Yeah.
>>Joseph: So to get
us back on track.
>>Zuko: I can move on.
>>Joseph: Yeah, let's
progress onward.
>>Zuko: So showing off the
different manipulators
and stuff on the
rig, that's awesome.
We are really happy
with how that came out.
It works well for the animators
and we're moving forward
with that full speed.
But kind of a really awesome
side effect to the manipulator
tools was the ability to
use them on any Blueprint.
And this is kind of
where the balance
of Control Rig versus other ways
to do things comes into play.
Because not only can
we have it on a rig,
we can have it on the
actual scene origin.
And you saw earlier,
I was clicking
like these visual
manipulators to move things.
Because the scene origin
is kind of like foolproof
almost, where you
have the ability
to lock the transform so
that it only moves when
I'm using natural manipulator.
And that's some way for,
basically, the animation team
doesn't like accidentally
move things when
they're trying to do stuff.
And I have other
stupid things where
you can move the flag
to a different area
to stop from overlap.
And then on top of that,
it's that type of thing.
So I guess another example of
tools that can use manipulators
are the camera switchers too.
So in our game--
I can kind of show
it first so you
can see what I'm talking about.
We'll do a little dance and
then I'll go ahead and go over
to the supply closet.
And here, is kind of a what I
call this the camera switcher
system.
So you can switch to
a different camera
real quickly as if you're
entering a different room
and switches back.
So that's how that works.
But the main
functionality behind that
is set up with a camera switcher
actor and this camera switcher
controls different points where
we have the interactions, where
we have the actual
character spawning.
And one of the really
big things that we
have to do when we spawn
the characters in order
to get the views to
kind of like look
like the character is
in a certain direction,
is we have to make sure
when we spawn the view--
You can see right here,
this bottom part, this
is where Pylon is going to
spawn when he comes back.
And this is also a manipulator
plug-in manipulator.
That's terrible-- manipulator
plug-in manipulator.
Ugh.
It's rotated in a
certain way, so this
is his front facing direction.
So that way, when the
camera is looking at it,
he actually looks
like he's facing left.
And we have to kind
of set these up
in a very specific way
in order to make sure.
Because the views
are kind of-- you
have to get within like
a certain 45 degree
threshold in order for
the right view to show up.
But then the whole point of
this is that, not only is it
just on things like
fancy rigs and stuff,
it's also first
really simple tools.
I can set up a very
quick actor that is just
looking at transforms on it.
So right here, I just have four
transfers that I'm looking at
and these transforms
can be adjusted just
with the manipulators.
And I can see them visually
where they're going to be in.
So that is something that
is a nice little side effect
of the manipulator tools.
And we use them
all over the place
for so many different things.
Another really cool
one that we didn't
plan on showing but I remembered
last night and I want to show
is a rig of Sally in the fridge.
>>Joseph: Ooh, yeah,
our office tentacle.
>>Zuko: Yeah, I just
have to remember
where we're going here.
>>Nolan: That's in 9.
Yeah.
>>Joseph: I guess we should
also, from a high level,
just kind of say these
manipulators are essentially
ways to visualize things
very similar to how animation
already visualizes the stuff
when they're looking at rigs.
That route has come
about because it is very
easy for the animators to use.
We're like, let's
deploy that to a lot
of other aspects in the engine.
>>Zuko: Yeah, I touched on
that a little bit, I think.
I might have.
I don't remember.
So Sally is our wonderful
fridge tentacle.
In the episode,
Pylon has a moment
where he gets a drink from
Sally from the fridge.
So you can see in
the editor, Sally
is a spline based actor that
has animated all spline points.
So in Sequencer, you can't
animates spline points,
unfortunately.
That was one of the
things that I kind of
was hoping was built
in, so I didn't
have to do it, but thankfully
the manipulator components
kind of use this to--
I designate-- I have six
points, or wait hold on.
I can count-- one,
two, three, four.
>>Joseph: Yeah, six.
>>Zuko: Five, six.
Sweet.
That I can manipulate on
Sally and they're literally
using the same manipulator
tools to do that.
And all it is, is I
just click on the point
and I can change
the scale of that.
And you can see that
now I have like Sally
in a weirder position already.
And then along with all the
different other really nice
things from Sequencer,
since Sequencer's
able to change simple
things like floats,
we can change like how
crazy tentacly she is.
So that's just
another added bonus
with all these components.
So you can kind of see that
one simple component can be
used in so many different ways.
And I think at this
point we can move
to the set up of a character,
because I want to show off
the actual like joint
view system, which
is also using manipulators.
>>Nolan: Somebody
mentioned they wanted
to see your Anim BP stuff too.
I don't know--
>>Zuko: OK.
>>Nolan: --too much on
that at this point.
>>Zuko: Yeah, so
the nice thing is,
all of this manipulator stuff,
is I am almost done and ready.
I just need to
make documentation.
We are going to be releasing
the manipulator component
as an open source plug-in.
So that's something that
I'm pretty excited about.
>>Joseph: That,
particularly, we should
mention that that was because
that was something that you had
built kind of off on your own.
>>Zuko: Yes
>>Joseph: And brought
to Terrible Posture--
the idea of the
component system.
>>Zuko: It was one
of those things--
I've made so many tools
in Unreal at this point
and I just wanted more power.
And that was how the
manipulator tools were born.
And then Control Rig showed
up and I was, like, here,
here's some more power.
I was like, oh, are we
going to be friends or?
[LAUGHTER]
Maybe I don't have
to have power.
>>Victor: Make sure you send that
link to me as soon as it's like
so that I can update
the forum announcement
thread in the YouTube
description with a link
to the plugin.
>>Zuko: Awesome, thank you.
That'd be great.
Yeah, the only reason I
haven't-- it is technically--
I could send you the link right
now and people could get it,
it's just there's
no documentation.
So I don't know if people are--
I don't think it's worth
it if people are just
going to be flying blind in it.
But I should have--
I'm going to make a promise
of having the documentation
in by the end of the weekend.
>>Victor: All right, you
heard it here first, folks.
>>Zuko: That's my promise.
>>Joseph: Oh, boy.
>>Zuko: I'm finally
going to do it.
>>Nolan: Nice.
>>Zuko: As far as the animation
Blueprints behind this,
Sally is probably a good
example of how things go,
how the actual
connections of things go.
First off, since we are doing
everything in the editor,
almost anything that you're
seeing that is happening
live like this is
using Editor Tick.
We capitalize on that big time.
And you can you can
activate Editor Tick already
and I believe you can already
use it on Editor Utility Widget
actors.
But the way that we did
it was a little bit more--
it's like a slight code tweak.
And I have some links that I
can post to you as well, Victor,
for that.
There's a whole page that I
wrote up on how to do Editor
Tick in a way that doesn't--
Because if you do
it in a certain way,
you can kind of get ticking
to happen in weird sections.
Let me just get some water.
>>Joseph: Right, so
let's move on to the--
what was the next thing
we wanted to look at?
The views themselves?
Or you had said the--
>>Zuko: I was going to jump
into the Anim Blueprint stuff
because there was a question
about that, I believe.
>>Joseph: OK.
>>Zuko: But we don't have to.
So since we are using
the Editor Tick,
you can see everything's
running kind of--
everything's hot
right now with Sally.
So all of this information
is being stored on to Sally.
And then this is a bit
more complicated than--
>>Nolan: You should zoom in.
>>Zuko: I don't want to because
it's a bit more complicated
of a setup, because
a lot of this
is very custom with
how I'm sending data.
You can go ahead and set up like
your own animation Blueprints
to have your transforms
hook into it really easily.
But with the rig system, I
chose to go with a generic route
so that way I can
send and receive
data in a more generic sense.
So you can kind of see
I have like-- the rig
animation data comes
in and it's just a map.
And the map is full of generic
transform, vector, bool,
and int, I believe, is the
four different types you
can kind of pump through it.
I don't know if it's
a good way to do it.
So that's why I'm
not sure if it's
good to tell people
to do it this way.
>>Joseph: Well,
actually the backup--
>>Zuko: It works for us.
>>Joseph: What was that?
>>Nolan: I just
figured so you could
show an example so we could
see what you're talking about.
>>Joseph: So this
actually goes back
to the spirit of the
project with every time
we find ways to optimize like
this, we'll identify them
and then potentially in future
episodes we can hit them.
But we make sure it's
like cordon off episodes
that are earlier, where,
at certain points,
so that we don't
impact things that
have been released already.
So it's essentially
a living project.
But I was going to say, though,
that that question might
been geared more towards
Anim BP and not the--
>>Zuko: That's where I'm getting!
I'm getting there.
>>Joseph: All right, all right.
>>Zuko: We're going to make it.
I promise, we'll get Anim BP
in probably like two minutes.
So if you have the actual--
if you have your
manipulators and stuff
and you're sending
data or you have
like a transform on an
object, the Anim BPs
can just read
directly from that.
So for us, all of our
animation Blueprints
are reading all of his data.
We have the generic data system.
It's sending data through.
And then our
animation Blueprints
are pretty straightforward.
They just grab whatever
pieces they need to grab.
The really annoying
part, which I
can't help but complain about--
I'm trying to get
to the actual thing.
I should just go straight to it.
That's where I'm going.
Resources, here we go.
>>Nolan: The folder
sets your hierarchy now.
>>Joseph: Oh, yeah, that's
a lot of time went into--
>>Zuko: A lot of stuff going on.
>>Joseph: --us kind
of plotting out
how to get hierarchy that was
that was effective for scaling
per episodes.
And even them we're
still learning.
>>Zuko: There's three different
characters that we have.
We have the
characters like this,
that are made up of all
the different body parts.
Then we have characters that
are everything's together
and we have a simplified
version as well.
And all this was
just in an interest
of different optimization.
So the one that has all
the different pieces
is actually for
Animation Blueprints.
So we have the head,
which is probably
the most complex of it.
And really, the
Animation Blueprints,
we have a bit of a
code class that's
doing some sort of
like stuff for us
when it comes to like how
things attach and all that.
That is a whole
breadth of complexity.
But the main takeaway
from this is that we have,
when our animation
data is modified,
because that whole like
generic animation data
system, what we're doing
in the actual anim instance
is we're checking the
data when it comes in.
And we say, when it's modified,
we want to do something.
And this is important
for us because we
have a very stepped animation
system, or animation style.
Which means, we can
capitalize on the frames
that nothing is happening.
So when Viper is saying
"Shoot me," up close,
he's not actually moving
his head in that moment.
And we can say, let's not
actually calculate anything,
and it saves us a
lot of performance.
So when the animation data
is modified, we go through
and we grab the actual
head, and we split it off
and we say, OK, get the head FK.
And this is the
part that I hate so
much, is I have to
split it into three
different variables for
each of the different types
of transform data.
And the reason why is
because in Anim Blueprint,
for when you're actually using
Blueprints to do Animation
Blueprint, it's very important
to have this little light bulb
or lightning icon.
And this is--
>>Nolan: Fast path, right?
>>Zuko: Yep, in the
documentation it's
called the fast path animation.
And the idea is that it
doesn't use the Blueprints
from a high-level point of view.
The idea is it doesn't
use the slow blueprint
method to do things.
And this only works if you
use individual variables.
So that's really all the
Anim BPs are doing though,
is they're grabbing this
data and sending it off
to our actual AnimGraph.
So you can see the
head's very simple.
And I will-- this
is where I was going
to jump into the
join view stuff,
because all of
this stuff is using
like a basic setup of positions.
So if I go and
grab Kevin's head.
Here, we have Kevin's
head by itself.
And you can see that he has
like eyes and all that stuff
in certain positions, but he's
using a very generic version
of a head in our game.
So every character is using the
same head Animation Blueprint.
So what we do from
there is I have
a system called the joint
view transform system.
So we are able to set the joint
positions, default positions,
based on which view he's in.
So in here, if I go into
the joint views themselves,
you can see I'm also using the
manipulators for this where
I can change his positions
of his default eyes
for this one view.
So now he's got
eyes on his cheeks.
And then when I change it
to the front side view,
I can do the same thing.
I can move it and
then you can see kind
of like the power behind that.
So now I don't have to make
individual Anim Blueprints
for every single character.
So they're all using
the same like data
at the end of the day.
And now, if I've
checked that in,
it would be populated to
all of the episodes that
use Kevin's head.
>>Joseph: Yeah, let's not do that.
OK, so I think that
we're moving a little bit
slow through things right now.
We've got to kind of, I
think, pick up the pace
in terms of what we're showing.
What else is actually
on our list of things
that we wanted to show off?
>>Zuko: Are you sure
we're moving slow?
Because I think we're
pretty much almost
at the end of our list.
>>Joseph: Are we?
Are we going to talk about
spawnable stuff at all?
>>Zuko: Maybe?
>>Joseph: I guess
we don't need to.
Yeah, that's fine.
>>Nolan: Did you mention how the
rigs-- yeah, I think you did
mention how the
rigs are spawned.
>>Joseph: Well, let's
talk a little bit
I guess about just some of the
other goodies that we have.
Those are more visual and
more exciting, I think,
to kind of show off because
I think that people would
appreciate seeing a little bit
of the pose library, maybe,
integration helper tool.
So let's kind of
dive over to that.
>>Zuko: Still doing good on time.
>>Joseph: OK, go.
>>Nolan: Maybe an explorer with
like midges run or something.
>>Zuko: Right.
Yeah, thanks.
[INTERPOSING VOICES]
>>Joseph: Saw that we're
at about 90 minutes
since the stream started.
>>Zuko: Hold on.
I can do this.
There we go.
I did it.
I opened a level.
>>Joseph: Back here again.
>>Zuko: All right.
>>Nolan: This one.
Either one.
>>Zuko: We don't want
too many spoilers.
>>Joseph: Question
to ask, what is up
with the duck that says quack?
Absolutely nothing.
We're definitely not going
to hit that button on stream.
>>Zuko: I don't know
what it does right now,
but I'm totally going
to do that right now.
>>Joseph: I don't--
>>Zuko: Unless you were
being sarcastic, right?
>>Joseph: Well, it doesn't
say anything bad.
I think it is--
I think it is literally--
it used to say, quack.
And then people would
hit it impulsively.
And then I think I stealth
changed it out to say--
>>Nolan: It's loud
and for a long time.
>>Joseph: Yeah, it's long.
>>Zuko: This one's not that long.
Trust me, I just hit it.
>>Nolan: OK.
All right, either way.
>>Zuko: It's me and
Liam laughing--
>>Joseph: Oh, OK.
Occasionally, we change
it to a dumb sound effect
and that's literally all it is.
But it used to be I read out
the entire Wikipedia article
on what a mallard duck was.
Not the entire, but like
the first two paragraphs.
And so they'd hit that
button and it'd just
be playing noise
for three minutes,
so that's why I was like--
>>Zuko: Sorry.
>>Joseph: --don't hit it.
>>Zuko: That's My
fault. We can move on.
>>Nolan: The button
actually exists
because that was a training
exercise for me when
I started at Terrible Posture.
I had never worked
on Unreal before.
So it was just to like
familiarize myself
there and actually go
in and edit the engine
and do some stuff.
>>Joseph: Right, that's right.
I was like, hey, we need
you to be ramping up
on tools as fast as possible.
Here's something
that gives us a goal.
Here something that
gives us a thing that
will be forever a
thing we used to prank
each other in the engine.
But the major goal of
it was at first just
to kind of get you adjusted
to messing with the engine
and getting tools for us.
>>Zuko: Yes.
>>Nolan: Zuko, I can't--
Oh, there you go.
Your stream's working.
I think your stream's
down in the--
>>Victor: Yeah, it's
down for me here.
Do you want to restart
it again, Chris.
Yes, Zuko.
I apologize.
>>Zuko: Nice.
There you go.
Boom.
All right, we're here.
We got-- let's see if Ben is
a good candidate for this.
>>Nolan: Sure.
>>Zuko: All right, let
me get the characters.
Cool.
We got Ben.
I want to hide the--
HH, boom.
>>Joseph: Hide the tree?
>>Zuko: Yes.
Cool.
So is this where you wanted to
talk about this stuff, Nolan?
>>Nolan: Sure.
Oh, yeah, so this is the
animation helper tool.
Basically, just something
to assist our animators
If that name wasn't
obvious enough.
The main things that
this helps with the reuse
of existing animations.
So it functions as pose library.
So as you can see,
Zuko is just clicking
through different folders.
And these are just referencing
other sequences that exist.
It's really easy
for the animators
to go in and add new poses,
duplicate some other ones
and then tweak them.
That way you, if
they make a walk
cycle or a few
different variations,
they obviously don't want to
keep doing the same exact walk
cycle over and over again.
And then over time as they
add to the post library,
it's just a more
robust library for them
to pull from for inspiration for
different animations and stuff.
And one thing this
actually does is--
something we needed to solve
was multi-track copy and paste
in Sequencer, which isn't
actually supported right now.
Like, Zuko, if you
pause and just like
go to highlight multiple
tracks and multiple sequences.
Now like drag from
all the keys, sorry.
>>Zuko: If you try to do this.
>>Nolan: And then right click.
You can't.
You can't copy and paste.
It's just not something
that's supported right now.
So something that's
supported in here,
is a custom copy
paste that allows
our animators go in and
copy paste custom sections
and then go through and
tweak things differently.
And using that,
that's kind of built
into how these are inserted.
So Zuko, if you
can go to his walk
and just extend his
walk with a different--
some other animation.
Maybe a different type
of walk or something
like that so we can
see the blend tool too.
Cool, so that's good.
So then, basically,
you see he just
inserted it and he can continue
to insert more animations.
And you can actually
take these animations
and insert them onto
different characters.
You can take Ben's
walk and insert it
on a midge assuming they have--
basically, it just correlates
any of the overlapping body
parts.
Not everything might be carried
over, but anything that they
have the same body parts of.
>>Joseph: And the reason
you all are doing this
as keys rather than like
a place in sub-sequence
with the track is that
then it is something
that is allowed to be custom
adjusted to the scene,
because every one
of these scenes
needs to be fine
tuned into place.
>>Nolan: Yeah, exactly right.
We're really heavily
animation based
and we don't want the
same animation piece
over and over and over again.
So the animators need a lot
of control of like, OK, I
want to reference
this animation,
but I want to change
it a little bit.
I want to tweak it and make it
feel specific to this. scene.
Did you add some blend keys in
there, Zuko, did you show that.
>>Zuko: Yeah.
>>Nolan: Yes, if you saw
that there, there's
a little blend tool
at the bottom of this
you can drag 0% to 100% of
the previous set of keys,
next set of keys.
Based on everything
before and after that,
that timeline of what
you have selected,
it goes and automatically blends
between the animations, which
is, I think, pretty nice.
>>Zuko: Yeah, no, it's awesome.
>>Nolan: Pretty sure the
animators use that quite a bit.
>>Zuko: I believe it's
based on the tool that's
free called Tweener or Tweak?
It's like a tween?
The Tween tool for Maya.
>>Joseph: That's the
inspiration for it?
>>Zuko: Mm-hmm.
>>Joseph: Gotcha.
So I think we've done a
pretty good job of kind
of showing all the different
components that go in.
There's quite a bit as you can
see if it goes into animation.
There's quite a bit that
go into these cutscenes.
We could really
quickly also mention up
some of the game stuff.
Because even though this stuff
is heavily used in cutscenes
and heavily used in the
explore phases for the games,
everything is way more custom.
And we're not going to really
dive too much into that,
but we should probably talk
about the game system at least
a little bit for five
minutes real quick.
>>Nolan: Oh, yeah.
The idea for this was to be able
to make mini games in any genre
that we could think of.
Basically, put
complete control--
>>Joseph: Zuko, could you
load up the Jeb Fight?
>>Zuko: Yeah, I'm getting there.
>>Nolan: Thanks, that's right.
Oh, you've been--
>>Zuko: I was like I
was blending Ben, Joe.
>>Nolan: Into air sitting, nice.
Perfect.
>>Zuko: I'm in my own little
world as an animator.
>>Nolan: Yeah, so here's a mini
game that we have, Jeb Fight.
Where are we at?
>>Joseph: Yeah, let's actually
play it and show them
what it is.
This is inspired by
a classic NES game.
You're not trying sharing with
sound right now, but that's OK.
>>Nolan: Yeah, think
we get the gist.
>>Zuko: So the idea is
I walk back and forth
and I can throw Pylon--
>>Joseph: Also, spoilers
for you, Victor.
Sorry.
>>Victor: I figured as much.
That was going to happen.
It's my bad for not playing
all the episodes yet.
>>Nolan: Yeah, so what we
discovered early on is
we needed all of the
games to basically
be based on a base
class, so we can share
some common functionality.
All the games needed to be
able to reset in the same way,
needed to be able to be skipped,
and played over and over again.
And so we have a base
class that basically
provides that functionality.
Common stuff just so that you
would need to set up per game.
Obviously, then, don't
need to set it up
for each of the different games.
So they start off
and the idea is
that you start off with
this blank slate of, OK,
we're ready to go.
We've got our intro
and everything.
And hopefully, the majority
of what you have to do
is just the pure game dev.
You don't have to set up the
same intro and exactly how do I
reset binding to the correct
events and all that stuff
again.
So that's handled
by our embedded game
template, the base for it.
Again, it's kind
of like a sandbox
for ultimate control for the
designer who's making games.
We didn't really-- you
don't want to restrict them.
We didn't want to make it so
you can't go to specific genres
or anything like that.
You just do whatever you can to
create a game however you want.
And this is definitely,
of anything,
the most traditional sense
of making a game that we've
showed so It's Is
just go through,
and if you got your idea
you go through and set it up
however it needs to be done.
We've got a few
different reusable
components, different timers,
and health bars and stuff
like that.
It's really just
whatever the designers
make they can
choose how they want
to use it between the different
games, everything like that.
>>Joseph: You just
gave them a framework
with which to build
around so that it
can exist within the
ecosystem of the episode.
>>Nolan: Yeah, exactly.
I mean, this is treated
like another scene.
All the games are.
You go into it and it started
and stopped the same way.
It's picked up by our
scene selection menu.
The explore phases are
actually like internally
considered mini games too.
Yeah, it's just a helpful, nice
base framework to start from,
but not limiting in
how the games are made.
You can really do
whatever you want,
ranging from first-person
shooter style stuff
to top down RPG-esque thing.
Really, whatever,
anything you think of.
>>Joseph: Yeah, which, I mean,
if people play the episodes,
they should see they're
a little all over the place.
There are puzzle games,
there are side-scrollers,
there's brawlers, there's
first-person shooters.
We try and shake it up
with every single episode
and this framework is
what keeps it stable.
>>Nolan: And consistent.
>>Joseph: And consistent.
As quick as possible
to actually build.
>>Nolan: I think that's it.
There's not a ton of
detail and specific tools
that we've written for that yet.
Typically don't want to
neglect our designers
and if they request
it, we'll definitely
get more stuff to them.
Right now, that's pretty
much the gist of it.
>>Joseph: Yeah, cool, I think
that's kind of a good overview
of what it takes.
Like we had that
brain in the script.
And then we had the
automated generation.
And then we showed
you quite a bit
about what went
into the animation
and what went into
the rig itself
and what went into a
lot of different tools
we use to assist us in making
these episodes quickly.
The end of this, you end up
with a 30 minute experience
that the player can--
one, that we can build
quickly and then,
two, that the players can
enjoy every single week.
So I guess now we could
probably take some questions.
Does that all sound
OK to you, Victor?
>>Victor: That sounds great to me.
The first one that
comes to mind was
someone asked, where did the
initial idea for 3 Out of 10
come from.
That's a good question.
And there's at least two
meetings that I'd had early on.
One with my wife.
Well, not really a meeting.
We just went out
to lunch somewhere
and we were talking
about what it'd
be like to have a silly game
based off of a terrible game
studio.
And then talking with Zuko.
When Zuko and I sat down
after Mother Gunship--
after we finished development
on Mother Gunship, we were like,
what do we want to build next?
We had a lot of different
ideas and we couldn't--
eventually, we're settling
on this idea of, like, what
about something that kind
of uses all of these ideas.
And people ask us what
genre 3 Out of 10 is.
I kind of tell them, yes.
That's my answer because
it's kind of every genre.
Zuko, did you actually
want to chime in on that?
Because my is a
little bit fuzzy.
We're talking about--
>>Zuko: Yeah.
>>Joseph: --a few years ago.
>>Zuko: I think the biggest
thing that comes to mind
is we've gotten asked
this question many times
and really a lot of the
inspiration for this game
came from the fact that
Mother Gunship was almost
like a test ground for it.
Like Mother Gunship has many
of the same voice actors,
has many of the same
quirkiness in its weird story.
So from there we realized
that people really
resonated with that and
that was kind of like, OK,
can we do this?
Can we actually just
make a game that people
will enjoy and laugh
and at the same time
we can kind of have fun
with the industry too?
>>Joseph: That's right.
Yeah, like with Mother
Gunship we were playing around
with a story quite a bit.
I wrote that story at like 3:00
in the morning at GDC 2018.
It was exhausting and as a
result it got very silly.
And then I didn't think
people would respond to it,
but then people seemed to
really respond to that humor
and to that silliness and to
the absurdity pretty well.
So yeah, Zuko and
I were like, let's
explore that a little bit more.
Maybe instead of a
first-person shooter
we could work on something
that is comedy and really leans
hard into comedy and we can
kind of see what people think.
Really leaning
into the absurdity.
So yeah I think it's probably
the best question for that--
best answer for that.
>>Victor: Yeah, I was wondering
as well, because I've
heard game mentioned
and then like sitcom
or interactive sitcom.
It's a little bit different
difficult to pin what it is.
And I think that's--
>>Joseph: It is.
We really were
excited about making
something that felt different.
And the idea of
something that was short,
came out regular, came out in
a way that surprised people--
we really want to do something
that people were like,
wait, what is this?
I've never played
something quite like this.
And that felt important
to us to do something
that felt fresh and different.
Something that people
hadn't really seen before.
Don't mind, Zuko he's
just destroying Kevin.
>>Zuko: I typed in Jeb
and I totally forgot
there's the naked Jeb scene.
>>Joseph: Oh, yeah,
let's not open up that.
That has, I think, a little
pixelization censorship bar,
so it'll be fine.
>>Zuko: It does, yeah.
>>Joseph: It's still
disturbing to look at naked.
>>Zuko: It's still disturbing to
look at naked Jeb regardless.
>>Victor: There was
the question-- they
were wondering if you made
a prototype for Surfing
With Sharks?
>>Joseph: Ooh, do you mean like
a pen and paper prototype?
>>Nolan: I think you mean
like a prototype within--
>>Victor: It specifically
was, did they
make a prototype for
Surfing With Sharks?
>>Joseph: The game within
a game is interesting.
This is the world's
worst game studio
and they are making a game and
that game is called Surfing
With Sharks.
And we have made a lot
of different versions
of that game.
In particular, a
developer named Liam,
who's somewhere in the
chat, was working on that.
And that has been,
not his only thing,
but that has been his baby
all throughout this project
and making sure that
at every episode
we treated it
differently and absurd.
And we didn't make
a prototype that
contained all of the
features of Surfing
With Sharks because we
wanted to kind of have
it go in different directions
with every single episode.
And so every episode they
add something a little bit
different and it's
usually not a good idea.
Usually it's
something very silly
or something that has
no real right being
in a game like
Surfing With Sharks.
So I guess the answer
is like, yes and now.
Like the base mechanics
we did, but then we're
adding to it constantly
with every episode.
>>Victor: It's fit like a warrior
style mini game inside--
or mini games inside of
a interactive sitcom.
It's pretty amazing.
>>Joseph: Yeah, that's that.
There's also a little
retro console that you
can play if you find it.
It's hidden somewhere different.
We'd like to do
this thing where we
know people are going
to be revisiting
the same location every episode
when they go to the office.
Usually, they visit
the office and they
visit one other location during
an episode-- at least one.
And we try to make
sure that we hide
different things in the office.
A different story to read.
Different recipes to find.
Something different on the
back of the cereal box.
There's lots of just stuff
to find and explore and learn
about the world and that
changes every episode.
So it's almost like
revisiting a friend every week
and kind of seeing
what's different
with them, doing a
little catch up on what's
going on with the studio.
And so the shark game and the
progress with the shark game
is one of those things.
>>Victor: Someone
was curious earlier
and I think Liam
answered it in chat,
but I wanted to do
it out on the stream
so that everyone watching on
YouTube can hear it as well.
They were curious how you
did the animated TV, I think,
in the office scene.
Oh, I think that was a Flipbook.
>>Nolan: It's just that UMG.
So you know when Kevin
intros the battle royal.
>>Zuko: Oh, that one.
>>Nolan: Zuko.
>>Zuko: Yeah.
>>Nolan: So it's just that UMG.
And then I think they
were curious just
how that was attached
to the TV or something.
>>Zuko: It's literally just--
>>Nolan: Just straight on
attached to it, right?
It's a 3D--
>>Joseph: Yeah, it's 3D widget.
3D widgets are pretty awesome.
They're pretty versatile.
You can capture
input with them too.
But I don't know if it's been
not marked as experimental.
>>Nolan: Oh, the input proportion?
>>Joseph: I can't remember.
It was for a long time.
I think it's not
experimental anymore,
but for a long time was flagged
as an experimental thing.
But it is a component
within Blueprint
that you can add and
then point it to a UMG.
>>Zuko: So yeah, right here.
I'm showing that the briefing
panel is that component.
And then underneath there
just points to the UI class.
And then in here is where
all the different animations
are put in like the
exterior panning shot.
And then, I believe, all
the different like fun
animated parts of that are
individual UMGs themselves
that animate all the
little blue bits.
>>Joseph: That
actually-- not having
that be video keeps the
footprint of the episode
down quite a bit.
What were we saying
earlier, Zuko?
We were like, if we were to
make a 4K version of the trailer
or if we were to like--
>>Nolan: It's bigger.
>>Joseph: Yeah, that is bigger
than the episode itself.
The entire episode
would be smaller than--
>>Zuko: Like a 4K high
compressed video trailer.
>>Joseph: Just because
we've kind of
made an effort to kind of
keep these things fairly
lightweight.
>>Victor: It was
quick to download,
but I also have fiber,
so I don't know.
>>Joseph: Any other questions?
>>Victor: Yeah, so Sally seems
like a really cool mechanic.
How did you handle the
sprites for that effect?
>>Zuko: For Sally?
>>Victor: Yes.
>>Zuko: Ah.
Let's go back to that scene.
>>Victor: We had to build Sally
like two times because--
>>Zuko: We did.
>>Joseph: Because
I drew her wrong.
>>Zuko: Because I got--
>>Joseph: She was originally--
>>Zuko: --so much
>>Joseph: --going to be a card--
>>Zuko: --flak from it.
>>Joseph: --that went [CLICK].
[INTERPOSING VOICES]
>>Zuko: From the first rig.
>>Victor: Well, OK to be fair
though, the first rig was done
on top of a drawing
that was supposed
to be just a slide in and
out and not really animated.
>>Zuko: Yeah.
>>Joseph: And then it was like
let's animate this thing.
So you had to like straighten
out this curved tentacle,
make it flat, and then
counter animate it
back into a curve again.
That was weird.
>>Zuko: But now, all Sally is
a bunch of spline meshes.
So I have, I believe, the
main broken up into segments.
And this was kind of like
flying at the skin of my teeth.
I'm trying to do things
really, really fast
and I don't have time
to like try and iterate
over and over at this point.
So the easiest thing
for me at that moment
was to split Sally into, I
believe, 11 different meshes.
So you can see
here's like a segment
and then these are all
individual spline meshes that
are told to follow
spines in the Blueprint.
So if you look up any
type of spline tutorials,
you can get the gist of
how to create splines.
But it's literally
just the actual spline
meshes are created in the
construction script, I believe.
So here's the clear.
And then I store them as a
variable for spline meshes
and then I update
them on the fly.
So you can see if I don't
have spline meshes right here,
I say if it's not valid,
I add the meshes in
and store them
into the variable.
Then from there, I just
do a for loop over them
and change how they're tangents
and their start positions work.
>>Joseph: She does not
have multiple views.
It is just one view.
>>Zuko: Correct, Sally
is not multiple views.
A
>>Joseph: Very custom
kind of purpose.
>>Victor: Somebody made a
really good Sally in the chat.
>>Zuko: Oh, yeah, wow.
>>Nolan: I'm impressed.
>>Joseph: That is very cool.
Were there other questions too?
>>Victor: I got two more.
So in this scene, I
think it was with Ben,
someone was curious if the
purple pig on the floor
is a custom place holder for
the character that you made
or something that
comes from engine.
>>Joseph: I think that
was the scene origin.
>>Zuko: Pig on the floor.
>>Joseph: That was Ben
in explore phase two?
>>Nolan: Like the
actual set itself?
>>Victor: Yeah, I think so.
They were just curious
where the assets came from.
>>Joseph: I think that was at the
scene origin, but we'll see it.
It was--
>>Zuko: This thing?
>>Victor: Mm-hmm.
>>Zuko: It's just two
primitives from the engine.
It's just cylinders.
>>Victor: Nice.
>>Joseph: What was that for?
Is that the designation of
where the character will spawn?
>>Nolan: Yeah.
>>Zuko: Yeah.
This is the origin--
the relative location.
>>Victor: Are those editor only?
>>Zuko: Yes.
So when I hit G, you can
see that they're hidden.
And they're also editor
only components, so that way
they should go away
in the game as well.
>>Victor: Right, they don't get
compiled out when you package.
>>Joseph: Hmm.
>>Nolan: Hmm.
>>Zuko: Even if they were
compiled they probably
wouldn't be too bad though.
>>Joseph: In terms
of adding and cost.
>>Victor: Two more
rendered meshes.
>>Zuko: If they're hidden,
yeah, it's not a big deal.
>>Victor: It's nice to
always set it up like that
and know that, like, oh, wait,
this is actually not supposed
to be in the game.
Just go ahead and mark it
as editor only and then
that it won't be there--
>>Zuko: It's a good practice.
>>Victor: Yeah.
Say if you happen to leave
collision on one of them.
There's all kinds of
stuff that can happen.
So last question
was, did you guys
make any pull requests
to engine code
from some of the
improvements that you made?
>>Nolan: No.
>>Joseph: Yeah, no?
>>Zuko: Nolan?
>>Nolan: We did kind of
a roundabout solution.
So I probably should with
some, because we do we do
have quite a few
engine overrides.
I think a lot of them are
pretty specific to our game
though, so I don't know--
necessarily apply.
But some of stuff for the
like the Sequencer scripting,
we had to do a lot of engine
overrides for the version
that we were on in
order to expose,
being able to add
different things,
or fix a few
different bugs, stuff
like that to make it so we
could do all the generation
I showed you before.
And I actually like got
like a whole list of kind
of all the different
changes and everything
and I got that together
and I sent that
over to one of my
contacts over at Epic.
And I believe that as of--
I think he said 4.25, Joe?
I feel like a lot of
that was implemented.
So I--
>>Joseph: Yeah, because
there's a lot.
Because we were also behind
a little bit in terms of what
was going on.
So you know we don't want
to conflict with stuff
that's in the current build.
But we at least
offered it where we
felt like it was something
that was more universal.
We were like, this is something
that could be beneficial.
>>Nolan: Yeah, so quite
a pull requests,
but they got some of the
things that we had found.
And I know they have
implemented some stuff,
so it's gotten better.
>>Joseph: Yeah, you've also made
some various posts about things
on the forums as well.
>>Nolan: Yeah.
>>Joseph: I believe, too,
when we've found things
or when we've had questions
about how things were coming
along or proper ways to go.
>>Nolan: Bugs and stuff like that.
>>Joseph: But yeah,
we've done we've
done an awful lot with
Sequencer and we're always
excited to see
what new toys come
in whenever we do an upgrade.
But certainly, because of
the custom stuff we do,
it's always a very serious
consideration whether or not
we are ready to upgrade.
>>Victor: Being just one
engine version behind
is still a really good
feat for something that's
so far in production like this.
>>Joseph: Yeah, I mean, thanks.
That's on Nolan and Zuko.
>>Nolan: Yeah, well,
luckily we don't
have too many engine overrides.
Or the stuff we do have is
pretty separated so that it's
just kind of like adding.
So we do the engine upgrade and
then just throw in our stuff
again.
And it's, I think at this
point, for us to do an upgrade.
Our last upgrade was
maybe a couple days total
through testing and
everything in that.
>>Zuko: Yeah, but now--
>>Joseph: I think it's a
little more than that, but--
>>Zuko: We're going to have
basically like a two week
period of highlighting
the tech settle.
Because there's
always something.
There is--
>>Nolan: Well, this time--
>>Zuko: --always--
>>Nolan: Definitely,
if we do another one.
At this point, now that we've
released everything too, yeah,
we'll be really careful.
This was all prerelease and
I was enthusiastic with, hey,
we'll be OK, we'll be OK.
Let's just upgrade.
>>Zuko: But code wise,
yeah, you're about right.
It is that quick.
[INTERPOSING VOICES]
>>Nolan: There is.
So kind of on the
same topic, I did
see another question come in.
They said for
secrets generation,
are you using Python
for automation
or Editor Utility Blueprints?
Yeah, we specifically
are using Python.
But the way that Python
works with their plugin
is, everything that
Python has access to
is all Blueprintable stuff.
So anything that
you do in Python
you could do in
Blueprint if you want to,
if you don't want
to learn Python.
I will say Python is a really
easy language to learn.
It's probably one of the--
I think one of the
better first languages.
It's a good area to start with.
But you could make an
Editor Utility Blueprint
for generating the sequences.
That would definitely
be possible.
We just don't.
>>Joseph: I think, Victor,
we're coming up close
on your timeline here, right?
>>Victor: Yes, we are.
One more question
came in that I thought
was pretty good-- a little
bit related to VR style.
They were curious if you
were applying border shaders
to your assets or if
everything is artistically
designed that way.
>>Zuko: I can take this one.
>>Joseph: Go for it,
yes, please take it.
>>Zuko: We do this
a pseudo approach.
So we do have an
actual outline shader,
but we can't rely
on it too, too much.
There's plenty of
outline shaders out there
that are really good.
Ours is pretty quick.
We found like one or two
tutorials and went with it.
But the main thing
is this is what
the game looks like
without the outline shader.
So you can see the
shader itself is
doing a nice finishing
touch, but there are still
actual line work--
there's a lot of line work
still happening on 2D assets.
And then the 3D assets
themselves still
have a line work too.
What's interesting
about the 3D asset
approach is that we are using--
we aren't using textures
for a lot of the bigger
stuff for the line work.
We're doing it all
with Vertex Color.
So if I were to actually
go in and mesh paint this--
I believe it's the blue
channel that we do stuff with--
you can see I can actually
paint like the line work
to be on my asset.
So we actually
model everything--
and take kind of like
the triangle cost.
>>Nolan: Your mic
cut out for a sec.
>>Victor: Yeah, you gave
me another heart attack.
I thought my interface
crashed again.
>>Joseph: Yeah, your
mic just cut out.
You said you take
everything and we do.
And then that's--
>>Zuko: Yeah, so when we're
modeling the asset, the larger
ones, because we've realized
that these smaller ones,
like the keyboards, we probably
should do with texture,
just because the line work
shader doesn't mip very well.
So you do run into an
issue where you kind of get
a little bit of aliasing.
But the bigger stuff we model
in actual extra geometry.
So you can see here
we have extra stuff
around the corners
of things, even
if it is like a flat corner.
>>Joseph: And that's one of
the few scripts you actually
do outside of Unreal,
because we do--
these are all modeled
in a traditional thing.
>>Zuko: We have one
main Maya script
and we made it right
in the beginning
and we've been
using it since just
to apply vertex colors in a
specific way for our process.
And I think if I
went to RGB channels,
you can kind of see
what it looks like here.
So it's just using that
to apply the actual line
work on bigger 3D stuff.
And that saves us
a ton of extra time
when it comes to making
very customized stuff
and not having to do
textures for everything.
Once again, iteration time.
Every.
>>Joseph: Iteration time, yes.
Because textures
are-- they take time.
But use them where you need to,
because with a game like this,
the art style is built
around the fast iteration.
>>Zuko: Yes, Jill, our technical
artist, wrote that script.
>>Joseph: Any other
questions, Victor?
I know we're kind of--
>>Victor: I think that's it.
>>Joseph: --at the end here.
>>Victor: We're running
up on the end here.
Yeah, I need to do my
little outro spiel.
But this has been
super exciting.
I'm very happy that you were
able to come on the stream
and show off this.
It's definitely something
extremely original
that I've never seen
or experienced before.
So big props to all of
you and then the rest
of the team, which I
think a lot of them
seems to be there in chat.
So I think, chat,
give a little shout-out
to everyone at Terrible
Posture Games who
helping out on chat today,
answering all the questions.
If this was one of the first
times you were watching
the stream today, we stream
every week on Thursday
at 2:00 PM eastern time.
I'm saying every week--
almost every Thursday.
There are a couple
of weeks of the year
that I think we all need to be
off, but almost every Thursday.
If you want to know
what's coming up
in the future, the best and the
first place to figure that out
is on the Unreal Engine
Forums in the Events thread.
That's where we post all of
the announcements of who's
coming on the stream.
You can also see the schedule
on our Twitch about page.
Sometimes a little
bit later updated,
but it will still be there.
There were some people
mentioning in chat
earlier in the stream
regarding transcripts.
And I do want to mention
that all of our livestreams
are transcribed manually and we
put up the captions on YouTube.
What's also cool, that
actual transcript file,
we upload that to
Box and you can
download that in case
there was something--
say you were watching maybe
on your second monitor
and you heard
something and you want
to go back and watch it later
on when the volume comes up.
You can actually download
that transcript file,
search for keywords,
which is control F,
and then find the timestamp
in it where we discussed that.
So as of right now,
there can be captions
there saying these exact words.
And if you search for, I don't
know, custom game controller,
you'll be able to find
the timestamp for that.
I just took the first
thing that is on my desk.
>>Joseph: That sounds like an
awful lot of work for somebody
to set up, but that's very cool.
>>Victor: It is semi automated.
However, when it comes to
the discussions that we have,
there are a lot of
technical terminology
that sometimes the automated
software doesn't even
know that that word exists.
Sometimes game dev
slang as well that
can be spelled in
an interesting way.
And it's important sometimes
to know what the word actually
is, because if you're learning
and you're just sort of trying
to put your headspace
in this realm of game
development or interactive
playable sitcom development,
there are a lot of words that
you're just not familiar with
and it's really important
to be able to sort of get
that terminology first.
And then now you might know
what to Google for, right?
And so big shout out
to Courtney who's
doing all of our transcriptions.
And this goes-- I take it back
date's almost over two years
now, we have transcriptions
for all the streams.
And also, if it's
difficult to hear
the stream for whatever
reasons, the transcriptions
can help you there.
We're still looking
for count of videos.
And so if you take 30
minutes of development,
record that, fast forward
that to five minutes,
and send it to us with
a non-composited logo.
So your logo but not
composited into the video.
You might end up becoming
one of our countdown videos
and we add a little bit
of nice music to that.
Other than that, make
sure you check out
our communities.unrealengine.com
Meetups page.
There are no in-person
Meetups right now,
as you probably understand, but
there are still virtual Meetups
happening among these groups.
And so go check
out and see if you
can find a group close to you.
If you cannot and you're
interested in what entails
to becoming a
Meetup group leader,
there's a button that
says "become a leader,"
just go ahead and fill that form
out and we will probably get
in touch with you.
Moving on, make sure to
follow us on social media.
Forums are a great
place to let us know
the products you're working on.
That's also what goes into
the product spotlight--
the community spotlight, sorry,
at the beginning of the stream.
And I think with that said,
special thanks once again,
to the team from
Terrible Posture,
everyone who saw the stream.
>>Zuko: Woo.
>>Joseph: Thank you for having us.
>>Zuko: Thanks for having us.
Jinx.
>>Victor: Any time.
Hopefully you'll
be able to continue
producing a whole eight
seasons of 3 Out of 10,
but I am excited to see what
kind of interesting things
you all come up with
in the future as well.
>>Joseph: We've got wacky plans.
>>Victor: I bet.
I can also tell that
there's definitely
no shortage of crazy
ideas at Terrible Posture.
That's awesome.
>>Joseph: Yeah, thank you very
much for having us though.
This has been fun.
>>Victor: You're so welcome.
Stick on the call
just for a little bit.
But for all of you out
there, I hope you stay safe
and we will see
you again next week
when I have Richard Cowgill
from Nvidia coming on,
talking about new technology.
So until then, bye-bye everyone.
