All language subtitles for Nuke Compositing for 3D Artists week 2 - Classroom - CG Master Academy_7

to begin with

what we're gonna do is have a look at our renders

so here is our city render

and if we look at our lender

um rota channel

the XR and look at our AOVs here

you could see that we have a velocity pass

um for the city

and if we look at our Zillow element

we have velocity pass rendered here as well

and generally uh

what these passes

um these channels represents is the red channel

is the motion in X

and the green channel is the motion in Y

and similarly again

if you look at our city

velocity pass um

red is our motion in in X

and green is our motion in y

so that's great that we have these passes

and if you go back to RGBA

um what we wanna do is we wanna

apply this vector blur node using the velocity um

where these merge together um

we could definitely put them individually

but for for sake of speed

what we could do is just apply it

where these characters have merged together

so upstream here we've got

our city with our Dinosaur held out

our Zilla element held out

and we also have

our zilla with the city and debris pieces held out

and we are merging them over here

and whether you've done a disjoint over or plus

this is where we wanna

apply our vector blur

so we could just hit

hit the motion blur at once

um on these elements

so if we grab ourselves a vector blur node

um and plug this in over here to our stream

to begin with

what we wanna do is isolate the

motion blur

adjust to our rgba

uh by default

this is set to all

which is totally fine

but what that's gonna do is apply

vector blur to every one of these AOVs

which um we could definitely do

but for the sake of time and efficiency

if we're not gonna be needing those

elements motion blur downstream

then we could just forget

applying vector blur to those and just isolate it to

RGBA here and

the next thing you wanna set is for the UV channels

you wanna select your velocity pass

as you remember

with the Motion Blur 2D and 3D

we were using

Motion passes

so in this case

we're just gonna use velocity

you could see we're getting

uh motion blur applied

but something looks a little bit strange about this

and what what's happening

um we're getting motion blur on our background

but the Zilla element isn't

getting motion blur where you would think

you would be seeing it um

for example

in this case

he is in the process of moving his head

so you'd expect to see some motion blur on his head

and the reason why we're not getting that is um

we have to take a couple steps to make sure

we're passing our velocity pass properly

so if we view are disjoined over

and we look at our AOVs here and we look at uh velocity

and if I bring gamma down and our exposure

you could see that

right now all we're doing

is we're just getting the velocity for our building

but for some

reason we don't have Zilla's velocity coming through

and the reason why that's not coming through is in our

disjoint over or plus that you've done

in this merge operation um

we're not carrying over

we're not merging our velocity together

so if we select

velocity in the also merge section

and we view this merger note now

now you could see that we've got

the Zilla velocity coming through

and merging with our city velocity

so again to look at this again

if we set this to none

we were bypassing and not passing through

the velocity for our Zilla character

so this is why we wanna set this to velocity as well

so that that comes downstream

the other thing you could do is um

you could select

you could simply just select all here

so that you can have all those AAVs come through but um

if you don't need those downstream

you could just simply select velocity

and make sure that that comes through

so now that we've got Zilla's

Motion Blur

Velocity pass coming through and the building

we could look at our um

our Vector Blur node

you looking at our RGBA

so now if we view the Vector Blur node

there we go

now you can see we're getting motion blur on his head

um which is what we want

the other thing you could see is there's a little

bit of an artifacting happening here and um

it's something a little bit strange here

so one thing we wanna do is in this

premult and unpremult that we did for these elements

what we wanna do is set

the unpremult to all

so that all of our channels get unpremultified as well

and then similarly here with our pre mold

we wanna pre multiply all those a

0 V's again

and we'll do the same thing for our Zelo element

so we'll un pre mold

instead of just

RGB will un

pre mold all

and we will pre mold all

down here too

so this way we're on premulting our velocity pass

and pre multiplying all cleanly together

and now if we look at our vector blur

we should have a little bit better result here

now we've got this strange situation here

with this sort of cut out quality on our Zilla here

and where that's coming from

there's a couple areas where we need to troubleshoot

and sort out where that's coming from

normally what happens is this

on the vector blur node

this normalized checkbox is on

and what this normalizes doing is it's trying to

normalize the tearing effect that would happen with

elements overlapping one another

so this is nukes

vector blurs approach and trying to minimize that

so if I uncheck this normalize

and we look at our RGB channels

you could see that took care of that

again if I check it on

we have this odd behavior happening

and if I uncheck it

that is giving us some more smoother

motion blur as we'd expect

which is good

um again unchecked and checked

we are getting

we're getting a better motion blur with it

unchecked here

now one problem

if you're looking at the RGB channels

this is great

but if you look at our alpha channel

you could see we've got this

cut out situation happening

and that's something that this

normalized feature likes to resolve

but in our case

it was giving us a little bit of an odd behavior

