funzione glBlendFunc

La funzione glBlendFunc specifica l'aritmetica pixel.

Sintassi

void WINAPI glBlendFunc(
   GLenum sfactor,
   GLenum dfactor
);

Parametri

sfactor

Specifica come vengono calcolati i fattori di fusione di origine alfa, verde, verde e alfa. Vengono accettate nove costanti simboliche: 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

Specifica il modo in cui vengono calcolati i fattori di fusione di destinazione alfa, verde, verde, blu e alfa. Sono accettate otto costanti simboliche: 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.

Valore restituito

Questa funzione non restituisce un valore.

Codici di errore

I codici di errore seguenti possono essere recuperati dalla funzione glGetError .

Nome	Significato
GL_INVALID_ENUM	Sfactor o dfactor non è stato accettato.
GL_INVALID_OPERATION	La funzione è stata chiamata tra una chiamata a glBegin e la chiamata corrispondente a glEnd.

Commenti

In modalità RGB è possibile disegnare pixel usando una funzione che combina i valori RGBA in ingresso (origine) con i valori RGBA già presenti nel framebuffer (i valori di destinazione). Per impostazione predefinita, la fusione è disabilitata. Usare glEnable e glDisable con l'argomento GL_BLEND per abilitare e disabilitare la fusione.

Se abilitato, glBlendFunc definisce l'operazione di fusione. Il parametro sfactor specifica quale di nove metodi viene usato per ridimensionare i componenti del colore di origine. Il parametro dfactor specifica quale di otto metodi viene usato per ridimensionare i componenti del colore di destinazione. I undici metodi possibili sono descritti nella tabella seguente. Ogni metodo definisce quattro fattori di scala ognuno per rosso, verde, blu e alfa.

Nella tabella e nelle equazioni successive, i componenti del colore di origine e di destinazione vengono definiti (R? , G? , B? , A? ) e (R_d , G_d , B d , B d , A_d ). Essi sono compresi per avere valori interi tra zero e (k_R , k_G , k_R , k_R , k A ), dove

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 ) è il numero di bitplani rosso, verde, blu e alfa.

I fattori di scala di origine e di destinazione sono definiti (s_R , s _G , s_B, s_A ) e (d_R , d_G , d B , d _A ). I fattori di scala descritti nella tabella, denotati (f_R , f_G , f _B , f_A ), rappresentano fattori di origine o di destinazione. Tutti i fattori di scala hanno intervallo [0,1].

Parametro	(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) - (R? / kR , G? / k G , B? / k B? / k B , A? / kA )
GL_DST_COLOR	(Rd) / kR , GdkG , Bd / kB , Ad / / kA )
GL_ONE_MINUS_DST_COLOR	(1.1.1,1) - (RdkR , G / d kG , B d / kB / , Ad / kA )
GL_SRC_ALPHA	(A? / kA , A? / k A , A? / kA ,A? / kA )
GL_ONE_MINUS_SRC_ALPHA	(1,1,1) - (A? / k A, A? / kA , A? / k A ? / k A , A? / k A? / kA )
GL_DST_ALPHA	(Ad / kA , AdkA , A d / k A ,A / d / kA )
GL_ONE_MINUS_DST_ALPHA	(1,1,1) - (AdkA, / / A dkA , Ad / / k A )
GL_SRC_ALPHA_SATURATE	(i,i, i, 1)

Nella tabella,

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

Per determinare i valori RGBA misti di un pixel quando si disegna in modalità RGBA, il sistema usa le equazioni seguenti:

R (d) = min( k_R , R? sR_{d dR} + )

G (d) = min( k_G , G? sG_{d dG} + )

B (d) = min( k_B, B? sB_{d dB} ) +

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

Nonostante la precisione apparente delle equazioni precedenti, la fusione di aritmetici non è esattamente specificata, perché la fusione opera con valori di colore intero impreciso. Tuttavia, un fattore di blend che deve essere uguale a uno è garantito non modificare la sua moltiplicazione e un fattore di blend uguale a zero riduce il suo moltiplicatore a zero. Ad esempio, quando sfactor è GL_SRC_ALPHA, dfactor è GL_ONE_MINUS_SRC_ALPHA e A? è uguale a k_A, le equazioni riducono alla semplice sostituzione:

R_d = R?

G d = G?

B_d = B?

= D A?

Esempio

La trasparenza è meglio implementata usando glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) con primitive ordinate da lontano a più vicino. Si noti che questo calcolo di trasparenza non richiede la presenza di bitplani alfa nel framebuffer.

È anche possibile usare glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) per il rendering di punti e linee antialiased in ordine arbitrario.

Per ottimizzare l'antialiasing poligono, usare glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ONE) con poligoni ordinati dal più vicino al più lontano. Vedere l'argomento GL_POLYGON_SMOOTH in glEnable per informazioni sull'antialiasing poligono. Bitplani alfa di destinazione, che devono essere presenti per questa funzione di blend per funzionare correttamente, archiviare la copertura accumulata.

In ingresso (origine) alfa è un opacità materiale, compreso tra 1,0 (K_A ), che rappresenta l'opacità completa, a 0,0 (0), che rappresenta la trasparenza completa.

Quando si abilitano più buffer di colore per il disegno, ogni buffer abilitato viene unito separatamente e il contenuto del buffer viene usato per il colore di destinazione. Vedere glDrawBuffer.

La fusione influisce solo sul rendering RGBA. Viene ignorato dai renderer dell'indice dei colori.

Le funzioni seguenti recuperano informazioni correlate a glBlendFunc:

glGet con argomento GL_BLEND_SRC

glGet con argomento GL_BLEND_DST

glIsEnabled con argomento GL_BLEND

Requisiti

Requisito	Valore
Client minimo supportato	Windows 2000 Professional [solo app desktop]
Server minimo supportato	Windows 2000 Server [solo app desktop]
Intestazione	Gl.h
Libreria	Opengl32.lib
DLL	Opengl32.dll

Vedi anche

glAlphaFunc

glBegin

glClear

glDisable

glDrawBuffer

glEnable

glGet

glIsEnabled

glLogicOp

glStencilFunc