Imagem de desenho com mistura aditiva

Use 1) XNA (recomendado para velocidade), ou 2) use pixel-operations em C#. Pode haver outros métodos ,mas qualquer um destes trabalhos (estou usando cada um deles para efeitos 3D e aplicações de análise de imagem (respectivamente) que eu manter).

Operações de pixels em C#: Usando 3 bitmaps; bmpA, bmpB, bmpC, onde você deseja armazenar bmpA+bmpB em bmpC.

for (int y = 0; y < bmp.Height; y++)
{
    for (int x = 0; x < bmp.Width; x++)
    {
        Color cA = bmpA.GetPixel(x,y);
        Color cB = bmpB.GetPixel(x,y);
        Color cC = Color.FromArgb(cA.A, cA.R + cB.R, cA.G + cB.G, cA.B + cB.B);
        bmpC.SetPixel(x, y, cC);
    }
}

O código acima é muito lento. Uma solução mais rápida em C# poderia usar ponteiros como este:

    // Assumes all bitmaps are the same size and same pixel format
    BitmapData bmpDataA = bmpA.LockBits(new Rectangle(0, 0, bmpA.Width, bmpA.Height), ImageLockMode.ReadOnly, bmpA.PixelFormat);
    BitmapData bmpDataB = bmpB.LockBits(new Rectangle(0, 0, bmpA.Width, bmpA.Height), ImageLockMode.ReadOnly, bmpA.PixelFormat);
    BitmapData bmpDataC = bmpC.LockBits(new Rectangle(0, 0, bmpA.Width, bmpA.Height), ImageLockMode.WriteOnly, bmpA.PixelFormat);
    void* pBmpA = bmpDataA.Scan0.ToPointer();
    void* pBmpB = bmpDataB.Scan0.ToPointer();
    void* pBmpC = bmpDataC.Scan0.ToPointer();
    int bytesPerPix = bmpDataA.Stride / bmpA.Width;
    for (int y = 0; y < bmp.Height; y++)
    {
        for (int x = 0; x < bmp.Width; x++, pBmpA += bytesPerPix, pBmpB += bytesPerPix, pBmpC += bytesPerPix)
        {
            *(byte*)(pBmpC) = *(byte*)(pBmpA) + *(byte*)(pBmpB); // R
            *(byte*)(pBmpC + 1) = *(byte*)(pBmpA + 1) + *(byte*)(pBmpB + 1); // G
            *(byte*)(pBmpC + 2) = *(byte*)(pBmpA + 2) + *(byte*)(pBmpB + 2); // B
        }
    }
    bmpA.UnlockBits(bmpDataA);
    bmpB.UnlockBits(bmpDataB);
    bmpC.UnlockBits(bmpDataC);

O método acima descrito exige ponteiros e, portanto, deve ser compilado com a Directiva "insegura". Também assume 1 byte para cada um de R,G, E B. mude o código para se adequar ao seu formato de pixel.

O uso do XNA é muito mais rápido (desempenho), uma vez que é o hardware acelerado (pela GPU). Trata-se essencialmente do seguinte:: 1. Crie a geometria necessária para desenhar a imagem (um rectângulo, provavelmente um quad de ecrã completo). 2. Escreva um 'vertex-shader' e um 'pixel-shader'. O vértice-sombreado pode simplesmente passar-através do geometria não modificada. Ou pode aplicar uma projecção ortogonal (dependendo das coordenadas com que deseja trabalhar para o quad). O sombreador de pixels terá as seguintes linhas (HLSL):

float4 ps(vertexOutput IN) : COLOR 
{
    float3 a = tex2D(ColorSampler,IN.UV).rgb;
    float3 b = tex2D(ColorSampler2,IN.UV).rgb;
    return float4(a + b,1.0f);
}

float4 ps(vertexOutput IN) : COLOR 
{
    float3 a = texA.Sample(samplerState, IN.UV).xyz;
    float3 b = texB.Sample(samplerState, IN.UV).xyz;
    return float4(a + b,1.0f);
}

Qual dos shaders acima que você usa irá depender se você quer usar o "sampler2D " ou" texture " HLSL interfaces para aceder às texturas.

Deve também ter o cuidado de utilizar um sistema de amostragem adequado para garantir que não é utilizada nenhuma amostragem (por exemplo, interpolação linear) ao procurar valores de cor, a menos que seja algo que queira (neste caso, utilize algo de qualidade superior/ordem superior).

O XNA também tem BlendStates incorporados que pode usar para especificar como as texturas sobrepostas serão combinadas. Ou seja, BlendState.Aditivo (ver publicação original actualizada).