Blender renders transparency currently by defining an "Alpha" value (opacity), where zero alpha means 100% transparent. The alpha value defines the blending function for how much a pixel covers another pixel.
This is a convention from image processing, and suited well the old pixel-based scanline render system in Blender.
For many 'real' transparent materials however - like glass - the material color should not blend with what is behind (or with light or rays) but should apply a filter as well. This operation is actually a multiplication, not blending, with for example a transparent Red material (RGB: 1, 0, 0) blocking all green and blue.
To define such a filtering, two approaches exist:
The first choice allows for creative freedom, but has the disadvantage that you not only have to mix a new RGB color to define a filter, but also have to apply to the filter the same texture as in use for the Material itself. Further this method excludes alpha itself, which is basically a totally different operation.
The Povray example is weird too... the choice for simple addition of alpha and filter easily gives impractical overflows, and is certainly not a quick method for users to edit.
Good however is that regular alpha still plays a role, and this method can be added with backwards compatiblity.
While testing various methods, it appeared to me that the most logical choice is to define a single new Filter value, which only operates on the transparent part of the alpha mixing operation.
Setting Filter at 0.0 "transmits" the background color (or light) unaltered through a Material, and setting it to 1.0 fully filters the "transmitted" part. Note that here the amount of "transmission" is still defined by alpha.
This also means we can stick to a single "AlphaOver" operation still, and use a fifth color compent (F = filter) to do filtered blending. Even better, RGBA+F color quintets appeared to behave consistantly, and can be applied as nice as pixel based alpha adding.
<ccode>/* regular alpha; RGBAo over RGBAu */
Rn = (1-Ao)*Ru + Ao*Ro;
Gn = (1-Ao)*Gu + Ao*Go;
Bn = (1-Ao)*Bu + Ao*Bo;
An= (1-Ao)*Au + Ao;
/* filtered alpha; RGBAFo over RGBAFu */
fr= 1+ Fo*(Ro-1);
fg= 1+ Fo*(Go-1);
fb= 1+ Fo*(Bo-1);
Rn = fr*(1-Ao)*Ru + Ao*Ro;
Gn = fg*(1-Ao)*Gu + Ao*Go;
Bn = fb*(1-Ao)*Bu + Ao*Bo;
An= (1-Ao)*Au + Ao;
Fn= (1-Ao)*Fu + Ao*Fo;</ccode>
Blender uses AlphaOver as well as AlphaUnder operations, this for rendering transparency from back to front. With RGBA these functions can be associative - meaning a*(b*c) is equivalent to (a*b)*c. Still need evidence this is true for the proposed RGBA+F method. :)
Currently, filtered transparency has been only implemented in the raytrace render.
You can use it with a new button "Filter" in the "Mirror Transp" Panel, note that this button only shows with option "RayTransp" set.
For a 100% color filter, set Alpha at zero, and Filter at 1.0. Zero Alpha can also be achieved with setting Fresnel.
Alpha
Raytraced transparency now also saves the Alpha component in images. Note that the RGB colors are "polluted" with sky color, when sky is rendered.
For the future the zbuffer-based (Ztransp) transparent renderer will also use RGBA+F colors for this kind of filtering. What needs to be evaluated and researched still is we can find one unified method for defining color adding (like for halos) as well.