Original subtitles

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.