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.
I was lighting One Lap, a commercial for AutoLensAI. The brief was to show a dealer taking one phone lap around a car, then using the finished images to sell it. The hero is Online Auto Connection truck #171. I bought a hauler, rebuilt it into that truck with Mark Subjeck’s permission, and modified the other vehicles from licensed meshes. The lot is not an HDRI with a product in it. The bumper only returns what its local normals can see from the shot camera. Everything else is a guess wearing gloss.
The rectangle in the bumper
A bounce card on painted plastic is fill. The same card on chrome is a white stamp. The metal was correct. The lighting model was not.
Specular return follows the reflection of the view vector about the surface normal. Roughness convolves that lobe. It does not invent a sample from a direction the facet does not face. Before I opened the shader I recovered the reflected ray and asked where it hit the apron.
A teaching plate is planar. A bumper is not. Adjacent facets on the bar look at different ground. One lit mark cannot serve the bar. I lit the ground those facets were actually sampling and removed the card.
mirror_ray.py is generic geometry, no production assets, Python 3.10+, no packages. A vertical plate 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
python3 mirror_ray.py:
camera_z=1.4 -> ground_hit=(0.0, -3.0, 0.0)
camera_z=2.2 -> ground_hit=(0.0, -1.5, 0.0)
Plate fixed. Camera up 0.8 m. Reflected floor point walks 1.5 m, from 3 m ahead of the plate to 1.5 m ahead. Lighting the truck is a ground problem with a truck in front of it.
I traced the bar’s reflected directions onto the real apron and put fill there. Later frame: dark ground structure in the chrome, card gone, silver response still intact. Raise gloss alone and the bar becomes a knife. Raise intensity alone and the card returns. The test is whether the thing in the metal exists on the lot, along the ray that facet is using, from this camera.
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.
The lot is built around the service building. Lit door as terminus. Parked rows as a corridor. Road wide in the foreground, straight to that door.
Snow is judged by where it can be seen. Long streaks near the lens put weather between camera and first cars. Flecks on the bay door put it behind them. If the door stays legible through both, the lot has depth in one frame. Particle count is not that measurement.
A flat dark stripe gives a lamp nothing to describe. I cut shallow depressions and left slush on the shoulders. Shoulders catch grazing light. Wet centers return a different lobe toward camera. A worn path has a cross-section. Snow can sit beside it. Identical grooves read as tooled. Continuity in the wet middle pulls to the bay; irregular slush breaks the outline. At road height, wet center and snow edge occupy the same strip. That strip is what the bumper samples. A decal track becomes a decal in the chrome.
Cover still has to read as a truck. Amber markers separate deck from parked cars. Red spill hits snow under the trailer. Bumper: silver response, dark ground inside. Native size lets you inspect those separately. Thumbnail reads the truck and discards the bar. I stopped treating the thumbnail as sign-off on the chrome.
Native detail crop of #171’s grille and chrome bumper from the 4K front view.
Snow on #171’s upper deck. View the full 4K overhead frame.
Overhead camera first: is #171 actually in the aisle I think I built? Road-level rows compress toward the building. That compression is useful in the beauty frame and a lie in layout. Then back to the low camera for paths and snow.
Upper-deck snow did more than another flake pass. Thickness on roof lines. The deck looks loaded because it has been outside.
Build a smaller scene to test the reflection
The carrier file is the wrong notebook. Short road, box on wheels, polished plate. Three stills, same plate: road light off, road light on, second camera with the light untouched.
Floor first. If the bright patch is not the plate’s reflected hit, more power lights the wrong ground. Then the metal.
rut_strip.py writes a 10 m strip, two shallow troughs. python3 rut_strip.py demo-ruts.obj — new filename — reports 3,321 vertices, lowest height 0.007 m. Full generator under Scripts.
Blender import at 1 unit = 1 m. Upper-face normals up. Surface at 0.025 m. Track centers drop ≤ 0.018 m. Wear, not a trench. Change width, then read the shoulder from the bumper camera, not the hero three-quarter. A profile that reads from the beauty angle can vanish from the plate.
The mesh is height plus a place to blend. A mask can paint two dark lanes on a plane. Only the mesh gives a shoulder that catches a grazing lamp and holds snow beside the depression. If the silhouette dies at camera height, roughness will not save it.
Beveled cube, four cylinders, contact with the road, thin plate facing the first camera. Hovering wheels poison the rest of the test.
Principled on the plate: metallic 1, roughness ~0.06. Exposed track ~0.18. Pale snow ~0.65 plus fine Noise into a small Bump. Starting values. The track has to sit between plate and snow. If those three collapse, the study is over.
Bare mesh under the road light before snow. Shoulders gone at the intended height: fix profile or light. Then the pale blend. Snow last.
Snow beside tracks: Geometry Position → Separate XYZ, distance to centers at −0.7 and 0.7 m, min of those, Mix wet/snow with a blend band ~0.14–0.33 m from either center. Ink-mark tracks: height, transition width, light direction, one at a time.
Low camera into the plate. Broad area light on the road ahead of the box. Second camera +0.8 m, same aim. Compare third still to second before you touch roughness. That 0.8 m is the teaching interval. The reflected hit should walk toward the plate. If it does not, the plate is not the mirror you think it is, or the lamp is not on the ground it can see.
Moving test: straight push, first / mid / last. Wheel contact. Flakes near the lens and small against the building. Mechanical contact cut to a visible action, speakers and headphones. Hiss with no source dies in the edit. Clank a frame late dies too.
Then more snow. Watch a flake intersect the plate. Watch a wheel leave the road. Sound stays tied to picture.
Know which frame you judged
Thumbnail: truck yes, chrome no. 3840 × 2160: dark ground in the bumper, snow on the upper deck, wheel on the lot. That is the file on the receipt.
Approving lighting in a panel too small to show the bar is how you ship a white rectangle.
python3 frame_receipt.py your-render.png prints dimensions, byte count, SHA-256 for a PNG. The new 4K PNG master returned 3840 × 2160, and its hash matched the handoff. The JPEG on this page is 1,211,732 bytes and matched its separate hash. Script under Scripts. pixel_review is NOT_ESTABLISHED_BY_THIS_SCRIPT. The hash names the file. It does not review the chrome.
Four questions from the directors
Working questions, not a mood board.
Adam Greenberg wetting streets on Terminator 2 to darken gray pavement, and separately moving reflections in glass and hoods. Wetting the lot darkened it. The question that remained: where does that wet road enter the bumper? If I cannot point at the patch, the wet work is decoration.
Dan Laustsen’s backlit rain in John Wick: Chapter 3 — foreground first, then the fixture that proves weather has a far plane. Here the bay door, not the sky. Snow only around the lens is a filter.
Chad Stahelski on readable wide action: can I place #171 among the rows before I cut closer? If the carrier is lost overhead, the bumper close has no geography to return to.
Christopher Nolan building effects and music together on Dunkirk: which mechanical action earns the cut? Exhaust, wheel in slush, marker past the lens. Pick one. A bed of winter noise hoping the picture will explain it will not.
Four ways to fail a still.
The cold open
Twelve seconds, 390 × 220, stereo. Darkness, then exhaust, snow, a headlamp, red bodywork. Sound on.
Open the 12-second preview with sound.
From One Lap, AutoLensAI.
Glass, wet asphalt, and chrome sample set pieces that sit outside the frame. Same rule as the bar. Interesting reflection, empty lot in that direction: wrong build.
Card off. Road where the metal was looking. Truck #171. Winter lot. Receipt on the frame I actually judged.
Scripts
mirror_ray.py— reflected ground point from plate and camerarut_strip.py— road mesh generatorframe_receipt.py— PNG file receipt
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))