Alpha Blending and Transparency Sorting: Key Mechanisms for Rendering Transparent Objects

What is Alpha Blending

Alpha blending is a technique that mixes the current fragment color with the destination framebuffer color in a certain proportion to achieve semi-transparent effects, such as glass, smoke, and particles. Blending uses the fragment's alpha value as a weight, typically with the following formula:

`Final Color = Source Color * Source Factor + Destination Color * Destination Factor`

Common blend modes include:

• **Standard Alpha Blending**: `SrcAlpha, OneMinusSrcAlpha`, i.e., `C_out = C_src * A_src + C_dst * (1 - A_src)`.
• **Additive Blending**: `One, One`, used for glow effects.
• **Multiplicative Blending**: `Zero, SrcColor`, used for shadows or tinting.

In the rendering pipeline, alpha blending is typically performed after depth testing. However, transparent objects do not write to the depth buffer to avoid occluding subsequent objects, which leads to sorting issues.

Transparency Sorting Problems

Because transparent objects do not write to depth, rendering order becomes important. If rendered back-to-front (painter's algorithm), results are correct; but if the order is wrong, blending results will be incorrect. A common sorting method is to sort objects by distance from the camera. However, for intersecting or non-convex objects, per-object sorting may fail.

Solutions include:

• **Per-object sorting**: Simple but may be incorrect.
• **Per-fragment sorting**: Such as A-Buffer or per-pixel linked lists, accurate but expensive.
• **Separate transparent from opaque**: First render opaque objects (writing depth), then render transparent objects (depth test but not write depth).
• **Use order-independent transparency (OIT)**: Such as weighted average OIT or depth peeling, for high-quality effects.

Handling in Engines

• **Unity**: Transparent materials use the Transparent render queue, and the engine automatically sorts by distance. You can adjust the render queue order (e.g., Transparent-100 to +100) to manually control.
• **Unreal**: Transparent materials use the Translucent blend mode, with support for per-object sorting and OIT options.

Difference between Alpha Test and Blending

Alpha testing is a hard switch that discards fragments based on a threshold, without blending. It is suitable for fully transparent or opaque objects (such as foliage), avoids sorting issues, but edges may have aliasing. Alpha blending is better for semi-transparent effects.

Frequently Asked Questions

Why don't transparent objects write to the depth buffer?

If transparent objects write to depth, they will occlude transparent objects behind them, causing those objects not to be rendered and blending results to be wrong. Therefore depth writing is usually disabled.

How to solve transparent object sorting errors?

You can improve sorting algorithms, use OIT, or split objects into convex pieces. Adjusting render queue order in engines can also mitigate.

Does alpha blending affect performance?

Yes, transparent objects add blending operations and sorting overhead, and may cause overdraw. Minimize the number of transparent objects and screen coverage area.

How to handle alpha blending on mobile?

Mobile bandwidth is limited, so use transparent blending cautiously and avoid heavy overlap. Using alpha testing instead of blending can improve performance.

Why do particle systems often use additive blending?

Additive blending produces glow effects and does not require sorting (because the order of color addition doesn't affect the result), making it suitable for particles.