Função glBlendFunc

A função glBlendFunc especifica aritmética de pixel.

Sintaxe

void WINAPI glBlendFunc(
   GLenum sfactor,
   GLenum dfactor
);

Parâmetros

sfactor

Especifica como os fatores de mesclagem de origem vermelho, verde, azul e alfa são calculados. Nove constantes simbólicas são aceitas: 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 e GL_SRC_ALPHA_SATURATE.

dfactor

Especifica como os fatores de mesclagem de destino vermelho, verde, azul e alfa são calculados. Oito constantes simbólicas são aceitas: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA e GL_ONE_MINUS_DST_ALPHA.

Retornar valor

Essa função não retorna um valor.

Códigos de erro

Os códigos de erro a seguir podem ser recuperados pela função glGetError .

Nome	Significado
GL_INVALID_ENUM	O refatorar ou o dfactor não era um valor aceito.
GL_INVALID_OPERATION	A função foi chamada entre uma chamada para glBegin e a chamada correspondente para glEnd.

Comentários

No modo RGB, os pixels podem ser desenhados usando uma função que combina os valores RGBA de entrada (origem) com os valores RGBA que já estão no framebuffer (os valores de destino). Por padrão, a mesclagem está desabilitada. Use glEnable e glDisable com o argumento GL_BLEND para habilitar e desabilitar a mesclagem.

Quando habilitado, glBlendFunc define a operação de mesclagem. O parâmetro sfactor especifica qual dos nove métodos é usado para dimensionar os componentes de cor de origem. O parâmetro dfactor especifica quais dos oito métodos são usados para dimensionar os componentes de cor de destino. Os onze métodos possíveis são descritos na tabela a seguir. Cada método define quatro fatores de escala um para vermelho, verde, azul e alfa.

Na tabela e nas equações subsequentes, os componentes de cor de origem e destino são chamados de (R? , G? , B? , A? ) e (R_d , G_d , B_d , A_d ). Entende-se que eles têm valores inteiros entre zero e (k_R , k_G , k_R , k_A ), em que

k_R = 2^mR - 1

k_G = 2^mG - 1

k_B = 2^mB - 1

k_A = 2^mA - 1

e (m_R , m_G , m_B , m_A ) é o número de bitplanes vermelhos, verdes, azuis e alfa.

Os fatores de escala de origem e destino são chamados de (s_R , s_G , s_B , s_A ) e (d_R , d_G , d_B , d_A ). Os fatores de escala descritos na tabela, indicados (f_R , f_G , f_B , f_A ), representam fatores de origem ou de destino. Todos os fatores de escala têm 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? / kA )
GL_DST_ALPHA	(Ad / kA , Ad / kA , Ad / kA , Ad / kA )
GL_ONE_MINUS_DST_ALPHA	(1,1,1,1) - (Ad / kA , Ad / kA , Ad / kA , Ad / kA )
GL_SRC_ALPHA_SATURATE	(i,i,i, 1)

Na tabela,

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

Para determinar os valores RGBA combinados de um pixel ao desenhar no modo RGBA, o sistema usa as seguintes equações:

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

G (d) = min( k_G , G? s_G + G_{dD G} )

B (d) = min( k_B, B? s_B + dB d_B )

A (d) = min( k_A , A? s_A + A_{dD A} )

Apesar da precisão aparente das equações acima, a mesclagem aritmética não é exatamente especificada, pois a mesclagem opera com valores de cor inteiro imprecisos. No entanto, um fator de mesclagem que deve ser igual a um tem a garantia de não modificar seu multiplicando, e um fator de mistura igual a zero reduz sua multiplicação para zero. Assim, por exemplo, quando o refatoro é GL_SRC_ALPHA, o dfactor é GL_ONE_MINUS_SRC_ALPHA e A? é igual a k_A, as equações reduzem à substituição simples:

R_d = R?

G_d = G?

B_d = B?

A_d = A?

Exemplos

A transparência é melhor implementada usando glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) com primitivos classificados do mais distante para o mais próximo. Observe que esse cálculo de transparência não requer a presença de bitplanos alfa no framebuffer.

Você também pode usar glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) para renderizar pontos e linhas suavizados em ordem arbitrária.

Para otimizar a suavização de polígono, use glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ONE) com polígonos classificados do mais próximo ao mais distante. (Consulte o argumento GL_POLYGON_SMOOTH em glEnable para obter informações sobre suavização de polígono.) Os bitplanos alfa de destino, que devem estar presentes para que essa função de combinação opere corretamente, armazenam a cobertura acumulada.

O alfa de entrada (origem) é uma opacidade material, variando de 1,0 (K_A ), representando opacidade completa, até 0,0 (0), representando total transparência.

Quando você habilita mais de um buffer de cores para desenho, cada buffer habilitado é combinado separadamente e o conteúdo do buffer é usado para a cor de destino. (Consulte glDrawBuffer.)

A mesclagem afeta apenas a renderização RGBA. Ele é ignorado por renderizadores de índice de cores.

As seguintes funções recuperam informações relacionadas a glBlendFunc:

glGet com GL_BLEND_SRC de argumento

glGet com GL_BLEND_DST de argumento

glIsEnabled com argumento GL_BLEND

Requisitos

Requisito	Valor
Cliente mínimo com suporte	Windows 2000 Professional [somente aplicativos da área de trabalho]
Servidor mínimo com suporte	Windows 2000 Server [somente aplicativos da área de trabalho]
Cabeçalho	Gl.h
Biblioteca	Opengl32.lib
DLL	Opengl32.dll

Confira também

glAlphaFunc

glBegin

glClear

glDisable

glDrawBuffer

glEnable

glGet

glIsEnabled

glLogicOp

glStencilFunc