11. Reflection and Recursive Rays

Local specular lighting produces a highlight, but it does not show the scene reflected in a surface. A mirror requires another visibility question. At the hit point, the incoming direction is reflected about the surface normal. The new ray searches the scene, and its returned colour contributes to the original pixel.

This is the first time a successful hit creates a ray whose result depends on another hit. The arithmetic of reflection is simple. The important engineering question is how to stop the chain. Two facing mirrors can keep generating rays without reaching a miss. A renderer must impose a termination rule and account for the work it permits.

Reflect the direction

Let D be the incoming unit direction and N the unit normal oriented against it. The component of D along N is (D · N)N. Subtracting twice that component mirrors the vector to the other side of the tangent plane:

R = D − 2(D · N)N

function reflect(direction, normal) {
    return subtract(
        direction,
        scale(normal, 2 * dot(direction, normal))
    );
}

If D and N are unit vectors, the result should also have unit length apart from finite-precision error. Normalising it defensively is inexpensive in this teaching renderer. More importantly, the signs must agree with the direction convention. Our D points towards the surface and N points against it. Changing either convention without changing the formula can send the reflected ray into the object.

Make tracing a function that can call itself

The trace function takes a ray and remaining depth. A miss returns sky. An opaque diffuse hit returns local lighting. A reflective hit constructs R, offsets the origin and calls trace again with one less permitted bounce.

function trace(ray, remainingBounces) {
    const hit = closestHit(ray, scene.objects, epsilon, farLimit);
    if (hit === null) {
        return sky(ray.direction);
    }

    const local = shadeLocal(ray, hit);
    const amount = hit.material.reflectivity;

    if (amount === 0 || remainingBounces === 0) {
        return local;
    }

    const reflectedRay = {
        origin: add(hit.position, scale(hit.normal, epsilon)),
        direction: normalise(reflect(ray.direction, hit.normal))
    };

    const reflected = trace(reflectedRay, remainingBounces - 1);
    return mix(local, reflected, amount);
}

The simple mix uses reflectivity as a teaching weight. A physically based conductor model would use wavelength-dependent Fresnel response and energy-aware material parameters. We are establishing recursive transport and work accounting before replacing the material approximation.

Count what recursion buys

Set the bounce limit to zero. The mirror sphere can show only its local term. Increase the limit and it begins to return the plane, sky and nearby objects reached by reflected rays. The primary-ray count does not change; the reflection-ray count and primitive-test count do.

A higher limit is not automatically a better image. If later bounces carry negligible contribution, the added work may not produce a visible difference. Conversely, one required mirror-to-mirror route may remain incomplete at a low limit. The operative criterion is the error and contribution permitted by the termination policy, not the largest number the device can tolerate.

Recursion is a description, not a requirement

The JavaScript function uses recursion because it expresses the path clearly. A renderer can perform the same process iteratively, carrying the current ray, accumulated colour and throughput through a loop. GPU implementations often prefer iterative control because call stacks, shader stages or implementation limits make general recursion unsuitable.

Do not confuse the code shape with the light path. The essential state is a current ray, remaining budget and accumulated contribution. Whether a programming language stores that state in stack frames or explicit variables is an implementation choice.

Contribution should also guide termination

A fixed depth gives a clear upper bound and reproducible teaching result. It can waste work on tiny contributions and truncate an important path at the same depth. More advanced tracers track path throughput and may use Russian roulette to terminate low-contribution paths without introducing systematic bias when weighted correctly.

We shall not add that estimator here because it would combine material transport, probability and termination before refraction has been introduced. The limitation is nevertheless important: a bounce count proves finiteness, not optimality and not physical completeness.

Reflection keeps the ray on the incident side of a boundary. Lesson 12 allows a transparent material to transmit a ray into another medium and uses Fresnel response to divide contribution between the reflected and transmitted routes.