### Raytracing concepts and code, part 8, mirror reflections

This is an article in a multipart series on the concepts of ray tracing. I am not sure where this will lead but I am open to suggestions. We will be creating code that will run inside Blender. Blender has ray tracing renderers of course but that is not the point: by reusing Python libraries and Blender's scene building capabilities we can concentrate on true ray tracing issues like shader models, lighting, etc.
I generally present stuff in a back-to-front manner: first an article with some (well commented) code and images of the results, then one or more articles discussing the concepts. The idea is that this encourages you to experiment and have a look at the code yourself before being introduced to theory. How well this works out we will see :-)

So far the series consists of the several articles labeled ray tracing concepts

## Mirror reflections

Mirror reflections are an important part of ray traced images. Many materials like glass and metals have a reflective component. Calculating ray traced reflections is surprisingly simple as we will see but we do need some options from the material properties so that we can specify whether a material has mirror reflectivity at all and what amount. Again we borrow an existing panel (and ignore most options present; later we will create our own panels with just the options we need but cleanup is not in focus just yet)

## Reflecting a ray

To calculate mirror reflection we take the incoming ray from the camera and calculate the new direction the ray will take after the bounce and see if it hits anything. The direction of the reflected ray depends on the direction of the incoming ray and the surface normal: the angle between the normal and the incoming ray equals the angle between the normal and the reflected ray:

If the the length of all vectors are normalized, we can calculate the reflected ray using this expresion: `dir - 2 * normal * dir.dot(normal)`
For a more in depth explanation you might want to take a look at Paul Bourke's site.

## Code

To deal with mirror reflecting the `single_ray()` function needs a small enhancement: it needs to check the amount of mirror reflectivity specified in the material (if any) and then, if the number of bounces we made is still less than the specified `depth`, calculated the reflected ray and use this new direction to cast a new ray and see if it hits something:
```        ... identical code left out ...

mirror_reflectivity = 0
if len(mat_slots):
mat = mat_slots[0].material
diffuse_color = mat.diffuse_color * mat.diffuse_intensity
specular_color = mat.specular_color * mat.specular_intensity
hardness = mat.specular_hardness
if mat.raytrace_mirror.use:
mirror_reflectivity = mat.raytrace_mirror.reflect_factor

...

if depth > 0 and mirror_reflectivity > 0:
reflection_dir = (dir - 2 * normal  * dir.dot(normal)).normalized()
color += mirror_reflectivity * single_ray(
scene, loc + normal*eps, reflection_dir, lamps, depth-1)

...
```

## Code availability

The code for this revision is available from GitHub.