Name

    ARB_blend_func_extended

Name Strings

    GL_ARB_blend_func_extended

Contributors

    Graham Sellers, AMD
    Mark Young, AMD
    Nick Haemel, AMD
    Pierre Boudier, AMD
    Mais Alnasser, AMD
    Jeff Bolz, NVIDIA
    Pat Brown, NVIDIA
    Ian Stewart, NVIDIA
    Mark Kilgard, NVIDIA

Contact

    Graham Sellers, AMD (graham.sellers 'at' amd.com)

Notice

    Copyright (c) 2010-2013 The Khronos Group Inc. Copyright terms at
        http://www.khronos.org/registry/speccopyright.html

Status

    Complete. Approved by the ARB at the 2010/01/22 F2F meeting.
    Approved by the Khronos Board of Promoters on March 10, 2010.

Version

    Last Modified Date:         05/22/2015
    Author Revision:            13

Number

    ARB Extension #78

Dependencies

    OpenGL 1.0 is required.

    The ARB_fragment_shader extension is required.

    The EXT_gpu_shader4 extension is required.

    The EXT_blend_func_separate extension interacts with this extension.

    The ARB_draw_buffers extension trivially affects the definition of this
    extension.

    The ARB_draw_buffers_blend extension affects the definition of this
    extension.

    This extension is written against the OpenGL 3.2 Specification (Compatibility Profile)

Overview

    Traditional OpenGL includes fixed-function blending that combines source
    colors with the existing content of a render buffer in a variety of ways.
    A number of extensions have enhanced this functionality by adding further
    sources of blending weights and methods to combine them. However, the inputs
    to the fixed-function blending units are constrained to a source color (as
    output from fragment shading), destination color (as the current content
    of the frame buffer) or constants that may be used in their place.

    This extension adds new blending functions whereby a fragment shader may
    output two colors, one of which is treated as the source color, and the
    other used as a blending factor for either source or destination colors.
    Furthermore, this extension increases orthogonality by allowing the
    SRC_ALPHA_SATURATE function to be used as the destination weight.

IP Status

    No known IP claims.

New Procedures and Functions

    void BindFragDataLocationIndexed(uint program, uint colorNumber,
                                        uint index, const char * name);

    int GetFragDataIndex(uint program, const char * name);

New Tokens

    Accepted by the <src> and <dst> parameters of BlendFunc and
    BlendFunci, and by the <srcRGB>, <dstRGB>, <srcAlpha> and <dstAlpha>
    parameters of BlendFuncSeparate and BlendFuncSeparatei:

        SRC1_COLOR                                      0x88F9
        SRC1_ALPHA
        ONE_MINUS_SRC1_COLOR                            0x88FA
        ONE_MINUS_SRC1_ALPHA                            0x88FB

    Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv
    and GetDoublev:

        MAX_DUAL_SOURCE_DRAW_BUFFERS                    0x88FC

Additions to Chapter 2 of the OpenGL 3.2 Specification (Compatibility Profile) (OpenGL Operation)

    None.

Additions to Chapter 3 of the OpenGL 3.2 Specification (Compatibility Profile) (Rasterization)

    Modify the "Shader Outputs" subsection of Section 3.12.2, Shader Execution

    Modify the text on p.297 beginning "The binding of a user-defined varying
    out variable to a fragment..."

    The binding of a user-defined varying out variable to a fragment color number
    can be specified explicitly. The command

        void BindFragDataLocationIndexed(uint program, uint colorNumber, uint index, const char * name);

    specifies that the varying out variable name in <program> should be bound to
    fragment color <colorNumber> when the program is next linked. <index> may be
    zero or one to specify that the color be used as either the first or second
    color input to the blend equation, respectively, as described in Section 4.1.8. 

    If <name> was bound previously, its assigned binding is replaced with
    colorNumber. <name> must be a null-terminated string. The error INVALID_VALUE
    is generated if <colorNumber> is equal or greater than MAX_DRAW_BUFFERS and
    <index> is zero, or if <colorNumber> is equal or greater than
    MAX_DUAL_SOURCE_DRAW_BUFFERS and <index> is greater than or equal to one.
    The command

        void BindFragDataLocation(uint program, uint colorNumber, const char * name)

    is equivalent to calling BindFragDataLocationIndexed with the same values
    for <program>, <colorNumber> and <name>, and with <index> set to zero.

    When a program is linked, any varying out variables without a binding
    specified through BindFragDataLocationIndexed or BindFragDataLocation will
    automatically be bound to fragment colors and indices by the GL.  All such
    assignments will use color indices of zero.  Such bindings can be queried
    using the commands GetFragDataLocation and GetFragDataIndex.  Output
    binding assignments will cause LinkProgram to fail:

      * if the number of active outputs is greater than the value of
        MAX_DRAW_BUFFERS;

      * if the program has an active output assigned to a location greater
        than or equal to the value of MAX_DUAL_SOURCE_DRAW_BUFFERS and has an
        active output assigned an index greater than or equal to one;

      * if more than one varying out variable is bound to the same number and
        index; or

      * if the explicit binding assignments do not leave enough space for the
        linker to automatically assign a location for a varying out array,
        which requires multiple contiguous locations.

    BindFragDataLocationIndexed may be issued before any shader objects are
    attached to a program object. Hence it is allowed to bind any name (except a
    name starting with gl_) to a color number and index, including a name that
    is never used as a varying out variable in any fragment shader object.
    Assigned bindings for variables that do not exist are ignored.

    Add to the last paragraph on p.279

    The command

        int GetFragDataIndex(uint program, const char * name);

    returns the index of the fragment color to which the variable <name> was bound
    when the program object <program> was last linked. If program has not been
    successfully linked, the error INVALID_OPERATION is generated. If name is not
    a varying out variable, or if an error occurs, -1 will be returned.

