Original subtitles

So NUKE uses these things called nodes to perform operations.

What is a node?

Well, a node is the smallest unit of a comp, or a composite.

Each node represents a specific operation to the image that it's connected to,

and then several of these nodes are strung together to create

a network or a node tree of operations.

Each node or operation in the comp concatenates to create the final

image represented by the last node in your tree.

So simply put,

NUKE just uses these visual objects called nodes to perform

operations on the images we'll be manipulating.

Each node constitutes a different operation that will be performed,

and we can string together many operations to get the end desired look that

we're looking for in an image that we wish to manipulate.

So how is node based compositing different from other methods of compositing?

Well, they are basically two main methods of composting.

One is node based compositing and the other is layer based compositing.

Layer based compositing you might have experienced so far.

This is what Adobe After Effects does.

Each media object in a layer based compositing package or each image is

represented by a separate layer within the timeline.

Each one of these layers has its own operations that can be

applied to it to manipulate the timeline,

effects, color adjustments, or keyframes.

NUKE is a node based compositing package,

which means each operation is graphically represented,

and as the image passes through each one of these nodes or operations,

they inherit the operations of each node.

This gives us a powerful graphical representation of the

workflow and lets us pick and choose,

view or modify any of the changes anywhere in the node tree,

on the fly quickly and easily.

Now that brings me to a word I used a moment ago in this clip, concatenation.

What is concatenation and why is it important to NUKE?

Well,

you'll hear the word concatenation a lot in reference

to node based compositing packages.

Concatenation relates to the way an application handles the

operations performed on an image in a compositing script.

I like to think of concatenation as a waterfall or a snowball.

Concatenation means everything you're passing into a node will

inherit the operation present in that node itself.

So everything that comes out of that node is everything that came before it,

plus whatever attributes you're adding with that node.

It'll make sense when we get deeper into NUKE,

but it's just important to know that concatenation simply

gives us a non-destructive workflow of operations that we

can remove or add to at any time, in any part of the tree.

Let me give you a quick example of what I'm talking about.

In example two, we have a very simple node tree.

We have an image, that image is being passed into a blur node,

that blur node is being passed into a color correct node,

where the gamma is being shifted to be blue,

and that node is being passed into a color correction node that

is removing the saturation from the image.

So concatenation simply means that this image is being passed into a blur node,

the total sum of those operations is being passed

into this color correction node,

and the total sum of those operations is being passed into the saturation node.

And that gives us a non-destructive workflow where we can just

simply remove the blur node from the tree,

and now the image is being passed into these color correction nodes,

not taking this blur into consideration,

and if we want the tree to take the blur into consideration,

we can just pop it back in there,

or we can move it to a different place in the tree,

so this is being shifted to be blue, the saturation's getting removed,

and now the image is getting blurred.

So it just depends on where you want the operations to happen in the tree,

and it's important to take this into consideration because some

operations are more expensive than others,

so if you're blurring something,

that might be a more expensive operation than a color correct,

and when you think through your comp,

you just want to think about what operation should come first,

and what operation should come later.

So when we're concatenating,

you basically just want to keep in mind that if this

operation is heavier on your processor,

you might want to save it for later in the tree.