For effects like smoke or water, a fluid simulation and rendering approach is needed. There are currently two popular methods for this:

1. Simulate the fluid on the CPU and send the result as particles to the GPU for rendering as billboards. This is often called a particle system. The technique has been around since the dawn of computer graphics.

2. Simulate the fluid on the GPU and render the result into textures. This will then be rendered by doing volume ray casting (or ray marching) on the GPU. This technique is new and rather unexplored, and there are few real-life implementations. The result can be very realistic but slow.

Technique one burdens both CPU, bandwidth and GPU. Although in modern solutions, it’s the bandwidth that’s the bottleneck. The GPU based technique only burdens the GPU ( but a lot ).

The movie shows the GPU method of fluid simulation and rendering. More info about this particular implementation in the two last links.

Building an Advanced Particle System
http://www.mysticgd.com/misc/AdvancedParticleSystems.pdf
Building a Million Particle System
http://www.2ld.de/gdc2004/MegaParticlesPaper.pdf
Real-Time Simulation and Rendering of 3D Fluids
http://http.developer.nvidia.com/GPUGems3/gpugems3_ch30.html
The previous page’s authors homepage:
http://www.cs.caltech.edu/~keenan/project_fluid.html

When doing a particle system one must decide what type of geometry to send to the GPU. In other words, what vertices. It’s also important to decide where and when to transform the geometry to screen space for rasterization.

It have been standard to use quads (sometimes just single triangles) as representation for particles. These quads are usually billboarded to the screen which requires additional work. There also exist a technique called point sprites that allows one to render a simple billboarded image by just sending a single vertice for each particle to the GPU , compared to at least four when doing quads (and maybe also indices). This sprite will be scaled by the distance accordingly to a formula that can be tweaked. It’s easy to translate it (it’s the position of the vertex itself) but it’s not so easy to rotate it. Rotation would need a special fragment shader that does the rotation manually.

Sprites can reduce the bandwidth usage a lot, at the cost of increased complexity in the fragment shader. Also, quads allows more possibilities, for example stretching. Which method is faster depends on where the bottleneck is in the rendering pipeline.

The movie above shows an example of a particle system.

Reference to the paperBuilding a Million Particle System:
http://www.2ld.de/gdc2004/MegaParticlesPaper.pdf

Some old info about point sprite based particle engines:
http://www.gamedev.net/reference/articles/article2002.asp

Instead of rendering textured billboards, this technique called “Mega Particles” render spheres to an off-screen texture. This texture is then blurred and randomly displaced using a fractal cube. The final result is carefully blended into the scene, taking depth into account. The result is a volumetric cloud that is lit by lighting and truly look volumetric. The problem is that this technique suffers from the shower-door effect which can make it really annoying to use in practice. It’s also harder for artist to control the final look. Also, going inside the cloud requires special treatment not even mentioned in the slides. But nevertheless, it’s an interesting approach that certainly can be developed furthered. At least one optimization could be to not render actual spheres, but instead billboards holding the sphere info.

http://www.inframez.com/events_volclouds_slide01.htm