Tile-Based Deferred Rendering vs Traditional Immediate Mode Desktop GPUs: Fundamental Mechanics and Deep Mathematical Modeling

[Luke Wilson]

Alright, I’ve been digging deep into the architecture side of things and I need to sort out a fundamental question about tile-based deferred rendering versus traditional immediate-mode desktop GPUs. With TBR’s binning pass, the renderer sweeps the frame once to sort primitives into tiles, then renders each tile using on-chip memory, which should dramatically cut bandwidth compared to the read-modify-write cycle of a conventional deferred or forward pipeline. But here’s where I’m genuinely stuck: how exactly does the on-chip tile memory bandwidth ceiling interact with the per-tile primitive sorting overhead when you’ve got heavy overdraw in dense scenes? Where’s the actual crossover point where binning stops being a net win?

I’m also curious about the power-to-performance scaling story. On mobile and handhelds the lower bandwidth clearly pays off, but on a desktop-class GPU running at high refresh rates, does the extra binning pass and the limited tile memory size eat into those gains? Is there a mathematical model for the optimal tile size given a fixed L2 budget—like, how do you derive the breakeven bandwidth savings against the coordinate-sorting cost? And honestly, how do you handle depth ordering and transparency when everything’s being processed tile-by-tile instead of globally?

🎮 Battlestation & Rig: Ryzen 5 7600X | RTX 4070 Super Dual | 32GB DDR5 6000 CL30 | FormD T1 SFF | AOC AGON Pro AG276QZD 240Hz QHD OLED | Logitech G Cloud + Razer DeathAdder V3 Pro + Endgame Gear EM-C Pad | Audio-Technica ATH-R70x + Schiit Magni/Modi Stack

📍 Montreal, QC (Canada)

"Under 55 grams on glass skates: zero friction, pure aim."

[Brandon Ramirez]

Great topic for a deep dive. The core mechanical difference really comes down to where fragment shading happens relative to the depth test. In an immediate-mode desktop GPU, the rasterizer pushes fragments straight toward the framebuffer in VRAM, and while modern cards do employ early-Z (depth culling) at the shader stage, the architecture fundamentally processes fragments in a streaming fashion without a dedicated deferral stage. TBDR,

[Marcus Allen]

Great topic. The core architectural difference really comes down to where the depth and color resolve in the pipeline. With Immediate Mode Rendering (IMR), which is what essentially every desktop GPU uses, each fragment is rasterized and written straight to the framebuffer in VRAM as it’s produced—no intermediate staging. The problem is overdraw: in a complex scene with heavy transparency or dense geometry, the same pixel gets shaded and memory-written many times, and every one of those writes costs you bandwidth on the GDDR bus. TBDR (think Apple’s GPU, ARM Mali, PowerVR) flips this by partitioning the frame into tiles that fit entirely in the GPU’s local high-bandwidth tile memory. Depth and color tests resolve per-tile before anything gets flushed to main memory, so only the final surviving samples get written back. The bandwidth savings model cleanly: if your average overdraw factor is D, IMR does roughly D× the pixel-memory traffic while TBDR approaches 1× for color, which is exactly why it dominates mobile and battery-constrained

"Lag isn’t an excuse, but it definitely wasn’t my fault."

[Author]

Posts