Large models and scenes

What the engine does with a Sponza-size level, where its frame time goes per quality tier, and the settings that decide whether it runs well.

Last updated Nov 4, 2026Edit this pageVersion 1.0.0

A level the size of the Intel Sponza (2022, with the Curtains and Ivy add-ons: about 10.8 million triangles in 450 submeshes and 80 4K PBR textures) runs on the same renderer as a small one. On a mid-range GPU its frame time is decided by the quality tier and the resolution far more than by the size of the meshes. This page shows where the time goes and what the engine does so the geometry itself stays cheap.

What the engine does with a big model

  • Static meshes are drawn by the GPU. Every static, opaque mesh joins the GPU scene: its vertices and indices are copied once into a shared geometry pool, the GPU culls the instances against the frustum and the previous frame's depth, and all meshes that share a material draw with one indirect call. The pools grow with the level, a pool at a time, so a large level stays on this path. Their total size is capped by r.GpuScene.GeometryPoolBudgetMB (by default an eighth of the GPU's memory, between 256 and 2048 MB); a mesh that no longer fits is drawn on its own and the log says so once. A mesh your game builds while it runs skips the second copy: see Meshes built at runtime.
  • Textures are block-compressed. An imported texture reaches the GPU as a BC chain with all its mips — BC7 for colour, BC5 for normal maps, BC6H for HDR — as the packaged game ships it. A 4K map takes 21 MB instead of the 85 MB it took uncompressed; on the Sponza that is the difference between 8.5 GB of loaded assets, past what an 8 GB card holds, and a level that fits. An author who sets a texture's compression to none keeps it uncompressed.
  • The first open cooks, later opens read the cache. The first time the editor opens a level it compresses every texture into the project's Derived Data Cache on all CPU cores, in the background: the level is usable at once, untextured surfaces fill in as their maps land, and the status bar counts the assets still importing. On the reference machine the Sponza's 80 textures cook in about a minute; every later open reads them from the cache.
  • Entering Play does not stall on the level's size. The sound occlusion and the scanner build their own copy of the level's triangles on a worker thread.

Where the milliseconds go

The Sponza in Play at 1920×1080, the level's cinematic camera flying through the nave, Global Illumination on, measured on the reference RTX 3050 (8 GB) with a development build, nothing else compiling. Auto is the Auto upscaling mode (r.Upscaler.AutoQuality 1, Quality at 1080p), native renders every pixel.

TierAutoNativeGPU frame (Auto)Largest passes (Auto, ms)
Low250 fps147 fps4.4 msG-buffer 1.3, post-processing 0.8, transparency 0.6
Medium110 fps55 fps9.6 msGI sampling 1.8, post-processing 1.6, GI denoise 1.4, upscale 1.3
High78 fps44 fps13.2 msGI sampling 3.3, shadows 2.3, transparency 1.4, GI denoise 1.4, SSR 1.4, G-buffer 1.1
High, GI off121 fps70 fps8.6 msshadows 1.8, G-buffer 1.7, SSR 1.3
Epic32 fps16 fps*31.6 msGI sampling 8.2, shadows 5.0, ray-traced GI gather 4.0, reflections 4.2 (screen trace 0.5, ray-traced world leg 2.8)
Cinematic19 fps11 fps44.9 msGI sampling 7.9, SSR 7.1, volumetric fog 6.1, ray-traced sun shadow 6.0, GTAO 5.1, RTAO 4.5
High at 2560×144051 fps23 fps19.8 msGI sampling 4.9, shadows 3.9, SSR 2.2

* Measured before Epic traced its screen-space reflections at half resolution, as High does: that cut the reflection passes from 7.9 to 4.1 ms (Auto 27-30 fps before, 32 after) with an image inside the noise of two full-resolution captures of the same view.

Drawing the geometry — the G-buffer pass with its culling — costs about 1 ms of a High frame. The meshlet G-buffer (Epic and up) did not lower it on the Sponza: forced on at High it drew the level in the same 1.2 ms, but at that time its cluster pool held only 38 of the level's 446 meshes, so High keeps the classic indirect draws (see Very dense meshes on Epic). The rest is lighting: Global Illumination, shadows and screen-space reflections, all of which scale with the number of pixels and with the tier. So:

  • Epic and Cinematic are not for a mid-range GPU. They add ray-traced and SDF features whose cost on a 3050 is three to four times High's whole frame. On such a card use High or Medium.
  • Render fewer pixels. Auto upscaling roughly doubles the frame rate at every tier for little visible loss; native rendering on a mid-range GPU is the most expensive single choice after the tier.
  • Global Illumination is the largest single cost on High (about 4.6 ms of 13.2). A project that does not need dynamic indirect light can turn it off in Project Settings.

