I Had to Build What the Bumper Could See

After I removed the light card, I checked the bumper from the camera view and worked backward to the part of the apron it reflected. The road had to carry the light now. Its surface and the camera angle had to agree.

That changed how I worked on the winter lot in One Lap. The bumper needed ground to reflect. The road needed worn paths with actual shape. Snow had to remain visible between the camera, the parked cars, and the lit service building. Each part affected what the next camera view could show.

1. The rectangle in the bumper

A polished surface responds to the direction it faces and the position of the camera. Roughness spreads a reflection; it cannot bring an unlit patch of ground into a bumper that is looking somewhere else. I had to inspect the truck from the camera position, then work on the part of the lot that appeared in its metal.

A small numerical exercise makes the camera change plain. It uses a vertical reflective plate and a flat floor. Raise its camera by 0.8 meters and the floor point appearing in the plate moves 1.5 meters. These are adapted teaching coordinates, separate from my film scene. The scripts and Blender exercise below use generic geometry and no production assets or settings.

Save this as mirror_ray.py. It runs with Python 3.10 or newer and needs no packages:

"""Adapted educational example; no film assets, scene, or production settings."""
from math import sqrt


def unit(vector):
    length = sqrt(sum(v * v for v in vector))
    if length == 0:
        raise ValueError("A direction must have nonzero length")
    return tuple(v / length for v in vector)


def ground_hit(point, normal, camera):
    normal = unit(normal)
    view = unit(tuple(c - p for c, p in zip(camera, point)))
    dot = sum(n * v for n, v in zip(normal, view))
    reflected = tuple(2 * dot * n - v for n, v in zip(normal, view))
    if reflected[2] >= 0:
        return None
    distance = -point[2] / reflected[2]
    return tuple(p + distance * r for p, r in zip(point, reflected))


if __name__ == "__main__":
    point, normal = (0, 0, 0.6), (0, -1, 0)
    for height in (1.4, 2.2):
        hit = ground_hit(point, normal, (0, -4, height))
        assert hit is not None and abs(hit[2]) < 1e-9
        print(f"camera_z={height:.1f} -> ground_hit={tuple(round(v, 3) for v in hit)}")
    assert ground_hit(point, normal, (0, -4, 0.6)) is None

Run python3 mirror_ray.py. The tested output is:

camera_z=1.4 -> ground_hit=(0.0, -3.0, 0.0)
camera_z=2.2 -> ground_hit=(0.0, -1.5, 0.0)

The plate did not move. At the lower camera height, it showed ground three meters from the plate. At the higher position, it showed ground only 1.5 meters away. If I light the first patch and then raise the camera, the highlight can vanish from the metal. The script computes an intersection; it does not render or judge an image. I still inspect the actual frame at native size.

For the carrier section, I checked reflected directions against the actual ground surfaces in the scene and put fill on the ground the camera could see through the bumper. In the later carrier view, the chrome carries a broad silver response with dark ground structure through it. I can no longer pick out the card as a rectangle.

2. Put the road where the reflection lands

The road-level approach. Two wet paths lead toward the service bay; its lamps catch snow at several distances.

The building gives this frame a destination. Parked vehicles close in from both sides. Snow near the camera crosses in long streaks; smaller flecks remain around the lit door. The exposed road pulls the eye through the middle.

I judged the snowfall by where it could be seen. The nearest flakes cut across the foreground. Around the building they become small marks against the door and work lights. That distance change matters when the storm and the road have to occupy the same space; an even screen of white would cover the scene without telling me how deep the lot is.

A dark stripe could have occupied those pixels, but a flat stripe gave the lamp little to describe. I shaped the exposed paths as shallow depressions with uneven slush at their edges. Their shoulders catch light. The wet middle sends a different reflection toward the camera. A worn path has a cross-section. Snow can remain beside it.

The carrier needed the same weather as the lot around it. The overhead view helped me check the arrangement before returning to the low camera:

Snow stays on the upper-deck roofs while amber markers trace the carrier’s length.