Additions to Chapter 4 of the OpenGL 3.2 Specification (Compatibility Profile) (Per-Fragment Operations
and the Framebuffer)

    Modify the first paragraph of the Blending Functions subsection of Section
    4.1.8 Blending (p. 292) as follows:

    The weighting factors used by the blend equation are determined by the blend
    functions. There are four possible sources for weighting factors. These are
    the constant color (Rc, Gc, Bc, Ac) (see BlendColor, p. 211), the first
    source color (Rs0, Gs0, Bs0, As0), the second source color
    (Rs1, Gs1, Bs1, As1), and the destination color (the existing content of the
    draw buffer). Additionally the special constants ZERO and ONE are
    available as weighting factors. Blend functions are specified ...

    Modify Table 4.2 (p. 213) as follows

                                                            RGB Blend Factors                   Alpha Blend Factors
        Value                                               (Sr, Sg, Sb) or (Dr, Dg, Db)        Sa or Da
        -----                                               ----------------------------        -------------------
        ZERO                                                (0, 0, 0)                           0
        ONE                                                 (1, 1, 1)                           1
        SRC_COLOR                                           (Rs0, Gs0, Bs0)                     As0
        ONE_MINUS_SRC_COLOR                                 (1, 1, 1) - (Rs0, Gs0, Bs0)         1 - As0
        DST_COLOR                                           (Rd, Gd, Bd)                        Ad
        ONE_MINUS_DST_COLOR                                 (1, 1, 1) - (Rd, Gd, Bd)            1 - Ad
        SRC_ALPHA                                           (As0, As0, As0)                     As0
        ONE_MINUS_SRC_ALPHA                                 (1, 1, 1) - (As0, As0, As0)         1 - As0
        DST_ALPHA                                           (Ad, Ad, Ad)                        Ad
        ONE_MINUS_DST_ALPHA                                 (1, 1, 1) - (Ad, Ad, Ad)            1 - Ad
        CONSTANT_COLOR                                      (Rc, Gc, Bc)                        Ac
        ONE_MINUS_CONSTANT_COLOR                            (1, 1, 1) - (Rc, Gc, Bc)            1 - Ac
        CONSTANT_ALPHA                                      (Ac, Ac, Ac)                        Ac
        ONE_MINUS_CONSTANT_ALPHA                            (1, 1, 1) - (Ac, Ac, Ac)            1 - Ac
        SRC_ALPHA_SATURATE                                  (f, f, f)                           1                       (Now allowed for dst)
        SRC1_COLOR                                          (Rs1, Gs1, Bs1)                     As1                     New
        ONE_MINUS_SRC1_COLOR                                (1, 1, 1) - (Rs1, Gs1, Bs1)         1 - As1                 New
        SRC1_ALPHA                                          (As1, As1, As1)                     As1                     New
        ONE_MINUS_SRC1_ALPHA                                (1, 1, 1) - (As1, As1, As1)         1 - As1                 New

    Remove Footnote 1 from Table 4.2.

    Add the following subsections to Section 4.1.8 Blending, at the end of the
    description of Blend Function (p. 294)

    Dual Source Blending and Multiple Draw Buffers

    Blend functions that require the second color input, <Rs1, Gs1, Bs1, As1>
    (SRC1_COLOR, SRC1_ALPHA, ONE_MINUS_SRC1_COLOR, or
    ONE_MINUS_SRC1_ALPHA) may consume hardware resources that could
    otherwise be used for rendering to multiple draw buffers. Therefore, the
    number of draw buffers that can be attached to a frame buffer may be lower
    when using dual-source blending.

    The maximum number of draw buffers that may be attached to a single frame
    buffer when using dual-source blending functions is implementation dependent
    and can be queried by calling GetIntegerv with the symbolic constant 
    MAX_DUAL_SOURCE_DRAW_BUFFERS. When
    using dual-source blending, MAX_DUAL_SOURCE_DRAW_BUFFERS should be used
    in place of MAX_DRAW_BUFFERS to determine the maximum number of draw
    buffers that may be attached to a single frame buffer. The value of
    MAX_DUAL_SOURCE_DRAW_BUFFERS must be at least 1. If the value of
    MAX_DUAL_SOURCE_DRAW_BUFFERS is 1, then dual-source blending and
    multiple draw buffers cannot be used simultaneously.

    If either blend function is set to one of the second source factors
    (SRC1_COLOR, SRC1_ALPHA, ONE_MINUS_SRC1_COLOR, or
    ONE_MINUS_SRC1_ALPHA) for any draw buffer and any draw buffers equal to
    or greater than the value of MAX_DUAL_SOURCE_DRAW_BUFFERS have values other than NONE,
    the error INVALID_OPERATION is generated by Begin, or any procedure that
    implicitly calls Begin.

    Generation of Second Color Source for Blending

    There is no way to generate the second source color using the fixed-function
    fragment pipeline. Rendering using any of the blend functions that consume
    the second input color (SRC1_COLOR, ONE_MINUS_SRC1_COLOR,
    SRC1_ALPHA or ONE_MINUS_SRC1_ALPHA) using fixed function will produce
    undefined results.  To produce input for the second source color, a shader
    must be used.

    When using a GLSL fragment shader with dual-source blending functions,
    the color output varyings are bound to the first and second inputs of a
    draw buffer using BindFragDataLocationIndexed as described in the "Shader
    Outputs" subsection of Section 3.12.2. Data written to the first of these outputs
    becomes the first source color input to the blender (corresponding to
    SRC_COLOR and SRC_ALPHA). Data written to the second of these outputs
    generates the second source color input to the blender (corresponding to
    SRC1_COLOR and SRC1_ALPHA).

    If the second color input to the blender is not written in the shader, or if
    no output is bound to the second input of a blender, the result of the blending
    operation is not defined.

    Other shading languages may define similar methods for producing the first
    and second color inputs to blending equations.

