LODs, Draw Calls & Culling

A draw call is one instruction from the CPU to the GPU: 'draw this mesh, with this material, at this position.' Each one has fixed overhead on the CPU draw thread regardless of how many triangles it carries. So a scene of ten thousand tiny, individually placed objects can drown the CPU in draw calls while the GPU sits half-idle - the classic CPU-bound-on-Draw signature from stat unit. Reducing draw calls is the highest-value optimization in most archviz scenes.

The first lever is instancing. When the same mesh appears many times - 500 identical chairs, a facade of repeated mullions, a car park of bollards - an Instanced Static Mesh (or Hierarchical Instanced Static Mesh, which adds culling and LODs) lets the CPU describe the mesh once and hand the GPU a list of positions. Five hundred draw calls become one. The pixels on screen are identical; the CPU just stops repeating itself. Unreal will auto-instance identical static meshes in many cases, and the Foliage tool instances by design.

The second lever is merging. Different meshes that will never move - a cluster of fixed props, an architectural assembly - can be combined with Merge Actors into a single mesh with a shared material, turning many draw calls into few. The trade is flexibility: merged geometry moves and culls as one unit, so you merge things that genuinely belong together. A third quiet lever is shared materials - each unique material on a mesh is typically its own draw call, so a mesh with eight materials costs more than one with two. Consolidating materials and using texture atlases pulls the count down. Reach for stat rhi after each of these moves and watch the draw-call number fall - it turns an abstract technique into a figure you can see dropping, which is the fastest way to build an instinct for what each lever is worth.

The cheapest object to render is the one you never draw. Culling is the family of tricks that skips geometry the camera cannot actually see, and Unreal does several kinds automatically - your job is to help them work well.

Frustum culling drops anything outside the camera's field of view - the view frustum, the pyramid of what the lens can see. Look north and the building behind you is not drawn. This is automatic and nearly free. Occlusion culling drops what is inside the frustum but hidden behind something else - the furniture in the next room, blocked by a wall. Unreal computes occlusion each frame, and it works best when big solid occluders (walls, floors, slabs) genuinely block the view; a scene modelled as a hollow shell with gaps lets the engine see - and draw - everything behind it. Distance culling (via a Cull Distance Volume or per-object max-draw-distance) simply stops drawing objects past a set distance, ideal for small clutter that is invisible from far away - you will never see the drawer handles from across the plot, so stop drawing them at thirty metres.

The practical craft: model solid occluders rather than paper-thin hollow shells so occlusion culling has something to work with; set sensible cull distances on small props; and remember that in a wide-open scene with long sightlines, culling helps less, so you lean harder on LODs and instancing. Culling and drawing are two sides of the same budget - every object culled is time handed back to the frame.

For every mesh that is not a Nanite mesh - foliage, translucent surfaces, animated geometry, or anything on the classic path - Levels of Detail remain the workhorse. An LOD chain is a set of progressively simpler versions of a mesh; the engine swaps to a lower one as the object shrinks on screen, because a chair fifty metres away does not need its full triangle count to look right. Unreal can auto-generate LODs from a source mesh, or you can import your own.

The controls that matter are the screen sizes (how small the object must appear before each LOD kicks in) and managing the LOD pop - the visible snap when one level swaps to the next. Set switch distances too aggressively and viewers see geometry visibly simplify; set them too generously and you carry detail you are paying for and cannot see. Dithered transitions soften the pop. For whole clusters of buildings or props, Hierarchical LOD (HLOD) goes further: it merges distant groups of actors into a single low-detail proxy mesh, cutting both triangles and draw calls for far-off parts of a large scene at once.

Getting LODs right is a small craft of its own. Unreal's auto-LOD generation is a fine starting point - you set a number of levels and reduction percentages and let it decimate - but for hero foliage or a signature piece you may import hand-made levels that hold silhouette better. Watch the triangle percentage each level keeps and the screen size at which it activates, and always test by flying the camera the way a viewer actually will: a level that looks fine in a static shot can pop distractingly during a smooth walkthrough. Dithered or temporal transitions blend the swap so the eye never catches it.

Remember the division of labour from earlier in this module: Nanite gives you continuous, automatic LOD for opaque static geometry, so you do not author LOD chains for it. LODs and HLOD are for everything Nanite does not cover, plus for platforms or projects where you are not using Nanite. Knowing which mesh belongs in which system is exactly the judgement this module is building, and it is the difference between an artist who blanket-applies one recipe and one who reaches for the right system per mesh.

Geometry is not the only budget. Texture streaming manages video memory (VRAM) by keeping high-resolution textures on disk and loading only the mip level - the resolution - a surface needs at its current on-screen size. A 4K wood texture on a distant floor is streamed in at a low mip; walk up to it and the high mip loads. This keeps VRAM from overflowing, which matters enormously in texture-heavy interiors and doubly in VR, where memory is tight. When you see textures visibly 'pop' from blurry to sharp, or the console warns of a streaming pool over budget, you are watching the streamer work - raise the pool size (r.Streaming.PoolSize) if you have VRAM to spare, or reduce texture resolutions if you do not.

Now put it together as a routine, driven by the profile rather than by habit. If stat unit says CPU-bound on Draw, attack draw calls first: instance the repeated meshes, merge the fixed clusters, consolidate materials, and let HLOD collapse distant groups. If GPU-bound, lean on culling (solid occluders, cull distances), LODs (tighter screen sizes), lighter shadows and translucency, and texture streaming for VRAM. Always change one lever at a time and re-measure with stat unit and stat rhi, watching the draw-call and triangle counts fall. This measured loop - diagnose, apply the matching lever, verify - is how a heavy building that crawled becomes a smooth, walkable experience, and it is the same loop VR will demand at double the intensity in the next lesson.