关于SFML BlendAlpha混合模式与图形编辑器颜色插值逻辑不符的技术咨询

You're absolutely correct in observing that SFML's default sf::BlendAlpha behaves differently from tools like Aseprite, Krita, or Photoshop. This discrepancy comes down to two distinct alpha blending models built for different use cases:

Key Background: Two Blending Models #

1. SFML's Default sf::BlendAlpha #

SFML's BlendAlpha uses non-premultiplied alpha blending, optimized for typical 2D game scenarios (like drawing semi-transparent sprites over opaque backgrounds). Its formula is:

// RGB channels
C_res = C_src * (A_src / 255) + C_dst * (1 - A_src / 255)
// Alpha channel
A_res = A_src * 1 + A_dst * (1 - A_src / 255)

When drawing your C₁=(255,0,0,127) onto a fully transparent C₂=(0,0,0,0), this calculates to:

• RGB channels: 255*(127/255) + 0 = 127
• Alpha channel: 127 + 0 = 127
  Resulting in the (127,0,0,127) texture you saw. This model prioritizes layering semi-transparent content over existing pixels, but it attenuates the source color by its own alpha even when drawing to a transparent canvas.

2. Graphics Editor "Normal" Blend Mode #

Tools like Photoshop use the Porter-Duff "Over" blend mode, which aligns with your intuitive expectation of "painting" onto a canvas. For non-premultiplied colors, its formula is:

A_res = A_src + A_dst * (1 - A_src/255)
C_res = (C_src * A_src + C_dst * A_dst * (1 - A_src/255)) / A_res

When drawing to a fully transparent target (A_dst=0), this simplifies cleanly to:

• A_res = A_src
• C_res = C_src
  Giving you the expected (255,0,0,127) result. The catch is that SFML's BlendMode can't directly implement this formula—GPU blend units don't support division operations. Instead, editors use premultiplied alpha to optimize this calculation by moving the division to a pre-processing step.

How to Replicate Graphics Editor Behavior in SFML #

The most reliable way to match editor-style blending is to use premultiplied alpha with SFML's built-in BlendPremultiplied mode:

Step 1: Convert Your Source Texture to Premultiplied Alpha #

Premultiplied alpha means each RGB channel is scaled by the alpha value. For your C₁=(255,0,0,127), this becomes (255*(127/255), 0, 0, 127) = (127,0,0,127).

To process an entire texture:

sf::Texture sourceTexture;
// Load your source texture first...

// Create a copy to modify
sf::Texture premultipliedTexture = sourceTexture;
sf::Image img = premultipliedTexture.copyToImage();

for (unsigned int y = 0; y < img.getSize().y; ++y) {
    for (unsigned int x = 0; x < img.getSize().x; ++x) {
        sf::Color pixel = img.getPixel(x, y);
        // Premultiply RGB channels by alpha
        pixel.r = static_cast<sf::Uint8>((static_cast<unsigned int>(pixel.r) * pixel.a) / 255);
        pixel.g = static_cast<sf::Uint8>((static_cast<unsigned int>(pixel.g) * pixel.a) / 255);
        pixel.b = static_cast<sf::Uint8>((static_cast<unsigned int>(pixel.b) * pixel.a) / 255);
        img.setPixel(x, y, pixel);
    }
}

premultipliedTexture.loadFromImage(img);

Step 2: Draw with BlendPremultiplied #

When drawing to your sf::RenderTexture, use the premultiplied blend mode:

sf::Sprite sprite(premultipliedTexture);
render_texture.draw(sprite, sf::RenderStates(sf::BlendMode::BlendPremultiplied));

This works because BlendPremultiplied uses a GPU-friendly formula (no division needed):

// Premultiplied RGB channels
C_res_premul = C_src_premul + C_dst_premul * (1 - A_src/255)
// Alpha channel
A_res = A_src + A_dst * (1 - A_src/255)

When converting back to non-premultiplied colors (SFML handles this implicitly for display), you get the exact result you'd see in a graphics editor.

Why SFML Uses BlendAlpha by Default #

SFML is designed primarily for game development, where many assets use non-premultiplied alpha. BlendAlpha is more intuitive for common game tasks like drawing semi-transparent sprites over solid backgrounds. Graphics editors, by contrast, prioritize "painting" behavior where drawing to transparency should preserve the source color's full intensity.

内容的提问来源于stack exchange，提问作者KingCake