Additions to Chapter 5 of the OpenGL 3.2 Specification (Compatibility Profile) (Special
Functions)

    None.

Additions to Chapter 6 of the OpenGL 3.2 Specification (Compatibility Profile) (State and
State Requests)

    None.

Dependencies on ARB_fragment_shader

    If ARB_fragment_shader is not supported then references to
    ARB_fragment_shader in section 4.1.8 and elsewhere in this document should
    be removed. In this case, there is no way to generate the second color input
    to the blending equation unless a further extension to another shading
    language is defined and used.

Dependencies on ARB_draw_buffers

    Using dual-source blending functions may consume additional outputs from
    hardware shading units and therefore can reduce the number of draw buffers
    that may be attached to a single frame buffer when dual-source blending
    functions are enabled. In this case, the value of 
    MAX_DUAL_SOURCE_DRAW_BUFFERS may be less than the value of
    MAX_DRAW_BUFFERS. If ARB_draw_buffers is not supported then the value of
    MAX_DUAL_SOURCE_DRAW_BUFFERS will be 1. Furthermore, the discussion
    in the subsection entitled "Dual Source Blending and Multiple Draw Buffers"
    may be discarded.

Dependencies on EXT_blend_func_separate

    If EXT_blend_func_separate is not supported, remove references to
    BlendFuncSeparate. Also, remove any references to BLEND_SRC_ALPHA and
    BLEND_DST_ALPHA, and replace references to BLEND_SRC_RGB and BLEND_DST_RGB
    with BLEND_SRC and BLEND_DST, respectively. In this case, the new blend
    functions may only be enabled via the BlendFunc procedure.

Dependencies on ARB_draw_buffers_blend

    If ARB_draw_buffers_blend is not supported, all references to BlendFunci
    and BlendFuncSeparatei should be removed. In this case, the blend
    functions for all attached draw buffers will be the same.

