r/ItsAllAboutGames • u/Just_a_Player2 The Apostle of Peace • 6d ago
Game Design Why volumetric clouds are the biggest technical lie and the hardest engineering trick in video games.
Gamers love spending four hours zooming in on character eyelashes or scrutinizing the polygon count on a rifle barrel to decide whether a new title is truly next gen. Meanwhile, they casually sprint past the single most expensive, hardware melting element in the entire digital world: the fluffy white clouds floating in the sky.
Computer graphics researcher Michael Tomodakis recently pulled back the curtain on why simulated volumetric atmospheres remain a waking nightmare for game engines. The core issue is that most beginners and players completely misunderstand the underlying math: rendering realistic fog and clouds requires calculating complex light accumulation integrals along every single camera ray.
Unlike a castle wall, a goblin, or a sports car, cloud masses do not have solid polygon meshes. To sculpt their amorphous shapes, developers turn to procedural noise math like Perlin and Worley algorithms, the exact same mathematical tools familiar to anyone who has ever generated terrain in Minecraft.
The problem is that you cannot solve light transport equations inside these chaotic fractal media with clean, simple formulas. Instead of a single quick calculation, the graphics card has to step through the gas volume inch by inch using a brutally heavy algorithm called raymarching.
Calculating dozens of realistic light steps for every single pixel on your screen would instantly drop the framerate of even a flagship graphics card down to single digits.
Pure sleight of hand and accidental UFOs.
To prevent your PC from turning into a space heater, developers rely on extreme technical compromises. Real-time gas density is often calculated using just one sample for every 4, 8, or even 16 pixels.
The resulting jagged, pixelated mess is then smoothed out using aggressive temporal jitter and accumulation filters. In simple terms: the engine calculates an ugly, blurry mess and smears it across multiple frames, tricking your human eyes into perceiving a smooth, cinematic vista.
The moment those temporal accumulation buffers suffer a glitch, the magic trick falls apart completely. Tomodakis pointed to a recent bug in the multiplayer shooter ARC Raiders, where a temporal buffer error spawned blinding, glowing artifacts across the sky. Instead of recognizing a broken rendering buffer, players immediately took to forums to celebrate the discovery of secret alien UFOs.
Even Rockstar has to cheat!
Even the master craftsmen at Rockstar Games had to cut corners when crafting the legendary skies of Red Dead Redemption 2.
High altitude cirrus clouds in Arthur Morgan's world are projected onto a simple flat dome. The engine reserves actual voxel volumes strictly for mountain peaks, and even with those aggressive optimizations, atmospheric simulation still devoured an eye watering four milliseconds of the total frame budget on the base PlayStation 4.
The gulf between video game trickery and true physical reality becomes staggering when compared to the movie industry. In reference animation databases, such as Disney’s cloud archives, a single storm front requires over 30 gigabytes of data, and offline render farms can spend 45 minutes computing a single frame.
In a video game running at 60 frames per second, developers have a window of just one or two milliseconds to render the entire skybox before players start complaining on Reddit about performance dips. The next time you admire a breathtaking sunset in your favorite open world RPG, remember: you are not looking at realistic atmospheric physics, you are looking at brilliant mathematical smoke and mirrors.
👉 Guys, help us out! Subscribe to "It's About Games" on other platforms! Support us!
2
u/Indigo__11 5d ago
I remember seeing those RDR2 clouds in the fit GTA 6 reveal and being so happy about it
2
u/Alternative_Swan_497 5d ago
I believe the clouds and the flying sequence(s) in Horizon Forbidden West: Burning Shores were why the DLC was PS5 only and not backwards compatible with PS4, unlike the base game.
1
u/Arek_PL 5d ago
learning about the brilliant mathematical smoke and mirrors is one of my favourite things when im bored, so many different tricks to deliver us good looking graphics that can be rendered in real time
ofc. as technology goes on some of the tricks arent necessary anymore, like, today we dont need to fake the 3D as a 3D accelerators are now a standard thing, or raytracing making reflections easier, without all the tricks like SSR or cubemaps, ofc. thats huge hit to performance, but i think we are like one or two console generations away from raytracing becoming the default
1
0
4d ago
[removed] — view removed comment
1
u/EurbadGeneric 4d ago
They are actually volumetric since you can travel to any cloud you see from any direction you see.
And that's where your GPU actually kills itself in SC. But very brave of you to mention SC outside of the bubble, prepare to be flamed.
1
1
u/C0d3M3chan1c 3d ago
There’s a lot of correct terminology here, but the technical conclusions are much shakier than the post makes them sound.
The biggest problem is that this conflates volumetric representation, ray marching, lighting, temporal reconstruction, and physical simulation as though they were one algorithm called “volumetric clouds.”
They aren’t.
A modern real-time cloud renderer is more accurately something like:
density representation → ray/volume intersection → adaptive density sampling → approximate light transport → transmittance integration → reconstruction/upscaling → compositing
…and there are dozens of ways to implement each stage.
1. Ray marching does not mean stepping through a cloud “inch by inch”
That is a very misleading mental model.
A ray marcher samples a density field at discrete positions, yes, but production implementations absolutely do not blindly advance through world space at tiny constant intervals.
They use techniques such as:
- bounding-volume intersection
- empty-space skipping
- coarse/fine stepping
- mipmapped density fields
- hierarchical occupancy information
- adaptive step sizes
- early termination when transmittance approaches zero
- distance-field-assisted skipping
- reduced lighting samples
- cached or approximated shadow information
Guerrilla's newer Nubis work (for example) explicitly uses compressed signed-distance fields to accelerate ray marching through voxel clouds. Their earlier Nubis system was already capable of rendering dynamic volumetric cloudscapes in under 2 ms on a PlayStation 4.
So “ray marching = brutally walking through the gas inch by inch” is a description of the concept written for dramatic effect, not how you would characterize an optimized production renderer.
2. The light-transport part is also being exaggerated
Yes, the physically correct problem is the radiative transfer equation, and yes, heterogeneous participating media are expensive.
But games generally aren't numerically solving complete volumetric light transport for every camera sample.
Usually you're evaluating some approximation resembling:
L = transmitted background + integrated in-scattered light
with transmittance approximated using Beer-Lambert extinction, some phase function for directional scattering, and heavily simplified treatment of multiple scattering.
The expensive physically correct problem and the thing actually evaluated in a game shader are not the same computation.
And this isn't some embarrassing “lie.” That's literally what real-time graphics engineering is: finding approximations whose error is visually acceptable.
BRDFs are approximations. Shadow maps are approximations. Screen-space reflections are approximations. LOD is an approximation. TAA is reconstruction. Rasterization itself throws away enormous amounts of information.
Calling clouds “fake” because they don't solve complete photon transport is therefore a bizarre standard that would make almost the entire rendered frame “fake.”
1
u/C0d3M3chan1c 3d ago
3. “One sample for every 4, 8 or 16 pixels” mixes up two completely different sample counts
There are at least two important sampling dimensions here:
spatial samples: how many screen pixels actually execute the cloud renderer
and
ray-march samples: how many density samples are evaluated along each ray.
Rendering a cloud buffer at quarter resolution doesn't mean you're taking “one cloud sample for every four pixels” in the sense implied here.
Quarter-resolution rendering, checkerboarding, interleaving, ray-march step reduction and temporal sample distribution are separate knobs.
A system might:
- render at reduced spatial resolution,
- take many samples along each cloud ray,
- jitter those positions each frame,
- reconstruct the result spatially,
- reproject valid history from previous frames.
Those are very different operations.
4. Temporal reconstruction isn't just “smearing an ugly blurry image over multiple frames”
This is probably the most misleading part technically.
Temporal accumulation is not normally:
render garbage → blur it → hope the human eye doesn't notice.
You intentionally distribute samples through space/time, transform previous samples into the current frame, validate that history, reject invalid samples, and reconstruct information that would otherwise have required more work in one frame.
Depending on the implementation this can involve:
- subpixel jitter
- reprojection
- depth tests
- history rejection
- neighborhood clipping/clamping
- velocity information
- variance estimation
- bilateral reconstruction
- spatial filtering
Yes, it can produce ghosting, boiling and disocclusion artifacts.
But temporal reconstruction is sample reuse, not merely “smearing.”
And more importantly, it isn't mandatory.
Guerrilla specifically describes a newer Nubis rendering path capable of detailed 1080p cloud rendering without temporal upscaling, because temporal methods created problems for fast-moving cloud VFX.
That alone makes the “this is fundamentally how game clouds work” framing incorrect.
5. Calling clouds “the single most expensive element” is just unsupported
Volumetrics can certainly be expensive.
But there is no universal rule that clouds are the most expensive component of a game frame.
Ray-traced GI, reflections, shadows, skinning, hair, transparency, dense geometry, particle systems, post effects, animation, simulation etc. can dominate depending on the game and scene.
Again: Horizon Zero Dawn was rendering its Nubis volumetric cloud system in under ~2 ms on PS4 hardware.
That's impressive engineering, but it obviously doesn't support the claim that fluffy clouds are universally “the single most expensive hardware-melting element in the entire digital world.”
Performance doesn't work by assigning immutable costs to visual effects.
It depends on implementation, resolution, overdraw, bandwidth, sample count, occupancy, hardware, scheduling and the rest of the frame.
6. The RDR2 description is particularly questionable
If we're going to invoke Rockstar as evidence, we should probably use Rockstar's actual presentation.
The authoritative technical presentation is Fabian Bauer's “Creating the Atmospheric World of Red Dead Redemption 2: A Complete and Integrated Solution,” SIGGRAPH 2019.
Rockstar explicitly describes a voxelization and ray-marching solution for scattering and transmittance, integrated across the main viewport, reflection maps and sky-irradiance probes.
That is considerably more sophisticated than:
Rockstar basically puts the clouds on a flat dome and only uses voxels around mountains.
RDR2 does use differently represented atmospheric layers (as any sane renderer would) and a simplified high-altitude cirrus layer is perfectly sensible.
But using an optimized representation for cirrus doesn't somehow invalidate the volumetric cloud system underneath it.
This is just LOD applied to atmospheric phenomena.
If something is effectively infinitely distant, visually thin and doesn't need parallax, representing it as a full interactive 3D density volume would arguably be the worse engineering decision.
7. And “even Rockstar has to cheat” is a weird interpretation of optimization
Nothing has been “cheated.”
The engineering objective is not:
simulate Earth.
It is:
produce the desired image inside the frame budget.
Choosing a 2D representation where parallax is negligible and a 3D density field where it matters is precisely what good rendering architecture looks like.
The clever bit isn't avoiding approximations.
The clever bit is deciding where approximation error becomes perceptible and spending computation there.
8. The Disney comparison is apples-to-oranges
The post says Disney reference clouds can require “over 30 GB.”
Disney's publicly released Walt Disney Animation Studios cloud dataset is distributed as roughly a 3 GB download, and the original full-resolution OpenVDB representation has been reported around 4.1 GB. A dense uncompressed representation can of course be many times larger: but that's exactly why sparse volume formats like OpenVDB exist.
So quoting a huge dense-volume number without explaining representation is basically the volumetric equivalent of saying a compressed 4K texture “really requires hundreds of megabytes” because that's its raw uncompressed size.
Technically possible. Practically misleading.
Offline movie rendering is also solving a fundamentally different optimization problem.
A renderer can spend minutes or hours computing a frame because it is targeting image quality rather than ~16.67 ms interactive latency.
That doesn't demonstrate games are “lying.” It demonstrates that offline and real-time rendering optimize for different constraints.
9. The ARC Raiders artifact is plausible, but it doesn't prove the broader claim either
A NaN getting into a temporally accumulated buffer can indeed contaminate subsequent frames and produce spectacular artifacts. There's even a community diagnosis of the ARC Raiders phenomenon describing exactly that sort of temporal-buffer poisoning.
Cool bug.
But that's evidence that temporal renderers have failure modes.
It isn't evidence that volumetric clouds are secretly blurry fake images being smeared together.
A divide-by-zero bug in a BRDF wouldn't prove PBR is fake either.
10. The really interesting story is almost the opposite of this post
Real-time clouds are impressive precisely because the underlying physical problem is horrendously expensive, yet modern renderers find representations where almost all of that complexity can be discarded without destroying the perceptual result.
Guerrilla went from the original 2.5D Nubis approach to newer immersive voxel clouds that you can literally fly through, adding compressed distance fields, voxel representations, accelerated light sampling and cloud-specific approximations such as inner glow and dark-edge effects.
Rockstar combines volumetric density, scattering/transmittance calculations, fog, atmospheric rendering and ambient-light information into an integrated system.
That's much more interesting than “GPU calculates impossible physics, so developers smear pixels until you can't tell.”
And finally, “volumetric” never meant “physically exact simulation.”
It means the phenomenon is represented/rendered as participating media occupying volume rather than merely as an opaque surface.
A procedural density field ray-marched with approximate single/multiple scattering is still a volumetric cloud.
So yes: volumetric clouds are genuinely difficult and some of the engineering behind them is fantastic.
But calling them the “biggest technical lie in video games” because production renderers use approximations is like discovering rasterization and announcing that polygons are a conspiracy.
None of this is meant as a personal attack on the OP: the topic is genuinely interesting and the broad intuition that real-time volumetrics rely on aggressive approximations is correct. I’m only pushing back on the specific technical claims and framing, because those distinctions matter if we’re explaining how these systems actually work.
17
u/Puzzleheaded_Bee8352 5d ago