The carrier’s chrome reflected my light card as a white rectangle. I moved the light to the wet road and rebuilt the shot around what the bumper saw.
1. The rectangle in the bumper
With the card gone, I traced the bumper’s reflection back to the apron.
A polished surface reflects along a direction set by its angle and the camera’s position. Roughness spreads that reflection. It cannot bring a lit patch of road into metal that faces somewhere else. I checked the reflected direction before touching the shader again.
The teaching plate is flat. The bumper is not. Each patch of chrome looks at a different piece of apron, so one lit mark on the road cannot serve the whole bar. I had to use the shot camera and light the ground that bar was actually returning.
The scripts below use generic geometry and no production assets. They run with Python 3.10 or newer and need no extra packages. In mirror_ray.py, a vertical plate reflects a flat floor at teaching coordinates:
"""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 stayed still. Raising the camera by 0.8 meters moved the reflected floor point 1.5 meters, from three meters ahead of the plate to 1.5 meters ahead. In the carrier scene, I traced the bumper’s reflected directions to the actual ground and put fill there. In the later frame, the chrome held dark ground structure and the card was gone.
2. Put the road where the reflection lands
Two wet paths lead toward the service bay. Snow is visible near the camera and around the door.
I built the winter lot around the service building. Its lit door gave the camera a destination; parked rows kept the route narrow. The road starts broad in the foreground and runs straight to that door. Near the lens, snow crosses in long streaks. At the far wall it becomes flecks against the light. I judged the snowfall by where I could see it.
A flat dark stripe gave the lamp little to describe. I cut shallow depressions into the terrain and shaped uneven slush at their edges. Their shoulders caught light. The wet middle sent a different reflection toward the camera. A worn path has a cross-section. Snow can remain beside it.
Cover: snow on the upper-deck vehicles, amber markers along the carrier, dark ground in the chrome.
I bought a hauler model, then rebuilt it into Online Auto Connection truck #171 with permission from the owner, Mark Subjeck. The other vehicles also began as licensed models that I modified for the film.
The loaded carrier beside the parked rows.
I placed the overhead camera to check where the deck sat among those rows. At road level, the rows compress toward the service building. I returned to the low camera to judge the paths and the snow.
3. Build a smaller scene to test the reflection
Three renders, same plate: road light off, road light on, then a second camera with the light left alone. Look at the floor first. If the bright patch is not the point the plate is reflecting, more power only lights the wrong ground. Then look at the metal.
A short road, a box on wheels, and a polished front plate are enough. The adapted rut_strip.py writes a 10 m road strip with two shallow troughs. Run python3 rut_strip.py demo-ruts.obj with a new output filename. It reports 3,321 vertices and a lowest height of 0.007 m. The full generator is under Scripts.
Import the OBJ into Blender at one unit per meter and check that its upper face normals point up. The surface starts at 0.025 meters. Each track center drops by up to 0.018 meters. Change the track width, then inspect the shoulder from the camera.
Use a beveled cube for the body and four cylinders for wheels. Check their contact with the road. Put a thin plate at the front, facing back toward the first camera.
For the plate’s Principled shader, start with metallic 1 and roughness around 0.06. Start the exposed track around 0.18 roughness and the pale snow around 0.65, with fine Noise Texture feeding a small Bump node. These are starting values for this test.
To keep snow beside the tracks, take the X coordinate from Geometry Position through Separate XYZ. Measure the distance to track centers at -0.7 and 0.7 meters and keep the smaller distance. That drives a Mix between wet material and snow, with a starting blend from 0.14 to 0.33 meters from either center. If the tracks read as ink marks, inspect the height profile, transition width, and light direction one at a time.
Put the first camera low and aim it at the plate. Use a broad area light to illuminate the road ahead of the box. Place the second camera about 0.8 meters higher, still aimed at the plate. Compare the third render with the second before changing roughness.
For a moving test, key a straight camera push and inspect its first, middle, and last frames. Check wheel contact and whether flakes remain visible near the lens and farther into the scene. Place a recorded mechanical contact at a visible action, then listen on speakers and headphones.
4. Know which frame you judged
At thumbnail size the truck reads and the chrome does not. At 1280 × 720 I could see dark ground in the bumper, snow on the upper deck, and whether a wheel sat on the lot. That is the file I kept a receipt for.
Run python3 frame_receipt.py your-render.png to print image dimensions, byte count, and SHA-256. For the cover it returned 3,219,108 bytes and a hash matching the handoff receipt. The full script is under Scripts. Its pixel_review field reads NOT_ESTABLISHED_BY_THIS_SCRIPT. The hash is not the review.
5. Four questions from the directors
Adam Greenberg described wetting the streets for Terminator 2 to darken gray pavement, and separately described moving reflections in car windows and hoods. Where did my wet road enter the bumper’s reflection?
Which visible fixture revealed the snow? Dan Laustsen’s backlit rain in John Wick: Chapter 3 sent me to the foreground, then the service door. The overhead posed a different question after Chad Stahelski’s discussion of readable wide action: could I place the carrier among the parked rows before cutting closer?
Christopher Nolan’s account of building sound effects and music together on Dunkirk left one question: which mechanical action deserved the sound cut?
6. The cold open
The 12-second cold open below is a 390 × 220 phone-size preview with stereo sound. It starts in darkness, then reveals exhaust, falling snow, a headlamp, and red bodywork. Play it with sound on.
Open the 12-second preview with sound.
The clip is from One Lap, my commercial for AutoLensAI.
Glass, wet asphalt, and chrome show pieces of a set that sit outside the frame.
Scripts
rut_strip.py — road mesh generator
"""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))
frame_receipt.py — PNG file receipt
"""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))
🎧 Listen to the audiobook — Spotify · Google Play · All platforms
🎬 Watch the visual overviews on YouTube
📖 Read the full 13-part series
