glBlendFunc -	specify	pixel arithmetic

C Specification

  void glBlendFunc( GLenum sfactor,
		    GLenum dfactor )


  sfactor  Specifies how the red, green, blue, and alpha source blending
	   factors are computed.  Nine symbolic	constants are accepted:

  dfactor  Specifies how the red, green, blue, and alpha destination blending
	   factors are computed.  Eight	symbolic constants are accepted:


  In RGB mode, 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).  By default,	blending is disabled.  Use
  glEnable and glDisable with argument GL_BLEND	to enable and disable

  glBlendFunc defines the operation of blending	when it	is enabled.  sfactor
  specifies which of nine methods is used to scale the source color
  components.  dfactor specifies which of eight	methods	is used	to scale the
  destination color components.	 The eleven possible methods are described in
  the table below.  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	(R ,G ,B ,A ) and (R ,G	,B ,A ).  They are
                                  s  s  s  s        d  d  d  d
  understood to	have integer values between zero and (k ,k ,k ,k ), where
						       R  G  B	A
				    k  = 2   - 1

  and (mR,mG,mB,mA) is the number of red, green, blue, and alpha bitplanes.

  Source and destination scale factors are referred to as (s ,s ,s ,s )	and
                                                            R  G  B  A
  (d ,d ,d ,d ).  The scale factors described in the table, denoted
    R  G  B  A
  (f ,f ,f ,f ), represent either source or destination	factors.  All scale
    R  G  B  A
  factors have range [0,1].

    |     parameter         |            (f ,  f ,  f ,  f )              |
    |                       |              R    G    B    A               |
    |	           	    |		                 		  |
    |	    GL_ZERO	    |		     (0, 0, 0, 0)		  |
    |	           	    |		                 		  |
    |	     GL_ONE	    |		     (1, 1, 1, 1)		  |
    |	           	    |		                 		  |
    |	  GL_SRC_COLOR	    |	     (R	/k , G /k , B /k , A /k	)	  |
    |	           	    |	       s  R   s  G   s  B   s  A	  |
    |	           	    |		                 		  |
    |GL_ONE_MINUS_SRC_COLOR | (1, 1, 1, 1) - (R	/k , G /k , B /k , A /k	) |
    |	           	    |	               s  R   s	 G   s  B   s  A  |
    |	           	    |		                 		  |
    |	  GL_DST_COLOR	    |	     (R	/k , G /k , B /k , A /k	)	  |
    |	           	    |	       d  R   d  G   d  B   d  A	  |
    |	           	    |		                 		  |
    |GL_ONE_MINUS_DST_COLOR | (1, 1, 1, 1) - (R	/k , G /k , B /k , A /k	) | 
    |	           	    |	               d  R   d	 G   d  B   d  A  |
    |	           	    |		                 		  |
    |	  GL_SRC_ALPHA	    |	     (A	/k , A /k , A /k , A /k	)	  |
    |	           	    |	       s  R   s  G   s  B   s  A	  |
    |	           	    |		                 		  |
    |	           	    |		                 		  |
    |GL_ONE_MINUS_SRC_ALPHA | (1, 1, 1, 1) - (A	/k , A /k , A /k , A /k	) |
    |	           	    |	               s  R   s  G   s  B   s  A  |
    |	           	    |		                 		  |
    |	           	    |		                 		  |
    |	  GL_DST_ALPHA	    |	     (A	/k , A /k , A /k , A /k	)	  |
    |	           	    |	       d  R   d  G   d  B   d  A	  |
    |	           	    |		                 		  |
    |GL_ONE_MINUS_DST_ALPHA | (1, 1, 1, 1) - (A	/k , A /k , A /k , A /k	) |
    |	           	    |	               d  R   d  G   d  B   d  A  |
    |	           	    |		                 		  |
    |	           	    |		                 		  |
    |GL_SRC_ALPHA_SATURATE  |		     (i,  i,  i,  1)              |
    |	           	    |		                 		  |

  In the table,

			    i =	min(A ,	k -A ) / k 
                                     s   A  d     A

  To determine the blended RGBA	values of a pixel when drawing in RGB mode,
  the system uses the following	equations:

			      R  = min(k ,  R s +R d )
                               d        R    s R  d R

			      G  = min(k ,  G s +G d )
                               d        G    s G  d G

			      B  = min(k ,  B s +B d )
                               d        B    s B  d B

			      A  = min(k ,  A s +A d )
                               d        A    s A  d A

  Despite the apparent precision of the	above equations, blending arithmetic
  is not exactly specified, because blending operates with imprecise integer
  color	values.	 However, a blend factor that should be	equal to one is
  guaranteed not to modify its multiplicand, and a blend factor	equal to zero
  reduces its multiplicand to zero.  Thus, for example,	when sfactor is
  GL_SRC_ALPHA,	dfactor	is GL_ONE_MINUS_SRC_ALPHA, and A  is equal to k  the
                                                         s              A
  equations reduce to simple replacement:

				      R  = R 
                                       d    s

				      G  = G 
                                       d    s

				      B  = B 
                                       d    s

				      A  = A 
                                       d    s


  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.

  Blend	function (GL_SRC_ALPHA,	GL_ONE_MINUS_SRC_ALPHA)	is also	useful for
  rendering antialiased	points and lines in arbitrary order.

  Polygon antialiasing is optimized using blend	function
  (GL_SRC_ALPHA_SATURATE, GL_ONE) with polygons	sorted from nearest to
  farthest.  (See the glEnable,	glDisable reference page and the
  GL_POLYGON_SMOOTH argument for information on	polygon	antialiasing.)
  Destination alpha bitplanes, which must be present for this blend function
  to operate correctly,	store the accumulated coverage.


  Incoming (source) alpha is correctly thought of as a material	opacity,
  ranging from 1.0 (K ), representing complete opacity,	to 0.0 (0),
  representing complete transparency.

  When more than one color buffer is enabled for drawing, blending is done
  separately for each enabled buffer, using for	destination color the
  contents of that buffer.  (See glDrawBuffer.)

  Blending affects only	RGB rendering.	It is ignored by color index


  GL_INVALID_ENUM is generated if either sfactor or dfactor is not an
  accepted value.

  GL_INVALID_OPERATION is generated if glBlendFunc is executed between the 
  execution of glBegin and the corresponding execution of glEnd.

Associated Gets

  glGet	with argument GL_BLEND_SRC
  glGet	with argument GL_BLEND_DST
  glIsEnabled with argument GL_BLEND

See Also

  glAlphaFunc, glClear,	glDrawBuffer, glEnable,	glLogicOp, glStencilFunc

Introduction | Alphabetic | Specification

Last Edited: Fri, May 26, 1995