Version: 2019.1
ShaderLab: Culling & Depth Testing
ShaderLab: Pass Tags

ShaderLab: Blending

El Blending se utiliza para volver los objetos transparentes.

When graphics are rendered, after all Shaders have executed and all Textures have been applied, the pixels are written to the screen. How they are combined with what is already there is controlled by the Blend command.

Sintaxis

Blend Off: Apaga el blending (esto es lo predeterminado)

Blend SrcFactor DstFactor: Configura y habilita el blending. El color generado es multiplicado por el SrcFactor. El color que ya está en la pantalla es multiplicado por DstFactor y los dos se agregan juntos.

Blend SrcFactor DstFactor, SrcFactorA DstFactorA: Lo mismo que arriba, pero tienen diferentes factores para hacerle blending (mezclar) el canal alpha.

BlendOp Op: Instead of adding blended colors together, carry out a different operation on them.

BlendOp OpColor, OpAlpha: Lo mismo que arriba, pero utiliza una operación diferente de blend para los canales de color (RGB) y alpha (A).

Additionally, you can set upper-rendertarget blending modes. When using multiple render target (MRT) rendering, the regular syntax above sets up the same blending modes for all render targets. The following syntax can set up different blending modes for individual render targets, where N is the render target index (0..7). This feature works on most modern APIs/GPUs (DX11/12, GLCore, Metal, PS4):

  • Blend N SrcFactor DstFactor
  • Blend N SrcFactor DstFactor, SrcFactorA DstFactorA
  • BlendOp N Op
  • BlendOp N OpColor, OpAlpha

AlphaToMask On: Turns on alpha-to-coverage. When MSAA is used, alpha-to-coverage modifies multisample coverage mask proportionally to the pixel Shader result alpha value. This is typically used for less aliased outlines than regular alpha test; useful for vegetation and other alpha-tested Shaders.

Operaciones Blend

Las siguientes operaciones blend se pueden utilizar:

Add Agrega una fuente y destino juntos.
Sub Resta el destino de la fuente.
RevSub Resta la fuente del destino.
Min Utiliza la fuente y el destino más pequeño.
Max Utiliza la fuente y destino más grande.
LogicalClear Operación lógica: Clear (0) DX11.1 solamente.
LogicalSet Operación lógica: Configure (1) DX11.1 solamente.
LogicalCopy Operación lógica: Copie (s) DX11.1 solamente.
LogicalCopyInverted Operación lógica: Copia invertida (!s) DX11.1 solamente.
LogicalNoop Operación lógica: Noop (d) DX11.1 solamente.
LogicalInvert Operación lógica: Invertir (!d) DX11.1 solamente.
LogicalAnd Operación lógica: And (s & d) DX11.1 solamente.
LogicalNand Operación lógica : Nand !(s & d) DX11.1 solamente.
LogicalOr Logical operation: Or (s | d) DX11.1 only.
LogicalNor Logical operation: Nor !(s | d) DX11.1 only.
LogicalXor Operación lógica: Xor (s ^ d) DX11.1 solamente.
LogicalEquiv Operación lógica: Equivalencia !(s ^ d) DX11.1 solamente.
LogicalAndReverse Operación lógica: Reverse And (s $ !d) DX11.1 solamente.
LogicalAndInverted Operación lógica: Invertida And (y) (!s & d) DX11.1 solamente.
LogicalOrReverse Logical operation: Reverse Or (s | !d) DX11.1 only.
LogicalOrInverted Logical operation: Inverted Or (!s | d) DX11.1 only.

Blend factors

Todas las siguientes propiedades son válidas para ambos SrcFactor & DstFactor en el comando Blend. Source (fuente) se refiere al color calculado, Destination (destino) es el color que ya está en la pantalla. Los blend factors son ignorados si *BlendOp está utilizando operaciones lógicas.

