All language subtitles for 01 IntroToPathTracing

Let's take a basic look at how a scene is
rendered.

This explanation describes path tracers, like
Cycles.

Meanwhile, rasterizers like Eevee use very
different methods.

But this is still relevant when working with
Eevee, because it tries to emulate the same

behavior as much as possible, so to the user
a lot of the same rationale applies, even

though it works differently behind the scenes.

Also keep in mind that this is extremely simplified,
and doesn't accurately describe what's actually

going on in Cycles or in the real world, but
it's enough as a foundation to start making

shaders.

Here we have a very simple scene.

Let's take note that the cone which has a
very matt surface, and the sphere has a polished

mirror-like surface, perfectly reflecting
almost all the light that hits it.

The scene is lit with a single lamp, which
we can see as a little white dot reflected

on the sphere.

There is also the ground, and some environment
light, but we can ignore those for now.

Let's keep the rendered scene in the corner
as a reference, and let's look at it from

outside the camera.

If this were a real scene, the lamp would
emit photons in all sorts of directions, some

of which are represented here by the yellow
dots.

These photons would mostly travel in a straight
path, until they hit an object.

This is a lot of paths, so let's just focus
on one of them, to see what happens.

Here, the path hit the cone, which has a matt
surface.

Basically, this means that when light hits
it, it bounces in a random direction.

The cone also has a color, which means that
some of the light gets absorbed, and the light

that gets reflected determines the surface
color, in this case red.

So now our light that was previously white,
gets colored red, and continues in a random

direction.

It happened to hit the sphere, which has a
sharp reflective surface, so that means that

the ray can only bounce in a specific direction,
in which the outgoing angle is a perfect mirror

of the incoming angle.

Also note that the sphere is not completely
reflective, so it absorbs a bit of light,

but being gray, it absorbs all colors equally.

Finally, our reflected ray hits the camera,
contributing to the color of a specific pixel.

Now, the thing is that this was a very specific
ray, which happened to hit the camera, but

there would have been many more rays that
didn't hit the camera, and thus wouldn't contribute

to the resulting image.

But luckily, this whole process is mostly
reversible, so render engines usually do the

whole thing backwards.

We start by shooting many rays from the camera,
and trace them until they hit an object.

Again, let's focus on a single ray.

At this point, the shader is evaluated.

This happens each time a ray hits an object,
and information about the object and the ray

is passed in as input to the shader, which
we can retrieve with a number of nodes.

We'll look more at this in a later chapter.

Since this object has a fully sharp glossy
surface, the ray can only do one thing from

here, a perfect reflection.

Now the ray hits the cone, which having a
diffuse surface, would cause the ray to bounce

off in a random direction.

This would be very inefficient, as lots of
rays would never hit a light source, and be

wasted.

So instead, we check if this ray could reach
a light source without hitting any obstacles.

For all we care, this has the same result
as if many rays were actually randomly bounced

off the surface.

Now that we reached the light, we can take
it's color and intensity, and trace it back,

basically multiplying the light with the object
colors along the way, to get the final color.

In reality it's a bit more complicated, but
that's the general gist.

Now that we traced this path, let's check
it by just keeping that one dot from the ray

that comes directly from the camera, and let's
get back into the camera view.

Now if we fade in the actual render, we see
that the dot is very close in color to that

point in the image.

The only differences are because we ignored
world lighting and because we got the color

by tracing a single ray, which kinda works
in such a simple scene, but generally you'd

need many more rays.

Once this whole process of shooting rays from
the camera is done many times for each pixel,

their individual results get integrated into
the pixel color, which in rough terms is kinda

like averaging the results of all the rays.

And that's how we get the final image.

The key point to remember about path tracing
in Cycles, is that the rays always start at

the camera, and bounce around the scene until
they hit some light source.