Alpha Blending With Two Rendering Targets (DirectX or OpenGL) - opengl

Question

I am trying to do the following:
Create a transparent texture called T
Render a textured quad called Q to T
Render T to the screen
Note that the alpha component of T will be zero and the alpha component of Q could be less than one.
I need two alpha blending equations so that if I render multiple instances of Q to T (1st blending equations used) and then render T (2nd blending euqations used), it would be the same as rendering multiple instances of Q directly to the screen.
I use this blending equation
color = src * srcAlpha + dst * (1 - srcAlpha)
alpha = 1 * srcAlpha + 0 * destAlpha
for the case when I render Qs directly to the screen, but cannot define two blending equations that achieve the same thing when I render to T first.
Note that T's pixels are initially fully transparent (alpha = 0) as I don't want it to overwrite the screen if it's not been draw to. Q may have any transparency level in each of its pixels.

Answer 1

What you are asking is mathematically impossible using linear interpolation.
Let's say you have two transparent objects, A and B. You have your texture T, and the screen S. And Blend is the blend equation.
What you are doing with rendering to T is:
T = Blend(B, Blend(A, T))
S = Blend(T, S)
//Therefore
S = Blend(Blend(B, Blend(A, T)), S)
See how there are 3 separate blending operations here? You cannot do that with two blending operations. Which is all you would have if you render A and B.
Linear interpolation is neither commutative nor associative. The order of blending operations matters. And the effect you achieve by writing to a temporary intermediate and blending that to the final buffer cannot be achieved without that intermediary.
There are blending operations that are associative and commutative. For example, additive. But that's almost certainly not going to achieve the visual effect you want, since it adds colors together. That may be something you could use, if you're doing HDR lighting. But there are many cases where it would be inappropriate.
Additive blending would involve a blend equation of the form:
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
With the source alpha determining what percentage of the incoming color to add.

Answer 2

I think this works when rendering Q into T:
color = src * srcAlpha + dst * (1 - srcAlpha)
alpha = (1 - destAlpha) * srcAlpha + 1 * destAlpha
Edit: Thinking about it, my answer won't result in the screen's alpha channel matching the alpha channel you describe when you're rendering direct into the screen. Your alpha blend mode when rendering direct to screen is very unusual. I'm not sure whether you really want the screen's alpha to represent the alpha of the last texture you rendered, or whether you don't actually care what the screen's alpha channel looks like. In most rendering situations people don't care about the state of the back buffer's alpha channel, hopefully that's the case here and my answer works for you.

Answer 3

I have figured this out, and given it's not something I've seen elsewhere on the internet, I hope this will help someone else...
For the first blend equation, for quads Q rendering to T:
Q -> T
color = src * srcAlpha + dst * (1 - srcAlpha)
alpha = 1 * srcAlpha + (1 - srcAlpha) * destAlpha
For the second blend equation, T going to the screen:
T -> S
color = src * 1 + dst * (1 - srcAlpha)
alpha = doesn't matter as screen alpha isn't used
Explanation
For Q -> T, the equation for the color components is as per the normal alpha blending equation:
color = src * srcAlpha + dst * (1 - srcAlpha)
however we need to make sure the alpha channel is set up for the second part. Because we are effectively pre-multiplying the alphas of Q when rendered to T using this blending equation, we only need the alpha in the second stage to determine how much to dim the color of the screen color by when rendering T, hence the alpha in the first equation is:
alpha = 1 * srcAlpha + (1 - srcAlpha) * destAlpha
but we only use it to fade the destination color behind the color of T in the second equation (we use 1 for src color as that was pre-multiplied by equation 1):
color = src * 1 + dst * (1 - srcAlpha)
In DirectX 11 this gives the same results whether equation 1 is used to render directly to the screen or both equations are used to render to T then the screen.
Code for DirectX 11 (for people who prefer real code):
1st equation:
D3D11_BLEND_DESC blend{};
blend.AlphaToCoverageEnable = FALSE;
auto& target = blend.RenderTarget[0];
target.BlendEnable = TRUE;
target.RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
target.SrcBlend = D3D11_BLEND_SRC_ALPHA;
target.DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
target.BlendOp = D3D11_BLEND_OP_ADD;
target.SrcBlendAlpha = D3D11_BLEND_ONE;
target.DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
target.BlendOpAlpha = D3D11_BLEND_OP_ADD;
2nd equation:
D3D11_BLEND_DESC blend{};
blend.AlphaToCoverageEnable = FALSE;
auto& target = blend.RenderTarget[0];
target.BlendEnable = TRUE;
target.RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
target.SrcBlend = D3D11_BLEND_ONE;
target.DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
target.BlendOp = D3D11_BLEND_OP_ADD;
target.SrcBlendAlpha = D3D11_BLEND_ZERO;
target.DestBlendAlpha = D3D11_BLEND_ONE;
target.BlendOpAlpha = D3D11_BLEND_OP_ADD;
T is initially cleared to {0, 0, 0, 0}.