Very dense meshes on Epic

On Epic and Cinematic, static meshes with an import-built cluster hierarchy draw through the meshlet G-buffer: the GPU picks, per cluster, the coarsest level whose error stays under a pixel and culls clusters against the frustum and the previous frame's depth. Two things decide whether a large level gets that benefit:

  • The cluster pool grows with the level. It starts at about 63 MB. When it is full of meshes that are all still on screen, the arena that ran short doubles at the start of the next frame and the meshes come back with their page layouts. It never grows past r.Meshlet.PoolBudgetMB (by default a sixteenth of the GPU's memory) and never into the last tenth of the GPU's memory budget, so a level that already fills the card keeps the classic path for what does not fit instead of running out of memory. Before, the pool stopped at 65 536 clusters; the Intel Sponza fit 38 of its 446 meshes.
  • Page layouts are built on worker threads. The first frame that draws a mesh used to build its page layout on the render thread; the mesh now draws through the classic path for the frame or two until a worker has it ready.

A synthetic field of 32 unique rocks (4.7 million unique triangles, 18.9 million submitted, the huge-scene-test row) at 1920×1080 on the reference RTX 3050, development build, nothing compiling:

GPU frameG-bufferShadowsWorst CPU frame while meshes arrive
Classic indirect draws28.9 ms8.6 ms17.7 ms—
Meshlet, pool fixed at 63 MB (18 of 32 rocks)9.0 ms3.5 ms2.7 ms—
Meshlet, pool grown to 128 MB (all rocks)5.5 ms1.1 ms0.8 ms24 ms (202 ms with layouts built on the render thread)

On Vulkan the same field takes 30.2 ms classic and 8.1 ms on the grown pool. The pool's growth cost 66 MB of VRAM here.

The Sponza on Epic is the opposite case: on an 8 GB card it already uses about 98 % of the VRAM budget, so the pool stops growing at 124 MB and the rest of the level keeps the classic path. Letting it grow to 328 MB there took the frame rate from 24 to 9 fps, which is why growth reads the live budget.

A pool that is full and still asked for more (a big level, a fast camera) evicts and admits meshes every frame. Before November 2026 that could shred meshes: each page-in's vertex gather read its page table from an upload buffer that the next eviction, or the next frame, had already rewritten, so the gather filled the wrong slices. Every frame now writes its own tables, and the meshlet-pool-churn-test row reads the whole pool back while groups of meshes churn through it on D3D12 and Vulkan: 1.2 million of 1.8 million checked vertices were wrong before the fix, none after.

The pool ages a mesh by frames the GPU has finished with, not by views drawn. A renderer that draws several views in one frame (a viewport with a scene capture, a split view) used to count each view as a frame, so a mesh's slices came back for reuse after a single GPU frame while the previous frame was still reading them. Eviction and the retire queue now follow the device's frame counter; the meshlet-pool-churn-test row runs its churn again with three views per frame and no idle between frames.

Cluster pages from disk: not yet

The cluster hierarchy of every mesh still lives in system memory once the mesh is loaded (179 MB for the Sponza), and the pool pages from that copy. Paging it from the cooked package is designed (the engine's internal notes hold the design) and not shipped: it needs a cook chunk of page-ordered payloads, a page source behind the pool, and asynchronous reads with a byte budget per frame. A package cooked today keeps working unchanged when it lands, because the new chunk is optional and the pool builds a layout at run time for a package without it. It was not built because no measured level needs it yet: the Sponza's cluster data is 2 % of the editor's working set on Epic, and the pool, not the system copy, is what limits large levels on an 8 GB card.

Many small meshes

A voxel world is thousands of small meshes, one per chunk, each its own entity with a Mesh Renderer, edited and re-meshed all the time. The voxel-chunk-scale-test row (RendererTests) measures exactly that: 1 024 to 8 192 chunk entities of about 1 000 triangles in a 32×32 grid, one shared material, drawn through the same path a level takes (scene gather, instancing plan, GPU culling, cascaded shadows), on the reference RTX 3050 at 1280×720 with a development build and nothing else compiling. Milliseconds of CPU per frame for the game and render side together:

Chunk entities1 0242 0484 0968 192
Nothing changes1.72.64.17.5
5 % change transform every frame2.03.04.810.4
5 % swap mesh every frame1.82.84.69.3
20 % change transform every frame2.74.38.014.4
Camera orbiting2.74.58.016.2
200 chunks created and destroyed per second3.24.77.014.0
GPU frame, nothing changes2.42.93.95.2
  • Vulkan and D3D11 are in the same range: 8 192 still chunks cost 8.9 ms on Vulkan and 6.4 ms on D3D11, and with a moving camera 11 ms and 20 ms. Run under the validation layers (--gpu-validation) the same frame takes about twice as long.
  • The cost is linear in the number of chunks: about 0.8 ms plus 0.85 µs per chunk when nothing changes. The scene already keeps what a static chunk needs between frames (the render proxies, the draw commands, the instancing plan and the GPU scene slots), so a chunk that does not change costs its gather, its draw record and its hash, not a rebuild. Changing 1 % to 5 % of the chunks adds under 3 ms at 8 192; a stream of fresh meshes costs the mesh creation (0.23 ms each) on top.
  • Memory runs out before the CPU does. A 1 000-triangle chunk takes about 0.5 MB of VRAM (its own buffers and its copy in the geometry pool) and 60 KB of system memory; a 2 000-triangle chunk about 0.9 MB. 8 192 chunks of 1 000 triangles fill 6.2 GB of the card's 8.
  • A moving camera is the most expensive change, because every cascade of the sun's shadow redraws the chunks it reaches when the camera slides it; see Shadows.
  • Background jobs no longer stall the frame. A frame that renders 4 096 chunks while 5 ms background jobs run on every worker took 26 ms (59 ms at worst) before the engine capped the workers background jobs may hold; it takes 6 ms now.

The row judges the still scene, 5 % transform changes, 5 % mesh swaps and the 200 per second churn against bars of the form base + per-chunk cost × chunks with 30 to 50 % of headroom over these numbers, so a change that makes the per-chunk path slower fails it. The goal for a voxel world is 4 ms of CPU for 8 192 still chunks; today's 7.5 ms is above it, and the remaining time is spread over the passes (scene gather 15 %, G-buffer 30 %, shadows 15 %, instancing plan 13 %) rather than in one place. --chunk-sizes=<list>, --chunk-tris=<n> and --chunk-frames=<n> change the experiment.

Check your own settings

The editor keeps the tier and upscaling mode you pick in your user settings, and they apply to every project you open. If a level runs far slower for you than the table above, check the Quality preset and the upscaling mode you saved: Epic with native rendering costs a 3050 about five times what High with Auto costs. On a GPU with less than 10 GB of memory the Quality card and Project Settings > Scalability say so under Epic and Cinematic, with the rate the reference card measured.

To see the numbers for your own level, enable stat.FrameStats 300 in the console: every 300 frames the log lists the CPU frame, the GPU frame and every GPU pass with its time.

Settings

Console variableDefaultWhat it does
r.GpuScene.GeometryPoolGrowth11 adds a geometry pool when a mesh does not fit; 0 keeps one fixed pool per index width and draws the rest one by one (for comparison)
r.GpuScene.GeometryPoolBudgetMB0Total size of the geometry pools in MB; 0 = an eighth of the GPU's dedicated memory, 256 to 2048 MB
r.Texture.PackageNativeBc1Upload a texture as its block-compressed chain; 0 decodes it and compresses it while it loads
r.Meshlet.PoolBudgetMB0Most VRAM the meshlet cluster pool may grow to, in MB; 0 = a sixteenth of the GPU's dedicated memory, 64 to 1024 MB; 64 or less keeps the starting pool. Growth also stops short of the last tenth of the GPU's memory budget
r.Meshlet.AsyncLayouts1Build a mesh's meshlet page layout on a worker thread the first time it is drawn; 0 builds it on the render thread (for comparison)
r.MeshletResidencyStats0Every N frames log the meshlet pool's residency, capacity, rejections and the system memory the meshes' cluster hierarchies hold
job.BackgroundWorkerReserve3Workers kept free of background (Low priority) jobs; they hold at most all but this many at once. 0 lifts the cap

Engine sources

This page describes behavior implemented in these files of the engine repository, checked against commit Infinity.

  • Engine/Source/Runtime/SceneRenderer/Public/Renderer/SceneRenderer.h
  • Engine/Source/Runtime/Renderer/Public/Renderer/GeometryPool.h
  • Engine/Source/Runtime/Renderer/Public/Renderer/MeshletPool.h
  • Engine/Source/Runtime/AssetSystem/Public/AssetSystem/ImageDecode.h

Page feedback

Was this page helpful?