From above, I could see where the loaded deck sat among the parked rows. At road level, those same rows compress toward the service building. I used the two views for different checks: one for the lot’s geography, one for the path and weather that a viewer would feel while approaching it.

The selected cover let me inspect a third relationship at native size. Snow covered the hoods, roofs, and windshields of vehicles on the upper deck, while the carrier’s small markers still described its length. The weather was present on the payload as well as in the air and on the road. That gave the truck a place in the winter lot instead of treating it as a clean object dropped in front of one.

3. Build a smaller scene to test the reflection

Make three renders: the first camera with the road light off, the same camera with it on, then a second camera with the light unchanged. Keep the polished front plate material fixed. That sequence lets you see whether the road enters the reflection and what the camera changes.

The film scene used licensed vehicle models. For this exercise, make a short road and an unbranded vehicle from simple shapes. The plate at its front is the surface to watch.

Shape the road

Save this second adapted script as rut_strip.py. It writes a four-meter-wide, ten-meter-long Wavefront Object (OBJ) mesh with two shallow troughs:

"""Adapted educational OBJ generator; a new toy surface, not film geometry."""
import argparse
import json
from math import exp
from pathlib import Path


def surface_height(x):
    distance = min(abs(x - 0.7), abs(x + 0.7))
    return 0.025 - 0.018 * exp(-((distance / 0.19) ** 2))


def write_obj(path):
    nx, ny = 80, 40
    vertices = [(-2 + 4 * i / nx, -1 + 10 * j / ny,
                 surface_height(-2 + 4 * i / nx))
                for j in range(ny + 1) for i in range(nx + 1)]
    with path.open("x", encoding="utf-8") as stream:
        stream.write("# Adapted educational rut strip, units are meters\n")
        for x, y, z in vertices:
            stream.write(f"v {x:.6f} {y:.6f} {z:.6f}\n")
        for j in range(ny):
            for i in range(nx):
                a = j * (nx + 1) + i + 1
                stream.write(f"f {a} {a+1} {a+nx+2} {a+nx+1}\n")
    assert len(vertices) == 3321
    assert abs(min(v[2] for v in vertices) - 0.007) < 1e-9
    return {"vertices": len(vertices), "quads": nx * ny,
            "minimum_z_m": round(min(v[2] for v in vertices), 6),
            "geometry_checked": True, "rendered": False}


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("output", type=Path)
    args = parser.parse_args()
    print(json.dumps(write_obj(args.output), sort_keys=True))

Run it with a new filename:

python3 rut_strip.py demo-ruts.obj

The tested run produced 3,321 vertices and 3,200 faces, with a lowest height of 0.007 meters. The generator refuses to overwrite an existing file. I checked its geometry and counts.

Import the OBJ into Blender with one unit per meter. Check that the upper face normals point up. The height function starts at 0.025 meters and lowers each track center by up to 0.018 meters. Change the width value, then look from the camera again. You are changing the shoulder that catches light, not merely painting a darker line.

Give the metal a place to look

A beveled cube can stand in for a vehicle body. Put four cylinder wheels under it and check that they meet the road. Add a thin plate at the front, facing back toward the first camera. No badge, grille, or purchased asset is needed.

For the material test, use a Principled shader on each surface:

• Start the front plate at metallic 1 and roughness around 0.06. Its reflection should reveal the set around it.
• Make the exposed track darker and smoother, with roughness around 0.18. Give the snow a pale material at roughly 0.65 roughness, with fine Noise Texture feeding a small Bump node. Keep the wet road smoother than the snow.
• To place snow beside the tracks, take the X coordinate from Geometry Position and Separate XYZ. Measure its distance to track centers at -0.7 and 0.7 meters, keep the smaller distance, and map that value into a Mix between wet material and snow. Start the blend around 0.14 to 0.33 meters from a center. The mesh supplies the dip; the shader supplies the surface response.

Those roughness and blend values are starting controls, not measured settings from One Lap. If the tracks read as two ink marks, inspect their height profile, transition width, and light direction one at a time.

Move the camera, keep the light

