glBlendFunc — specify pixel arithmetic
| void glBlendFunc( | GLenum sfactor, | 
| GLenum dfactor ); | 
| void glBlendFunci( | GLuint buf, | 
| GLenum sfactor, | |
| GLenum dfactor ); | 
buf
                
              
            
                    For glBlendFunci, specifies the index of the draw
                    buffer for which to set the blend function.
                
sfactor
                
              
            
                    Specifies how the red, green, blue,
                    and alpha source blending factors are computed.
                    The initial value is GL_ONE.
                
dfactor
                
              
            
                    Specifies how the red, green, blue,
                    and alpha destination blending factors are computed.
                    The following symbolic constants are accepted:
                    GL_ZERO,
                    GL_ONE,
                    GL_SRC_COLOR,
                    GL_ONE_MINUS_SRC_COLOR,
                    GL_DST_COLOR,
                    GL_ONE_MINUS_DST_COLOR,
                    GL_SRC_ALPHA,
                    GL_ONE_MINUS_SRC_ALPHA,
                    GL_DST_ALPHA,
                    GL_ONE_MINUS_DST_ALPHA.
                    GL_CONSTANT_COLOR,
                    GL_ONE_MINUS_CONSTANT_COLOR,
                    GL_CONSTANT_ALPHA, and
                    GL_ONE_MINUS_CONSTANT_ALPHA.
                    The initial value is GL_ZERO.
                
            Pixels can be drawn using a function that blends
            the incoming (source) RGBA values with the RGBA values
            that are already in the frame buffer (the destination values).
            Blending is initially disabled.
            Use glEnable or glEnablei
			and glDisable or glDisablei
			with argument GL_BLEND to enable and disable blending for all or one draw buffer.
        
            glBlendFunc defines the operation of blending for all draw buffers when it is enabled.
            glBlendFunci defines the operation of blending for a single draw buffer
            specified by buf when enabled for that draw buffer.
            sfactor specifies which method is used to scale the
            source color components.
            dfactor specifies which method is used to scale the
            destination color components.
            Both parameters must be one of the following symbolic constants:
                    GL_ZERO,
                    GL_ONE,
                    GL_SRC_COLOR,
                    GL_ONE_MINUS_SRC_COLOR,
                    GL_DST_COLOR,
                    GL_ONE_MINUS_DST_COLOR,
                    GL_SRC_ALPHA,
                    GL_ONE_MINUS_SRC_ALPHA,
                    GL_DST_ALPHA,
                    GL_ONE_MINUS_DST_ALPHA,
                    GL_CONSTANT_COLOR,
                    GL_ONE_MINUS_CONSTANT_COLOR,
                    GL_CONSTANT_ALPHA,
                    GL_ONE_MINUS_CONSTANT_ALPHA,
                    GL_SRC_ALPHA_SATURATE,
            The possible methods are described in the following table.
            Each method defines four scale factors,
            one each for red, green, blue, and alpha.
            In the table and in subsequent equations, source
            and destination color components are referred to as
            
            Source and destination scale factors are referred to as
            
                Prior to blending, unsigned normalized fixed-point color components undergo
                an implied conversion to floating-point using equation 2.1. This conversion must
                leave the values 0 and 1 invariant. Blending computations are treated as if carried
                out in floating-point and will be performed with a precision and dynamic range no
                lower than that used to represent destination components.
                If the value of GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING for the
                framebuffer attachment corresponding to the destination buffer is GL_SRGB,
                the R, G, and B destination color values (after conversion from fixed-point
                to floating-point) are considered to be encoded for the sRGB color space and
                hence must be linearized prior to their use in blending. Each R, G, and B component
                is converted in the same fashion described for sRGB texture components.
        
| Parameter | |
|---|---|
| GL_ZERO | |
| GL_ONE | |
| GL_SRC_COLOR | |
| GL_ONE_MINUS_SRC_COLOR | |
| GL_DST_COLOR | |
| GL_ONE_MINUS_DST_COLOR | |
| GL_SRC_ALPHA | |
| GL_ONE_MINUS_SRC_ALPHA | |
| GL_DST_ALPHA | |
| GL_ONE_MINUS_DST_ALPHA | |
| GL_CONSTANT_COLOR | |
| GL_ONE_MINUS_CONSTANT_COLOR | |
| GL_CONSTANT_ALPHA | |
| GL_ONE_MINUS_CONSTANT_ALPHA | |
| GL_SRC_ALPHA_SATURATE | 
In the table,
            
To determine the blended RGBA values of a pixel, the system uses the following equations:
            
            If the value of GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING for the framebuffer
            attachment corresponding to the destination buffer is GL_SRGB, the R, G, and B
            values after blending are converted into the non-linear sRGB color space by computing
                
            where cl is the R, G, or B element and cs is the result (effectively converted into an
            sRGB color space).
            If GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING is not GL_SRGB, then
            cs = cl:
            The resulting cs values for R, G, and B, and the unmodified A form a new
            RGBA color value. If the color buffer is fixed-point, each component is clamped
            to the range [0; 1] and then converted to a fixed-point value using equation
        
            Transparency is best implemented using blend function
            (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
            with primitives sorted from farthest to nearest.
            Note that this transparency calculation does not require
            the presence of alpha bitplanes in the frame buffer.
        
            Incoming (source) alpha is correctly thought of as a material opacity,
            ranging from 1.0
            (
When more than one color buffer is enabled for drawing, the GL performs blending separately for each enabled buffer, using the contents of that buffer for destination color. (See glDrawBuffers.)
            GL_INVALID_ENUM is generated if either sfactor
            or dfactor is not an accepted value.
        
            GL_INVALID_VALUE is generated by glBlendFunci if buf is greater
            than or equal to the value of GL_MAX_DRAW_BUFFERS.
        
            glGet with argument GL_BLEND_SRC
        
            glGet with argument GL_BLEND_DST
        
            glIsEnabled with argument GL_BLEND
        
| OpenGL ES API Version | ||||
|---|---|---|---|---|
| Function Name | 2.0 | 3.0 | 3.1 | 3.2 | 
| glBlendFunc | ✔ | ✔ | ✔ | ✔ | 
| glBlendFunci | - | - | - | ✔ | 
glBlendColor, glBlendEquation, glBlendFuncSeparate, glClear, glDrawBuffers, glEnable,
Copyright © 1991-2006 Silicon Graphics, Inc. Copyright © 2010-2015 Khronos Group. This document is licensed under the SGI Free Software B License. For details, see https://khronos.org/registry/OpenGL-Refpages/LICENSES/LicenseRef-FreeB.txt.