so there's a couple things we could do

we can uncheck this for now

and we'll make sure to check on this soft lines

so what this does

is it'll try to

blur out any of the um

the lines on the inside

so if we uncheck this

we've got this odd behavior

and if we check soft lines

it softens up these lines inside

which is good

but we still have our issue here with these um overlap

overlapped areas

so one way to fix that is

to apply a clamp node to our

upstream here

before vector blur

and we could clamp our velocity passes

just to negate any odd values inside our

velocity passes

so again I'm just gonna look at our alpha channel here

and what I'm gonna do is grab a clamp node

and I'll plug this in our stream here

and if I instead of

clamping all channels if I select velocity

and plug this in our stream

that took care of these holes

that we were seeing from our city render

and now if we apply the same clamp to our Zilla render

that took care of that as well

which is good

so now we're getting a cleaner motion blur

now the thing that we need to do is

with our velocity

we don't necessarily wanna clamp it at 0 and 1

because this is cutting any motion that we might have

like any severe motion

and um in this case what we wanna do is maybe set

the maximum instead of 1 to maybe a value of six

and we'll do the same thing for our Zilla

clamp node will just set that to six as well

and you could see we're getting

more motion blur as that you'd expect um

so you could take this up as high as you want

we could um

we could maybe even say like clamp it at sixteen

and we'll do the same thing with our city

we'll set that to 16 as well

and you could see

we're getting more motion blur as you'd expect here

but it's a little bit cleaner

now the final touch on this is

you could see by increasing this clamp on both the

Zillow and our city

we're getting a bit more

we're introducing some of this

edgy quality back into this

so to resolve that now

we could just go back to our Vector Blur node

and select normalize here

and now that has cleaned up any of that

little outline that we have

but we have a clean

alpha channel

and we're getting good motion blur so again

but just for the sake of this example

if I disable these two clamp nodes

you could see

some of these um really

if I gamma this up

you could see some of this odd behavior in here

because of these debris pieces having really

odd velocity data in them

which is sort of a result

that happens sometimes when it's rendered out so

we to fix that um

the simple normalize option

helps for the most part

but it doesn't fully get rid of all of this so

um the best way to do it is essentially just clamp that

velocity data

and now if we enable those again

you could see it's cut those values down

and we're not getting those

really strange streaks happening

and we're getting good vector blur happening

on our character

and we could test another frame

I will disable this and maybe go to frame 1080 10 80

85 for example

and if we reapply our vector blur

you could see we're getting good vector blur

where you'd expect to see it

and maybe if we go to another frame

where maybe the cameras panning as well

with a debris pieces falling

if we re enable our vector blur

we're getting what we'd expect to see here

we're getting

not only is it just camera motion blur

but you're actually getting motion blur

applied on these pieces that are falling

and everything looks good where the contacts are

and we're getting vector blur nicely on him too

cause he's in the process of moving as well

and now if you look at our alpha channel

it's nice and clean as well too

if you even gamble this down we would we would see

any potential artifacts within this

so hopefully that helps explain a little bit of how to

um customize uh

sorry not customize

but how to clean up

any issues with the vector blur node

and any um odd

pixel values in our velocity passes

so to recap

just make sure to apply a clamp to our velocity and

set a fairly high maximum for this

and just make sure the um

the minimum uh

the maximum

you know it doesn't just clamp it at one

and then to put the final touch on it is

experiment with the normalize

checked on and off and

see if that's giving you any

additional artifacts or if it's actually

um taking care of artifacts that you would be seeing

in that case um

the other thing you might wanna do is potentially

with the clamp node

set the minimum to a minus 1

and the reason you wanna do this is because

the values in the negative direction are

things moving left

so if you clamp this at zero

then you're gonna be

clamping any values

any motion and and and left

so you wanna set the minimum on the um

the minimum below zero as well to just so that

you're picking up any motion

that's gonna be going to the left

and I'll do the same thing here with our clamp on our

Zilla character

and I'll set that to minus 1

this way we're getting

at least any motion coming from our

our Z direction through there too

so there you go

now we've got vector blur applied

to our character

to our characters I should say

and they're all playing nicely

now um again

to recap you could simply put a vector blur

perk element and merge them together

but this way

it's less calculation

and less processing by having multiple of these in your

in your script

and if you merge things cleanly using the

also merge feature and the merge node and

making sure you're getting your velocity pass

coming through

um you could

vector blur everything all together at once

so now we could just plug this in our stream

and if we look at our final result

with everything over our background

we are getting nice motion blur

on all the characters

together and we could go again to frame

another frame like 1092 and we enable our velocity

our vector blur

you can see we're getting good motion blur right now

the camera is fairly locked off here

so we're getting mainly his movement here

but everything is getting blurred nicely together