Put one camera low and aimed at the front plate. Place a broad area light so it illuminates the road ahead of the vehicle, rather than presenting a bright card directly to the plate. Make a second camera about 0.8 meters higher or to the side. Keep both cameras aimed at the plate.

Compare the third render with the second. Its reflection may change even though the light stayed put. Return to the ray script before adjusting roughness.

For a short moving study, key a straight camera push that clears the wheels and ground. Inspect its first, middle, and last frames before rendering the full range. A sparse Geometry Nodes field of instanced flakes can test whether snow remains legible near the lens and at the building. Record your own wind and one mechanical contact for sound. Place that contact at a visible action, then listen once on speakers and once on headphones.

4. Know which frame you judged

I inspected the selected carrier render at its native 1280 × 720 size. That let me see the upper-deck snow, marker lamps, bumper response, and dark parts of the lot. I also needed to know that I was opening the selected file rather than an earlier lighting pass or a smaller preview.

This third adapted script, frame_receipt.py, records a Portable Network Graphics (PNG) file’s dimensions, byte count, and SHA-256 digest. It reads the file without changing it:

"""Adapted read-only PNG receipt; integrity is not visual approval."""
import argparse
import hashlib
import json
import struct
from pathlib import Path


def inspect_png(path):
    digest = hashlib.sha256()
    with path.open("rb") as stream:
        header = stream.read(24)
        if header[:8] != b"\x89PNG\r\n\x1a\n" or header[12:16] != b"IHDR":
            raise ValueError("Expected a PNG with an IHDR header")
        digest.update(header)
        for block in iter(lambda: stream.read(1024 * 1024), b""):
            digest.update(block)
    width, height = struct.unpack(">II", header[16:24])
    return {"file": path.name, "width": width, "height": height,
            "bytes": path.stat().st_size, "sha256": digest.hexdigest(),
            "pixel_review": "NOT_ESTABLISHED_BY_THIS_SCRIPT"}


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("image", type=Path)
    args = parser.parse_args()
    print(json.dumps(inspect_png(args.image), indent=2))

Run python3 frame_receipt.py your-render.png. Under Python 3.10.12, the script was run against the selected cover and another reviewed image. The cover’s dimensions, byte count, and digest matched its handoff record.

The last field has a narrow meaning. Matching bytes establish which file I inspected. They say nothing about whether the snow has depth or a wheel touches the ground. Open the frame at its actual size for those decisions. For the exercise, save the three comparison renders with their camera and light choices, then make a receipt for each.

5. Four questions I brought back from the directors

I used interviews as checks on my own shots. Each source gave me a question I could ask of the lot.

• Adam Greenberg: When he described wetting streets for Terminator 2, he also discussed moving lights appearing in a car’s windows and hood. Where should the road carry light, and what does the carrier reflect? Greenberg in American Cinematographer.
• Dan Laustsen: His account of backlit rain in John Wick: Chapter 3 pushed me to check snow at more than one distance. Which visible fixture reveals it? Laustsen in American Cinematographer.
• Chad Stahelski: His discussion of readable wide action sent me back to the overhead image. Can a viewer place the carrier among the parked rows before the cut moves closer? This is how I used the principle, not a copied John Wick setup. Stahelski in Filmmaker.
• Christopher Nolan: His account of building sound effects and music together during Dunkirk raised an editing question. Which mechanical action deserves the sound cut? Nolan at Cannes.

6. Coming soon: the AutoLensAI commercial

The 12-second clip below is a phone-size preview from One Lap, the upcoming commercial for my AutoLensAI application. It has a stereo audio track. The picture starts in darkness, then reveals exhaust, falling snow, a headlamp, and red bodywork. Play it with sound on.

Watch the 12-second preview of the One Lap commercial with sound.

The AutoLensAI commercial is coming soon. Glass, wet asphalt, and chrome can all show pieces of a set that sit outside the frame.

---

🎧 Listen to the audiobook — Spotify · Google Play · All platforms
🎬 Watch the visual overviews on YouTube
📖 Read the full 13-part series