The Mirror That Isn't

You're standing in a rain-soaked alley. Neon signs bleed pink and teal into the puddles at your feet. Your character's boots ripple the reflection as you walk through it, and for a second your brain just... accepts it. Completely. Files it under "light bouncing off water" and moves on.

None of it is real. Not one photon was simulated.

Real reflections work by tracing light from a source, bouncing it off a surface, and calculating what reaches your eye. Do that for every pixel, every frame, sixty times a second, on a dynamic scene with hundreds of moving objects, and even the fastest GPU alive would buckle. So engines cheat. Brilliantly, systematically, in ways that took decades to refine, and the cheats are so good that most players never notice. Which is, of course, the entire point.

The Oldest Trick: The World Rendered Twice

The foundational fake is called a planar reflection, and it's almost insultingly simple once you see it.

The engine renders the entire scene a second time, from a camera position flipped to the mirror image of the player's view. That flipped render gets pasted onto the reflective surface. The puddle isn't showing light bouncing off water. It's showing a second, upside-down camera feed projected onto a flat plane.

Here's the scenario: a player stands in front of a bathroom mirror. The engine is running two cameras simultaneously. One is your view. The other is positioned as if it were behind the mirror, looking back at you, with its output texture-mapped onto the mirror geometry. Walk left, and both cameras move together. The illusion holds beautifully in that tight space.

The cost is real. Rendering the scene twice roughly doubles the draw calls for that frame, which is fine for a contained bathroom and catastrophic for an open-world city full of glass skyscrapers. So developers use planar reflections sparingly, reserving them for the most prominent, plot-important mirrors. Every other shiny surface gets a cheaper trick.

Cubemaps: The Frozen Panorama

Open almost any game from the last fifteen years and most of its reflections are cubemaps. A cubemap is a pre-baked panoramic snapshot of an environment, captured from a fixed point during development and stored as six square textures (one per face of an imaginary cube surrounding that point). The engine wraps that snapshot onto nearby reflective surfaces and calls it a day.

The chrome fender on a car in a racing game? It's reflecting a photograph of the track taken during asset production, not the live scene. The marble floor in an RPG throne room? Same deal. The reflections look plausible because the general lighting and color palette match the surroundings. But they're static. They will never show a dynamic object, another character, or a shift in weather.

This is why, in older or mid-budget games, you can walk up to a shiny surface and notice the reflection doesn't include you, or shows a version of the environment that no longer matches what's around you. The panorama was baked before you arrived. It doesn't know you exist.

Some engines update cubemaps at set intervals, say every 500 milliseconds, for important surfaces. This catches slow changes like a day-night cycle. Fast-moving objects still ghost or disappear entirely. You get away with it because human perception is surprisingly tolerant of reflective imprecision, as long as the color and brightness are roughly right.

Screen-Space Reflections: The Clever Kluge

The technique that genuinely changed what players expected is screen-space reflections, abbreviated SSR. More sophisticated than cubemaps, considerably cheaper than planar rendering.

SSR works by using only the information already on screen. The engine takes the current rendered frame, calculates the surface normals of reflective objects (which direction each surface faces), and marches rays across the existing 2D image to find where those reflected rays land. The result gets composited back onto the reflective surface. No new light physics. Just a very clever rearrangement of pixels that already exist.

A wet concrete floor in a corridor will show a convincing, slightly blurred reflection of the ceiling lights above it because those lights are already rendered on screen. The engine looked up where the ceiling pixels are and smeared them downward. It's less like optics and more like folding a photograph in half.

The catch is immediate: SSR can only reflect what's visible on screen. Walk to the edge of a puddle and look down. Anything off-screen, behind you, or hidden by other geometry? Gone. The reflection abruptly cuts off or dissolves into a fallback cubemap. It's the most recognizable artifact of modern real-time rendering, and once you spot it, you'll see it everywhere.

Consider this: two characters stand on opposite sides of the same reflective floor. The one facing the light source sees a convincing SSR reflection of the scene ahead. The one facing away sees a blurry cubemap approximation, because the light sources she'd need to reflect aren't in her frame. Same surface, same moment, two entirely different fakes running in parallel.

What People Actually Misunderstand About Ray Tracing

Ray tracing has become a marketing word, and the gap between the label and the reality is wide enough to drive a render pipeline through.

Modern ray-traced reflections in games are not full path tracing. They typically fire a limited number of rays per pixel, often one to four, at reduced resolution, then use AI-based upscaling and denoising to make the result look clean. Still an approximation. A dramatically better approximation than cubemaps, one that catches dynamic objects, self-reflections, and off-screen geometry, but the "accurate physics" framing oversells it badly. And I think the GPU vendors know exactly what they're doing when they lean on that language.

The real-world tradeoff is blunt: enabling ray-traced reflections in a demanding game can cut frame rates by 30 to 50 percent even on high-end hardware. Most players on mid-range machines leave it off and play with SSR instead, getting cubemap-plus-screen-space trickery and mostly not noticing. Which raises an honest question: if the cheaper fake already has your brain convinced, what exactly are you paying for?

Found the reflection artifacts in your current game? If you can only spot them by actively looking, the engine team did its job.

The Perceptual Bargain

What makes all of this work isn't the technology. It's that human vision is lazy in exactly the right ways.

We don't verify reflections. We sample them. If the general brightness, color, and blur feel right for a shiny surface, the brain signs off and moves on to the next thing demanding its attention. Game engines have spent thirty years learning precisely how little they can get away with, and at this point the field isn't really about rendering light anymore. It's applied psychology with a shader compiler.

The puddle in that neon alley isn't showing you physics. It's showing you a carefully constructed lie that your visual cortex already decided to believe before you finished the thought. The engineers didn't solve light transport. They solved you.