Deferred Shading

"Lights, in this article, are point lights with a finite range, beyond which they do not

contribute any lighting. Thus, when we refer to the light volume, this is the spherical

volume defined by the light position and influence radius. This is obviously not physically

correct, but represents a very common type of lights in real-time applications.

The techniques presented can be applied to arbitrary kinds of lights, but this is beyond

the scope of this article.

In the literature it is not always clear what is meant by Deferred Shading. In this

article we mean the technique whereby all required geometry attributes are rendered

into Geometry Buffers (G-Buffers [ST90]), in a single geometry pass. The G-Buffers

contain attributes such as position, normal and material properties for each pixel. This

is followed by a lighting pass, during which the lights are applied one at a time by rasterizing

the light volumes. Note that this is different from Deferred Lighting [AA03],

which only performs light computations in the deferred pass and adds a separate geometry

pass to compute final shading. This technique is also referred to as Light Pre-pass

Rendering [Eng09]. As deferred lighting has the same basic characteristics as deferred

shading, we do not evaluate this technique in this article.

We use the term Forward Shading to mean when lighting is computed in the fragment

(or sometimes, vertex) shader as part of the rasterization of the scene geometry.

This technique is probably still the most common in real-time applications, such as

games."

"The Tiled

Deferred Shading algorithm is summarized in the following steps.

1. Render the (opaque) geometry into the G-Buffers.

2. Construct a screen space grid, covering the frame buffer, with some fixed tile

size, t = (x, y), e.g. 32 × 32 pixels.

3. For each light: find the screen space extents of the light volume and append the

light ID to each affected grid cell.

4. For each fragment in the frame buffer, with location f = (x, y).

(a) sample the G-Buffers at f.

(b) accumulate light contributions from all lights in tile at ⌊f/t⌋

"Deferred shading renders the scene to a 'fat' texture format, using a shader that outputs colour, normal, depth, and possible other attributes per fragment. Multi Render Target is required as we are dealing with many outputs which get written into multiple render textures in the same pass. After rendering the scene in this format, the shading (lighting) can be done as a post process. This means that lighting is done in screen space. Adding them requires nothing more than rendering a screenful quad; thus the method allows for an enormous amount of lights without noticable performance loss."

For more info, I've included these links as a starting point.

http://c0de517e.blogspot.com/2011/01/mythbuster-deferred-rendering.html

http://en.wikipedia.org/wiki/Deferred_shading

http://s09.idav.ucdavis.edu/talks/04-JAndersson-ParallelFrostbite-Siggraph09.pdf

http://tower22.blogspot.com/2010/11/from-deferred-to-inferred-part-uno.html

http://aras-p.info/blog/2012/03/02/2012-theory-for-forward-rendering/

http://software.intel.com/en-us/articles/deferred-rendering-for-current-and-future-rendering-pipelines

http://graphicrants.blogspot.com/2012/04/tiled-light-culling.html

http://www.catalinzima.com/tutorials/deferred-rendering-in-xna/creating-the-g-buffer/

http://tomgillen.blogspot.com/2010/07/gbuffer-layout.html

http://www.gamedev.net/page/reference/index.html/_/technical/graphics-programming-and-theory/deferred-rendering-demystified-r2746

http://developer.amd.com/wordpress/media/2012/10/D3DTutorial_DeferredShading.pdf