Interactions with NV_gpu_program5

    If NV_gpu_program5 is supported, fragment result bindings 
    "result.color[n].primary" and "result.color[n].secondary" can be used to
    specify the <n>th color outputs for index 0 and 1, respectively.

Additions to the AGL/GLX/WGL Specifications

    None.

GLX Protocol

    None.

Errors

    The error INVALID_OPERATION is generated by Begin or any procedure that
    implicitly calls Begin if any draw buffer has a blend function requiring the
    second color input (SRC1_COLOR, ONE_MINUS_SRC1_COLOR, SRC1_ALPHA or
    ONE_MINUS_SRC1_ALPHA), and a framebuffer is bound that has more than
    the value of MAX_DUAL_SOURCE_DRAW_BUFFERS-1 active color attachments.

New State

    Table 6.21 (p. 286)

    Get Value                 Type  Get Command   Initial Value   Description          Sec    Attribute
    ------------------------  ----  ------------  -------------   -------------------  -----  ---------
    BLEND_SRC_RGB             Z19   GetIntegerv   ONE             Blending source RGB  4.1.8  color-buffer
                                                                  function
    BLEND_SRC_ALPHA           Z19   GetIntegerv   ONE             Blending source A    4.1.8  color-buffer
                                                                  function
    BLEND_DST_RGB             Z19   GetIntegerv   ZERO            Blending dest. RGB   4.1.8  color-buffer
                                                                  function
    BLEND_DST_ALPHA           Z19   GetIntegerv   ZERO            Blending dest. A     4.1.8  color-buffer
                                                                  function

NOTE: The only change is that Z14 and Z15 change to Z19 for the existing blend
function state. No new state is actually added to the OpenGL Specification.

New Implementation Dependent State

    Get Value                        Type  Get Command     Minimum Value    Description             Sec.     Attribute
    ---------                        ----  -----------     -------------    -------------------     -----    ---------
    MAX_DUAL_SOURCE_DRAW_BUFFERS     Z+    GetIntegerv     1                Maximum number of       4.1.8    -
                                                                            active draw buffers
                                                                            when using dual-source
                                                                            blending

Example Use Cases

    There are several potential uses for this functionality. A first example
    is in the implementation of sub-pixel accurate font rendering algorithms.
    Given a known layout of pixel elements (red, green and blue components),
    coverage may be calculated independently for each element and passed
    to the blender in the second source color as a per-channel opacity. To use
    this mode, use the following blend functions:

        glBlendFunc(GL_SRC1_COLOR, GL_ONE_MINUS_SRC1_COLOR);

    As a second example, consider a partially reflective colored glass window.
    It will attenuate light passing through it, and reflect some of the light
    that strikes it. Using an appropriate combination of functions, this effect
    may be simulated in a single pass using only fixed-function blending
    hardware. In this case, the following blend functions may be used:

        glBlendFunc(GL_SRC_ALPHA, GL_SRC1_COLOR);

