The Polycount Myth: Why Vertex Count Doesn't Matter Anymore

For decades, game developers obsessed over polygon counts as the primary metric for rendering performance. As Jason Booth notes, this legacy thinking leads to excessive Level of Detail (LOD) models that cause visual popping, memory bloat, and artistic compromises. The reality? Modern GPUs don't render polygons – they process vertices and fragments.

"The cost of rendering pixels dwarfs vertices," Booth explains. "A 1080p screen with G-buffers and overdraw can compute 20 million pixels per frame versus relatively cheap vertex transformations."

MicroTriangles: The Real Performance Villain

The true rendering cost emerges at the rasterization stage, where GPUs process pixels in 2×2 blocks called quads. When triangles shrink below ~10×10 pixels, they become microtriangles that trigger catastrophic performance penalties:

  • A single-pixel triangle forces the GPU to process 4 pixels (the entire quad) but only outputs 1 valid pixel
  • Rendering cost increases exponentially as triangles shrink
  • Single-pixel geometry can be 40-80x slower than optimally sized triangles
// Simplified GPU rasterization logic
for each 2x2 pixel quad {
  if triangle covers ANY quad pixel {
    compute ALL 4 pixels
    discard uncovered results
  }
}

Practical Optimization Strategies

1. Wireframe Density Analysis

Artists should monitor wireframe views in modeling tools:
- Switch to lower LOD when wireframe nears "solid" density
- Unity's HDRP offers "Vertex Density" heatmap visualization

2. Impostor Overkill

For distant objects:
- Replace complex LOD chains with single optimized mesh
- Use impostors (billboard textures) beyond certain distances
- Reduces draw calls and eliminates LOD popping

The Nanite Revolution

Epic's Nanite fundamentally solves microtriangle inefficiencies through:

  1. Continuous LOD: Dynamically adjusts geometry to maintain ~1 triangle/pixel
  2. Compute-Based Rasterization: Offloads microtriangles to compute shaders
  3. Two-Pass Technique:
    • Lightweight first pass writes geometry IDs to screen buffer
    • Full fragment shading executes on unified screen-space quads

"Nanite avoids all MicroTriangle issues by doing heavy fragment work on large quads," observes Booth. This eliminates traditional LOD systems for compatible assets.

Performance Implications

  • Over-optimized LODs waste memory: 3-5 LODs for simple assets like rocks is counterproductive
  • Batch-breaking: Frequent LOD transitions disrupt GPU instancing
  • Art pipeline efficiency: Reducing LOD frees artists for higher-value work

As GPU architectures evolve, understanding actual rendering pipelines trumps historical polycount lore. Developers must shift focus to pixel efficiency and embrace compute-based solutions that sidestep rasterization bottlenecks.

Source: Jason Booth on Medium