One El valor de uno - utilice esto para permitir que el color fuente o destino venga completamente.
Zero El valor cero - utilice esto para quitar los valores ya sea de la fuente o el destino.
SrcColor El valor de este estado es multiplicado por el valor del color fuente.
SrcAlpha El valor de este estado es multiplicado por el valor alpha fuente.
DstColor El valor de este estado es multiplicado por el valor del color fuente del frame buffer.
DstAlpha El valor de este estado es multiplicado por el valor fuente alpha del frame buffer.
OneMinusSrcColor El valor de este estado es multiplicado por (1 - color fuente).
OneMinusSrcAlpha El valor de este estado es multiplicado por (1 - alpha fuente).
OneMinusDstColor El valor de este estado es multiplicado por (1 - color destino).
OneMinusDstAlpha El valor de este estado es multiplicado por (1 - alpha destino).

Detalles

Abajo están los tipos de blend más comunes:

Blend SrcAlpha OneMinusSrcAlpha // Traditional transparency
Blend One OneMinusSrcAlpha // Premultiplied transparency
Blend One One // Additive
Blend OneMinusDstColor One // Soft Additive
Blend DstColor Zero // Multiplicative
Blend DstColor SrcColor // 2x Multiplicative

Alpha blending, alpha testing, alpha-to-coverage

For drawing mostly fully opaque or fully transparent objects, where transparency is defined by the Texture’s alpha channel (e.g. leaves, grass, chain fences etc.), several approaches are commonly used:

Alpha blending

Un alpha blending regular
Un alpha blending regular

This often means that objects have to be considered as “semitransparent”, and thus can’t use some of the rendering features (for example: deferred shading, can’t receive shadows). Concave or overlapping alpha-blended objects often also have draw ordering issues.

Often, alpha-blended Shaders also set transparent render queue, and turn off depth writes. So the Shader code looks like:

// inside SubShader
Tags { "Queue"="Transparent" "RenderType"="Transparent" "IgnoreProjector"="True" }

// inside Pass
ZWrite Off
Blend SrcAlpha OneMinusSrcAlpha

Alpha testing/cutout

clip() in pixel Shader
clip() in pixel Shader

By using clip() HLSL instruction in the pixel Shader, a pixel can be “discarded” or not based on some criteria. This means that object can still be considered as fully opaque, and has no draw ordering issues. However, this means that all pixels are fully opaque or transparent, leading to aliasing (“jaggies”).

Often, alpha-tested Shaders also set cutout render queue, so the Shader code looks like this:

// inside SubShader
Tags { "Queue"="AlphaTest" "RenderType"="TransparentCutout" "IgnoreProjector"="True" }

// inside CGPROGRAM in the fragment Shader:
clip(textureColor.a - alphaCutoffValue);

Alpha-to-coverage

AlphaToMask prendida, en 4xMSAA
AlphaToMask prendida, en 4xMSAA

When using multisample anti-aliasing (MSAA, see QualitySettings), it is possible to improve the alpha testing approach by using alpha-to-coverage GPU functionality. This improves edge appearance, depending on the MSAA level used.

Esta funcionalidad funciona mejor en texturas que son en su mayoría opacas o transparentes, y tienen áreas “parcialmente transparentes” demasiado delgadas (pasto, hojas y similar).

Often, alpha-to-coverage Shaders also set cutout render queue. So the Shader code looks like:

// inside SubShader
Tags { "Queue"="AlphaTest" "RenderType"="TransparentCutout" "IgnoreProjector"="True" }

// inside Pass
AlphaToMask On

Ejemplo

Here is a small example Shader that adds a Texture to whatever is on the screen already:

Shader "Simple Additive" {
    Properties {
        _MainTex ("Texture to blend", 2D) = "black" {}
    }
    SubShader {
        Tags { "Queue" = "Transparent" }
        Pass {
            Blend One One
            SetTexture [_MainTex] { combine texture }
        }
    }
}
ShaderLab: Culling & Depth Testing
ShaderLab: Pass Tags