You're standing on a rooftop. You've been fine all session, a steady 60 frames, fan barely audible. Then you pan the camera to look out over the city below, and something shifts. The fan climbs. The frame rate sags. Nothing in the scene changed. Same city block, same time of day, same character. The GPU is just angrier now.
This isn't a bug. It's geometry.
What the engine actually bills you for
A game engine doesn't render everything in the world. It renders everything the camera can theoretically see, a volume called the view frustum: a truncated pyramid starting at your lens and widening outward to a far clip plane, typically somewhere between 500 and 2,000 virtual meters depending on the game. Anything outside that pyramid gets culled before the GPU even touches it. Cheap, fast, fine.
The problem is what's inside the pyramid.
Rendering cost comes down to two numbers: draw calls (instructions sent to the GPU to render a mesh) and pixel fill rate (how many pixels need color and depth information written to them). Both explode depending on which direction you point.
Face a narrow alley and you see maybe forty objects, most of them hidden behind walls. The engine's occlusion culling system figures out that the building behind the first building is invisible, culls it, and the GPU handles a manageable load. Point that same camera at an open plaza, or look down from a rooftop across an entire district, and the frustum swallows thousands of objects, most of them visible, all of them needing to be drawn. Draw calls can jump from a few hundred to several thousand in a single rotation. Not metaphorically. In titles like Cyberpunk 2077 or Microsoft Flight Simulator, profiling tools show draw call counts varying by an order of magnitude based purely on view direction.
Here's the scenario that makes this concrete. Two players, Maya and Priya, running the same RPG on identical hardware. Maya is in a canyon, walls close on both sides, looking forward. Priya is on a cliff edge, camera panned to overlook a valley city below. Maya holds 60 fps without complaint. Priya is at 41 fps, GPU sitting at 97% utilization. Same game version, same settings. The cliff is the most expensive seat in the house, and Priya didn't get a warning before she bought the ticket.
The shadow math nobody warns you about
Shadows make this worse. Much worse, and in a direction most players don't expect.
Real-time shadows are rendered using shadow maps: the engine places a virtual camera at each light source and renders the scene from that light's point of view to build a depth texture. Every frame. For every shadow-casting light inside the frustum. Face a cramped indoor space and maybe one or two lights matter. Face an outdoor panorama with a sun, ambient fill lights, and several streetlamps, and the engine is now rendering the scene multiple times per frame from multiple light positions, each covering a large chunk of the world.
This is why looking directly at a sunset is the single most punishing camera angle in almost any game. The sun sits low, so its shadow map must cover an enormous ground area to cast long shadows correctly. The fill rate cost of resolving all those shadow samples across every visible pixel piles up like a tab you forgot you were running. Some engines use cascaded shadow maps, splitting shadow distance into rings of decreasing resolution, to soften this. The fundamental geometry of a wide, low light source stays expensive regardless.
What players attribute to "bad optimization" in a particular scene is, honestly, usually just the honest cost of that view. Lots of unique objects, lots of lights, lots of shadow-casting geometry, all visible at once. The engine isn't failing. It's just telling you what that angle actually costs.
The honest caveat
Occlusion culling, level-of-detail (LOD) systems, and draw call batching can all mitigate this. None of them eliminate it.
LOD systems swap high-polygon meshes for simpler ones at distance, which helps fill rate. Batching merges multiple objects into single draw calls, which helps CPU overhead. A well-tuned engine running these systems aggressively will have a much flatter cost curve as the camera rotates. A poorly tuned one, or a game that shipped under deadline pressure, will swing wildly.
You can test this right now. Most PC games expose a performance overlay, or you can use MSI Afterburner. Find an open outdoor area. Watch GPU usage as you slowly rotate 360 degrees. See the spike toward the most open sightline? That's the frustum filling up. The trough when you face a wall is occlusion culling earning its keep.
The camera isn't a passive window onto a scene. It's the renderer's most expensive tool, and every direction you point it is a fresh invoice. The GPU isn't struggling with your world. It's struggling with your curiosity about it.