Original subtitles

The White Noise node allows us to generate completely random values between zero and

one, based on an input value.

Just like with the Noise node, the White Noise node can generate an output based on a one

to four dimensional input.

And also like the Noise node, it outputs a color, composed of three independent noise

channels, and a value, which carries the same result as the red color channel.

But it's different from the Noise node in that the Noise node has a smoothly varying

output, meaning that a small change in the input results in a small change in the output.

On the other hand, the White Noise node generates a completely random and independent value

for each input.

Given two different inputs, no matter how close they are two each other, the outputs

will be completely different.

However, just like other nodes, when given exactly the same input, it will generate exactly

the same output.

If we feed a texture coordinate into this Noise, the result is just a gray color.

This is because for each ray, even within a single pixel, the texture coordinate will

be ever so slightly different, resulting in a completely different noise output.

And given that for each channel of the noise the output has an equal probability of being

any value between zero and one, when the results of all the rays get averaged for each pixel,

the result is 0.5 on all channels, which is a gray color.

So at the ray level, the colors truly are all different, but at the pixel level, we

only see the combined results of several rays.

This is true for both Cycles and Eevee.

If we set the render to just one sample, we can see a completely random color for each

pixel, as each pixel just gets a single ray, and nothing gets averaged.

Note that here I'm zooming into the final rendered image.

Zooming with the camera in the viewport has no effect, and we'll still always see a different

random color for every single pixel, as each ray is hitting a different point, no mater

how close we zoom.

So the White Noise is useful when we need to randomize some attribute for each ray.

But it is also extremely useful when we have distinct elements that we want to randomize,

like tiles.

As long as we have a constant value for each element, we can feed it into the White Noise,

and we'll get a different constant output for each element.