función glBlendFunc

La función glBlendFunc especifica aritmética de píxeles.

Sintaxis

void WINAPI glBlendFunc(
   GLenum sfactor,
   GLenum dfactor
);

Parámetros

sfactor

Especifica cómo se calculan los factores de fusión de origen rojo, verde, azul y alfa. Se aceptan nueve constantes simbólicas: GL_ZERO, GL_ONE, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA y GL_SRC_ALPHA_SATURATE.

dfactor

Especifica cómo se calculan los factores de combinación de destino rojo, verde, azul y alfa. Se aceptan ocho constantes simbólicas: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA y GL_ONE_MINUS_DST_ALPHA.

Valor devuelto

Esta función no devuelve ningún valor.

Códigos de error

La función glGetError puede recuperar los siguientes códigos de error.

Nombre	Significado
GL_INVALID_ENUM	sfactor o dfactor no era un valor aceptado.
GL_INVALID_OPERATION	Se llamó a la función entre una llamada a glBegin y la llamada correspondiente a glEnd.

Observaciones

En el modo RGB, los píxeles se pueden dibujar mediante una función que combina los valores RGBA entrantes (de origen) con los valores RGBA que ya están en el framebuffer (los valores de destino). De forma predeterminada, la combinación está deshabilitada. Use glEnable y glDisable con el argumento GL_BLEND para habilitar y deshabilitar la mezcla.

Cuando se habilita, glBlendFunc define el funcionamiento de la fusión. El parámetro sfactor especifica cuál de nueve métodos se usa para escalar los componentes de color de origen. El parámetro dfactor especifica cuál de los ocho métodos se usa para escalar los componentes de color de destino. Los once métodos posibles se describen en la tabla siguiente. Cada método define cuatro factores de escala uno para rojo, verde, azul y alfa.

En la tabla y en ecuaciones posteriores, los componentes de color de origen y destino se conocen como (R? , G? , B? , A? ) y (R_d , G_d , B_d , A_d ). Se entiende que tienen valores enteros entre cero y (k_R , k_G , k_R , k_A ), donde

k_R = 2^mR - 1

k_G = 2^mG - 1

k_B = 2^mB - 1

k_A = 2^mA - 1

y (m_R , m_G , m_B , m_A ) es el número de planos de bits rojo, verde, azul y alfa.

Los factores de escala de origen y destino se conocen como (s_R , s_G , s_B , s_A ) y (d_R , d_G , d_B , d_A ). Los factores de escala descritos en la tabla, indicados (f_R , f_G , f_B , f_A ), representan factores de origen o de destino. Todos los factores de escala tienen un intervalo [0,1].

Parámetro	(fR , fG , fB , fA )
GL_ZERO	(0,0,0,0)
GL_ONE	(1,1,1,1)
GL_SRC_COLOR	(R? / kR , G? / kG , B? / kB , A? / kA )
GL_ONE_MINUS_SRC_COLOR	(1,1,1,1) - (R? / kR , G? / kG , B? / kB , A? / kA )
GL_DST_COLOR	(Rd / kR , Gd / kG , Bd / kB , Ad / kA )
GL_ONE_MINUS_DST_COLOR	(1,1,1,1) - (Rd / kR , Gd / kG , Bd / kB , Ad / kA )
GL_SRC_ALPHA	(A? / kA , A? / kA , A? / kA , A? / kA )
GL_ONE_MINUS_SRC_ALPHA	(1,1,1,1) - (A? / kA , A? / kA , A? / kA , A ? / k A , A? / kA )
GL_DST_ALPHA	(Ad / kA , Ad / kA , Ad / kA , Adk A , A d / kA )
GL_ONE_MINUS_DST_ALPHA	(1,1,1,1) - (Ad / kA , A dkA , A d / kA , Ad / k A , Ad / kA )
GL_SRC_ALPHA_SATURATE	(i,i,i, 1)

En la tabla,

i = min (A? , k_A - _d ) / k_A

Para determinar los valores RGBA combinados de un píxel al dibujar en modo RGBA, el sistema usa las ecuaciones siguientes:

R (d) = min( k_R , R? s_R + _dd_R )

G (d) = min( k_G , G? s_{G G} + d d_G )

B (d) = min( k_B, B? s_{B B} + _{dd B} )

A (d) = min( k_A , A? s_{A D} + D_A )

A pesar de la precisión aparente de las ecuaciones anteriores, la combinación de aritmética no se especifica exactamente, ya que la combinación funciona con valores de color entero imprecisos. Sin embargo, se garantiza que un factor de mezcla que debe ser igual a uno no modifique su multiplicación y un factor de mezcla igual a cero reduce su multiplicación a cero. Por ejemplo, cuando sfactor es GL_SRC_ALPHA, dfactor es GL_ONE_MINUS_SRC_ALPHA y A? es igual a k_A, las ecuaciones se reducen a un reemplazo simple:

¿R_d = R?

¿G_d = G?

¿B_d = B?

¿A_d = A?

Ejemplos

La transparencia se implementa mejor mediante glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) con primitivos ordenados de más lejos a más cercano. Tenga en cuenta que este cálculo de transparencia no requiere la presencia de planos de bits alfa en el framebuffer.

También puede usar glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) para representar puntos y líneas antialias en orden arbitrario.

Para optimizar el suavizado de contornos de polígonos, use glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ONE) con polígonos ordenados de más cercano a más lejano. (Vea el argumento GL_POLYGON_SMOOTH en glEnable para obtener información sobre el suavizado de contornos de polígono). Los planos de bits alfa de destino, que deben estar presentes para que esta función de mezcla funcione correctamente, almacene la cobertura acumulada.

El alfa entrante (origen) es una opacidad material, que va desde 1,0 (K_A ), que representa la opacidad completa, hasta 0,0 (0), que representa la transparencia completa.

Al habilitar más de un búfer de color para dibujar, cada búfer habilitado se combina por separado y el contenido del búfer se usa para el color de destino. (Consulte glDrawBuffer).

La mezcla solo afecta a la representación RGBA. Los representadores de índice de color omiten .

Las siguientes funciones recuperan información relacionada con glBlendFunc:

glGet con GL_BLEND_SRC de argumentos

glGet con GL_BLEND_DST de argumentos

glIsEnabled con GL_BLEND de argumento

Requisitos

Requisito	Value
Cliente mínimo compatible	Windows 2000 Professional [solo aplicaciones de escritorio]
Servidor mínimo compatible	Windows 2000 Server [solo aplicaciones de escritorio]
Encabezado	Gl.h
Biblioteca	Opengl32.lib
Archivo DLL	Opengl32.dll

Vea también

glAlphaFunc

glBegin

glClear

glDisable

glDrawBuffer

glEnable

glGet

glIsEnabled

glLogicOp

glStencilFunc