[Algorithms] Multipass alpha-blended objects

[<we...@nc...>]

How do people generally handle complex (multipassed) alpha-blended 
objects
in their pipelines? Here is one common pipeline for a multipassed 
object:

/////// warm zbuffer ///////
zwrite: on
if (alpha-test)
    alpha: test, select shader that loads material alpha
else
    alpha: none, select NULL shader
end if
draw z/ambient pass

/////// draw diffuse ///////
zwrite: off, alpha: add
draw light diffuse passes

/////// draw material ///////
alpha: modulate
draw material pass

/////// draw additive ///////
alpha: add
draw additive passes

Obviously this doesn't work for alpha blended objects, because the
alpha-blend modes break down. I've generally used the following 
options, but
I don't like their drawbacks. What do other people do?

1. only support single-pass alpha objects.
    * Pro: no alpha-blend problems.
    * Con: severely limits the available complexity of alpha objects
2. pre-assemble all passes of alpha objects in offscreen buffer.
    Write material alpha to dest-alpha.
    Blit that quad with alpha-blend.
    * Pro: enables arbitrarily complex shaders
    * Con: requires expensive offscreen buffer and blits
    * Con: doesn't work well with MSAA
    * Con: requires a wildly different rendering pathway.
3. Special case all alpha-blending shaders
    * Pro: can work out multipass techniques for each case.
    * Con: restricts alpha-modes
    * Con: not friendly to data-driven pipelines

In my experience, the most complex shaders are invariably on the
alpha-blended ones, so it's actually more important to support complex
shaders for alpha-blended objects, but this requires offscreen buffer
assembling. Since most games support MSAA, I'm assuming they don't use
offscreen buffers. I don't really want to hard-code the alpha-
combinations
available to content creators.

Thanks,
Wes