glBlendFunc man page on DigitalUNIX

Man page or keyword search:  
man Server   12896 pages
apropos Keyword Search (all sections)
Output format
DigitalUNIX logo
[printable version]

glBlendFunc(3G)						       glBlendFunc(3G)

       glBlendFunc - specify pixel arithmetic

       void glBlendFunc(
	       GLenum sfactor,
	       GLenum dfactor );

       Specifies  how  the red, green, blue, and alpha source blending factors
       are computed. The following symbolic constants are  accepted:  GL_ZERO,
       GL_SRC_ALPHA_SATURATE.  The  initial value is GL_ONE.  Additionally, if
       the GL_ARB_imaging extension is supported, the following constants  are
       STANT_ALPHA,  GL_ONE_MINUS_CONSTANT_ALPHA.   Specifies  how  the	  red,
       green,  blue,  and  alpha  destination  blending	 factors are computed.
       Eight symbolic constants are accepted: GL_ZERO,	GL_ONE,	 GL_SRC_COLOR,
       GL_DST_ALPHA, and GL_ONE_MINUS_DST_ALPHA. The initial value is GL_ZERO.
       Additionally, if the GL_ARB_imaging extension is supported, the follow‐
       ing  constants  are  accepted:	GL_CONSTANT_COLOR,   GL_ONE_MINUS_CON‐

       In  RGBA	 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). Blending is initially dis‐
       abled. Use glEnable() and glDisable() with argument GL_BLEND to	enable
       and disable blending.

       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 following table. Each method defines four scale fac‐
       tors, 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[s], G[s], B[s], A[s] ) and (R[d],
       G[d], B[d], A[d] ). The color specified by glBlendColor()  is  referred
       to  as  (R[c],  G[c], B[c], A[c] ). They are understood to have integer
       values between 0 and (k[R], k[G], k[B], k[A] ), where

       k[c] = 2^m[c] - 1

       and (m[R], m[G], m[B], m[A] ) is the number of red,  green,  blue,  and
       alpha bitplanes.

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

       Parameter		     (f[R], f[G],  f[B],  f[A] )
       GL_ZERO			     (0, 0, 0, 0 )
       GL_ONE			     (1, 1, 1, 1 )
       GL_SRC_COLOR		     (R[s] / k[R], G[s]	 /  k[G],  B[s]	 /
				     k[B], A[s] / k[A] )
       GL_ONE_MINUS_SRC_COLOR	     (1,  1, 1, 1 ) - (R[s] / k[R], G[s] /
				     k[G], B[s] / k[B], A[s] / k[A] )
       GL_DST_COLOR		     (R[d] / k[R], G[d]	 /  k[G],  B[d]	 /
				     k[B], A[d] / k[A] )

       GL_ONE_MINUS_DST_COLOR	     (1,  1, 1, 1 ) - (R[d] / k[R], G[d] /
				     k[G], B[d] / k[B], A[d] / k[A] )
       GL_SRC_ALPHA		     (A[s] / k[A], A[s]	 /  k[A],  A[s]	 /
				     k[A], A[s] / k[A] )
       GL_ONE_MINUS_SRC_ALPHA	     (1,  1, 1, 1 ) - (A[s] / k[A], A[s] /
				     k[A], A[s] / k[A], A[s] / k[A] )
       GL_DST_ALPHA		     (A[d] / k[A], A[d]	 /  k[A],  A[d]	 /
				     k[A], A[d] / k[A] )
       GL_ONE_MINUS_DST_ALPHA	     (1,  1, 1, 1 ) - (A[d] / k[A], A[d] /
				     k[A], A[d] / k[A], A[d] / k[A] )
       GL_SRC_ALPHA_SATURATE	     (i, i, i, 1 )
       GL_CONSTANT_COLOR	     (R[c], G[c], B[c], A[c])
       GL_ONE_MINUS_CONSTANT_COLOR   (1, 1, 1, 1 ) -  (R[c],  G[c],  B[c],
       GL_CONSTANT_ALPHA	     (A[c], A[c], A[c], A[c])
       GL_ONE_MINUS_CONSTANT_ALPHA   (1,  1,  1,  1 ) - (A[c], A[c], A[c],

       In the table,

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

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

       R[d] min ( k[R], R[s]s[R]+R[d]d[R] )

       G[d]( k[G], G[s]s[G]+G[d]d[G] )

       B[d]( k[B], B[s]s[B]+B[d]d[B] )

       A[d]( k[A], A[s]s[A]+A[d]d[A] )

       Despite	the apparent precision of the above equations, blending arith‐
       metic is not exactly specified, because blending operates  with	impre‐
       cise integer color values. However, a blend factor that should be equal
       to 1 is guaranteed not to modify its multiplicand, and a	 blend	factor
       equal  to 0 reduces its multiplicand to 0. For example, when sfactor is
       GL_SRC_ALPHA, dfactor is GL_ONE_MINUS_SRC_ALPHA, and A[s] is  equal  to
       k[A], the equations reduce to simple replacement:

       R[d]  = mark   R[s] G[d] = lineup G[s] B[d] = lineup B[s] A[d] = lineup

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

       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 glDrawBuffer().)

       Blending affects only RGBA rendering. It is ignored by color index ren‐

       GL_ONE_MINUS_CONSTANT_ALPHA are only available if the GL_ARB_imaging is
       supported by your implementation.

       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().

       glGet() with argument GL_BLEND_SRC
       glGet() with argument GL_BLEND_DST
       glIsEnabled() with argument GL_BLEND

       Transparency  is	 best  implemented using blend function (GL_SRC_ALPHA,
       GL_ONE_MINUS_SRC_ALPHA) with primitives sorted from farthest  to	 near‐
       est. Note that this transparency calculation does not require the pres‐
       ence 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 func‐
       tion to operate correctly, store the accumulated coverage.

       glAlphaFunc(3),	 glBlendColor(3),   glBlendEquation(3),	   glClear(3),
       glDrawBuffer(3), glEnable(3), glLogicOp(3), glStencilFunc(3)


List of man pages available for DigitalUNIX

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net