void PEXOCCSetAlphaBlend(
PEXOCC context,
int src_blend_func,
int dest_blend_func
)
None.
Invoke PEXOCCSetAlphaBlend to create an attribute output command that sets the alpha blend function attribute in the renderer's pipeline state according to the values specified by src_blend_func and dest_blend_func.
Alpha blending specifies how the implementation should individually modulate the color coming out of the depth cueing stage and the previously rendered pixel. The results are summed to determine a color that the implementation sends through the color approximation stage.
The PEX implementation uses alpha blending if you set the renderer's transparency method to PEXTransparencyAlphaBlend. If you set the transparency method to one of the other values, then the implementation ignores this function. If the implementation supports an alpha buffer, then the implementation stores the alpha component of the color directly in the alpha buffer when it sends the other color components through the color approximation stage.
Note: the previously rendered pixels have already been through color approximation and the implementation must transform them back into the rendering color model for alpha blending. This can result in some loss of color accuracy. If the color approximation or the rendering color model are different from the values used for the previously rendered pixels, then the transformed color may be incorrect.
PEXlib describes the alpha blending factors and functions according to the following key:
The overall blend function is determined by combining blend factors:
Cout = src_blend_func * Csrc + dest_blend_func * Cdst
Aout = src_blend_func * Asrc + dest_blend_func * Adst
The blend factors src_blend_func and dest_blend_func are selected from the following table:
Alpha Blend Factors ------------------------------------------------------------- PEXlib Symbol Value ------------------------------------------------------------- PEXZero 0 PEXOne 1 PEXSourceColor Csrc PEXDestinationColor Cdst PEXOneMinusSourceColor 1 - Csrc PEXOneMinusDestinationColor 1 - Cdst PEXSourceAlpha Asrc PEXDestinationAlpha Adst PEXOneMinusSourceAlpha 1 - Asrc PEXOneMinusDestinationAlpha 1 - Adst PEXSourceAlphaMinOneMinusDestinationAlpha min(Asrc , (1 - Adst)) -------------------------------------------------------------The following table lists the alpha blend factor combinations that are defined in PEX. An implementation may not support all of these combinations. Therefore, invoke the PEXQueryAlphaBlend function if your pair of factors, chosen from the list below, are supported by the implementation.
Defined Alpha Blend Functions (Continued)
-------------------------------------------------------------------------------------------------
Source Blend Factor Destination Blend Combined Function
Factor
-------------------------------------------------------------------------------------------------
PEXOne PEXZero Cout = Csrc
Aout = Asrc
PEXSourceAlpha PEXOneMinusSource- Cout = (Asrc * Csrc) + ((1-Asrc) * Cdst)
Alpha Aout = (Asrc * Asrc) + ((1-Asrc) * Adst)
PEXZero PEXZero Cout = 0
Aout = 0
PEXDestinationColor PEXZero Cout = Csrc * Cdst
Aout = Asrc * Adst
PEXOneMinusDestination PEXZero Cout = Csrc * (1 - Cdst)
Color Aout = Asrc * (1 - Adst)
PEXSourceAlpha PEXZero Cout = Asrc * Csrc
Aout = Asrc * Asrc
PEXOneMinusSourceAlpha PEXZero Cout = (1 - Asrc) * Csrc
Aout = (1 - Asrc) * Asrc
PEXDestinationAlpha PEXZero Cout = Adst * Csrc
Aout = Adst * Asrc
PEXOneMinusDestination PEXZero Cout = (1 - Adst) * Csrc
Alpha Aout = (1 - Adst) * Asrc
PEXZero PEXOne Cout = Cdst
Aout = Adst
PEXOne PEXOne Cout = Csrc + Cdst
Aout = Asrc + Adst
PEXDestinationColor PEXOne Cout = (Csrc * Cdst) + Cdst
Aout = (Asrc * Adst) + Adst
PEXOneMinusDestination PEXOne Cout = (Csrc * (1 - Cdst)) + Cdst
Color Aout = (Asrc * (1 - Adst)) + Adst
PEXSourceAlpha PEXOne Cout = (Asrc * Csrc) + Cdst
Aout = (Asrc * Asrc) + Adst
PEXOneMinusSource- PEXOne Cout = ((1 - Asrc) * Csrc) + Cdst
Alpha Aout = ((1 - Asrc) * Asrc) + Adst
PEXDestinationAlpha PEXOne Cout = (Adst * Csrc) + Cdst
Aout = (Adst * Asrc) + Adst
PEXOneMinusDestination PEXOne Cout = ((1 - Adst) * Csrc) + Cdst
Alpha Aout = ((1 - Adst) * Asrc) + Adst
PEXOne PEXSourceColor Cout = Csrc + (Csrc * Cdst)
Aout = Asrc + (Asrc * Adst)
PEXOneMinusDestination PEXSourceColor Cout = (Csrc * (1 - Cdst)) + (Csrc * Cdst)
Color Aout = (Asrc * (1 - Adst)) + (Asrc * Adst)
PEXZero PEXOneMinusSource- Cout = (1 - Csrc) * Cdst
Color Aout = (1 - Asrc) * Adst
PEXOne PEXOneMinusSource- Cout = Csrc + ((1 - Csrc) * Cdst)
Color Aout = Asrc + ((1 - Asrc) * Adst)
PEXDestinationColor PEXOneMinusSource- Cout = (Csrc * Cdst) + ((1 - Csrc) * Cdst)
Color Aout = (Asrc * Adst) + ((1 - Asrc) * Adst)
PEXZero PEXSourceAlpha Cout = Asrc * Cdst
Aout = Asrc * Adst
PEXOne PEXSourceAlpha Cout = Csrc + (Asrc * Cdst)
Aout = Asrc + (Asrc * Adst)
PEXOneMinusSource- PEXSourceAlpha Cout = ((1 - Asrc) * Csrc) + (Asrc * Cdst)
Alpha Aout = ((1 - Asrc) * Asrc) + (Asrc * Adst)
PEXDestinationAlpha PEXSourceAlpha Cout = (Adst * Csrc) + (Asrc * Cdst)
Aout = 2 * (Asrc * Adst)
PEXOneMinusDestination PEXSourceAlpha Cout = ((1 - Adst) * Csrc) + (Asrc * Cdst)
Alpha Aout = ((1 - Adst) * Asrc) + (Asrc * Adst)
PEXZero PEXOneMinusSource- Cout = (1 - Asrc) * Cdst
Alpha Aout = (1 - Asrc) * Adst
PEXOne PEXOneMinusSource- Cout = Csrc + ((1 - Asrc) * Cdst)
Alpha Aout = Asrc + ((1 - Asrc) * Adst)
PEXDestinationAlpha PEXOneMinusSource- Cout = (Adst * Csrc) + ((1 - Asrc) * Cdst)
Alpha Aout = Adst
PEXOneMinusDestination PEXOneMinusSource- Cout = ((1 - Adst) * Csrc) + ((1 - Asrc) * Cdst)
Alpha Alpha Aout = ((1 - Adst) * Asrc) + ((1 - Asrc) * Adst)
PEXZero PEXDestinationAlpha Cout = Adst * Cdst
Aout = Adst * Adst
PEXOne PEXDestinationAlpha Cout = Csrc + (Adst * Cdst)
Aout = Asrc + (Adst * Adst)
PEXSourceAlpha PEXDestinationAlpha Cout = (Asrc * Csrc) + (Adst * Cdst)
Aout = (Asrc * Asrc) + (Adst * Adst)
PEXOneMinusSource- PEXDestinationAlpha Cout = ((1 - Asrc) * Csrc) + (Adst * Cdst)
Alpha Aout = ((1 - Asrc) * Asrc) + (Adst * Adst)
PEXOneMinusDestination PEXDestinationAlpha Cout = ((1 - Adst) * Csrc) + (Adst * Cdst)
Alpha Aout = ((1 - Adst) * Asrc) + (Adst * Adst)
PEXZero PEXOneMinusDestination Cout = (1 - Adst) * Cdst
Alpha Aout = (1 - Adst) * Adst
PEXOne PEXOneMinusDestination Cout = Csrc + ((1 - Adst) * Cdst)
Alpha Aout = Asrc + ((1 - Adst) * Adst)
PEXSourceAlpha PEXOneMinusDestination Cout = (Asrc * Csrc) + ((1 - Adst) * Cdst)
Alpha Aout = (Asrc * Asrc) + ((1 - Adst) * Adst)
PEXOneMinusSource- PEXOneMinusDestination Cout = ((1 - Asrc) * Csrc) + ((1 - Adst) * Cdst)
Alpha Alpha Aout = ((1 - Asrc) * Asrc) + ((1 - Adst) * Adst)
PEXDestinationAlpha PEXOneMinusDestination Cout = (Adst * Csrc) + ((1 - Adst) * Cdst)
Alpha Aout = (Adst * Asrc) + ((1 - Adst) * Adst)
PEXSourceAlphaMinOne PEXOne Cout = (min(Asrc, (1 - Adst)) * Csrc) + Cdst
MinusDestinationAlpha Aout = Asrc + Adst
-------------------------------------------------------------------------------------------------
If the implementation does not support the combined alpha blend function specified by the src_blend_funcdest_blend_func blend factors, then the alpha blend function used by the implementation is the function formed by the source blend factor of PEXOne and the destination blend factor of PEXZero.
A pixel is transparent if its alpha value is 0.0; it is opaque if its alpha value is 1.0. If you alpha blend a color of a primitive that does not have an alpha component, then the implementation uses the default alpha value. For fill area primitives, the default alpha value is the transmission coefficient field of the pipeline state's reflection attributes subtracted from 1. For back-facing fill area primitives, the pipeline state's back-facing reflection attributes are similarly used. For all other primitives, alpha defaults to 1.0.
Alpha blending interacts with HLHSR, primitive antialiasing, drawing functions (except GXcopy), and plane masking (except all planes enabled), in an implementation-dependent way.
This function is a member of the global attribute set and affects all output primitives.
For an overview and for a list of output attribute functions, see Output Attribute Functions.