Issues

    1) Should the new tokens be SRC1_COLOR and SRC2_COLOR (1-based), or
       be SRC0_COLOR and SRC1_COLOR.

       RESOLVED: Indices in OpenGL are generally zero based. These follow
       suit.

    2) What happens when rendering using a dual-source blend function using
       fixed-function?

       RESOLVED: There is no reasonable way to generate the second source color
       for blending using fixed-function fragment processing. However, as it is
       possible to set the blend function and then enable a shader, there isn't
       really a clean way to report an error. Therefore, we allow it, but leave
       the result undefined.

    2a) Can't we use an existing output from fixed function, like back color,
        to make this work?

       DISCUSSION: We could relabel things. For example, make the front color
       be the first input to blending and the back color the second input. This
       kind of thing would come at the cost of lost fixed function capability,
       possible ambiguity and added complexity in the fixed function
       specification. The new functionality in this extension is most useful
       when reading data from multiple textures or other complex sources that
       would just be too complex to express with fixed function processing.
       For these reasons, rendering through dual-source blending functions using
       the fixed function pipeline is not supported and will produce undefined
       results.

    2b) Then why write this against OpenGL 2.1 which includes fixed-function?
        Why not write against OpenGL 3.x that only supports shaders anyway?

       DISCUSSION: Because this extension adds functionality to existing
       extensions and those are written against OpenGL 2.1. Furthermore, the
       functionality described here does not rely on any core feature provided
       by OpenGL 3.x and can be easily built upon and used in implementations of
       OpenGL 2.1 or earlier versions of the OpenGL Specification.

       RESOLVED: Updated to stand against OpenGL 3.2, but kept the fixed function
       issues in the spec.

    3) Why is this not orthogonal and interoperable with ARB_draw_buffers?

       RESOLVED: This is functionality that has existed in hardware for some
       time and been made available via other graphics APIs. In some hardware
       and APIs, the second color input from the shader is actually what would
       have been written to draw buffer 1. This is the functionality that is
       guaranteed to be universally supported. This extension does not preclude
       use with multiple draw buffers except exclusion through implementation
       defined limits. If future hardware supports multiple color outputs
       simultaneously to multiple draw buffers, it can simply advertise higher
       limits.

    4) Can we not add an implementation state query to find out if it's
       available with multiple draw buffers?

       RESOLVED: Done. Query MAX_DUAL_SOURCE_DRAW_BUFFERS. If this returns
       the same value as MAX_DRAW_BUFFERS then the functions are orthogonal.
       If this returns 1, then they cannot be used together. If it returns some
       value between 1 and MAX_DRAW_BUFFERS, then dual-source blending
       may consume some additional hardware routing resources, but can be used
       with multiple draw buffers provided the MAX_DUAL_SOURCE_DRAW_BUFFERS
       limit is not exceeded.

    5) Should there also be a Link error if the fragment shader uses both an
       index=1 output below MAX and an index=0 output greater than or equal to
       MAX? The quoted begin-time error leaves open the possibility of an app
       doing something like BindFragDataLocationIndexed(colorNumber=0, index=0)
       + (colorNumber=0, index=1) + (colorNumber=1, index=0), then rendering
       without using the src1 blend functions. If an implementation aliases
       index=1 onto other index=0 outputs, then it wouldn't be able to handle
       that case.

       DISCUSSION: The begin time error language states '... if any draw buffer
       has a blend function requiring the second color input ...'. This means
       that the outputs can be bound to non-zero indices, but if the blend
       function does not consume that output, no error will be generated. In
       theory, an implementation could ignore output bound to color=0, index=1
       in this case and operate as if it were not there. However, it makes no
       sense for the linker to accept such a configuration of outputs because
       the underlying hardware may not be able to support it. Therefore, we can
       generate a link time error, thus eliminating this begin-time check and
       potentially improving run-time performance.

Revision History

    Rev.    Date      Author    Changes
    ----  --------    --------  -----------------------------------------
    13    05/22/2015  mjk       Fix misspellings
    12    02/05/2010  istewart  Add interactions with NV_gpu_program5.
    11    01/26/2010  pbrown    Assign enum values.
    10    01/14/2010  pbrown    Add spec language allowing for a link error if
                                explicit output bindings don't leave enough 
                                space for array outputs.  Clarify that any 
                                automatic assignments for fragment outputs
                                will use color index zero.
     9    12/10/2009  Jon Leech Fix typos in blending equation table, remove
                                ARB suffixes for core 3.3 inclusion, clean
                                up "GL_TOKEN" vs. "the value of GL_TOKEN".
     8    11/19/2009  gsellers  Remove SRC0_COLOR etc. enums, use old ones
                                instead. Use previously defined value for
                                SRC1_ALPHA. Update text to match.
     7    10/26/2009  gsellers  Change BindFragDataLocationIndexedARB to take a
                                numerical index instead of an enum. Clarify
                                behavior in several places. Add issue 5.
     6    10/20/2009  gsellers  Update to diff to OpenGL 3.2 (Compatibility) spec.
                                Add BindFragDataLocationIndexedARB and
                                GetFragDataIndexARB. Remove idea of making shader
                                outputs arrays. Define Begin time error when
                                blend func is SRC1_* for FBO with >=
                                MAX_DUAL_SOURCE_DRAW_BUFFERS draw buffers.
     5    05/21/2009  gsellers  Clarify meaning of MAX_DUAL_SOURCE_BUFFERS_ARB.
                                Clarify the (lack of) interaction with fixed
                                function fragment processing and further
                                justify lack of support (Issues 2a and 2b).
                                Clarify modification to state.
     4    05/19/2009  gsellers  Allow simultaneous use of ARB_draw_buffers with
                                this extension;
                                add MAX_DUAL_SOURCE_DRAW_BUFFERS_ARB.
                                Document interaction with ARB_draw_buffers_blend.
     3    05/19/2009  gsellers  Remove access via gl_FragData, replace with user
                                defined output varyings.
     2    05/15/2009  gsellers  Minor cleanup. Add usage examples.
     1    05/14/2009  gsellers  Initial draft