glBlendFunc
(weitere exzellente Artikel) |
 |
Inhaltsverzeichnis
glBlendFunc
Name
glBlendFunc - Bestimmt das Verhalten beim Schreiben von Fragmenten (Pixeln) in den Framebuffer
Delphi-Spezifikation
procedure glBlendFunc(sfactor : TGLEnum; dfactor: TGLEnum);
Parameter
| sfactor | Gibt an, wie der Rot-, Grün-, Blau- und Alphaanteil des Quell-Blendfaktors berechnet wird. Folgende symbolische Konstanten sind erlaubt : GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA und GL_SRC_ALPHA_SATURATE. Vorgabewert ist GL_ONE. |
|---|---|
| dfactor | Gibt an, wie der Rot-, Grün-, Blau- und Alphaanteil des Ziel-Blendfaktors berechnet wird. Folgende symbolische Konstanten sind erlaubt : GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA und GL_ONE_MINUS_CONSTANT_ALPHA. Vorgabewert ist GL_ZERO. |
Beschreibung
Im RGBA-Modus, können Pixel so gezeichnet werden, dass anhand einer Funktion die ankommenden RGBA-Werte (Quelle) mit dem bereits im Framepuffer befindlichen RGBA-Werten (Ziel) gemischt werden. Mischung ist als Vorgabe deaktiviert, kann jedoch mit glEnable/glDisable und dem Token GL_BLEND gesteuert werden.
glBlendFunc beschreibt die Funktion der Mischung, sofern aktiviert. sfactor gibt dabei an welche Methode genutzt wird um die Quellfarbkomponenten zu skalieren. dfactor gibt an, welche der Methode genutzt wird um die Zielfarbkomponenten zu skalieren. Die möglichen Methoden werden in der folgenden Tabelle beschrieben, wobei jede insgesamt vier Skalierungsfaktoren besitzt, für die vier Komponenten einer RGBA-Farbe.
In der Tabelle (und allen folgenden Gleichungen), werden Quell- bzw. Zielfarbkomponenten als (Rs, Gs, Bs, As) und (Rd, Gd, Bd, Ad) dargestellt. Diese Komponenten besitzen Ganzzahlwerte, die zwischen 0 und (kR, kG, kB, kA) liegen, wobei
kc = 2^mc - 1;
und (mR, mG, mB, mA) gleich der Zahl der Rot-, Grün-, Blau- und Alphabitflächen ist. (Beispiel: Wenn man 8 Bit für eine Farbe (z.B. Rot) hat, dann ist kR = 2^8 - 1 = 255.)
Konstante Farbkomponenten (gesetzt mit glBlendColor) werden als (Rc, Gc, Bc, Ac) angegeben und werden nicht mit (kR, kG, kB, kA) skaliert, da sie bereits im Intervall [0,1] liegen.
Quell- und Zielskalierungsfaktoren werden als (sR, sG, sB, sA) und (dR, dG, dB, dA) angegeben. Die in der Tabelle beschriebenen Skalierungsfaktoren, angegeben als (fR, fG, fB, fA) repräsentieren entweder Quell- oder Zielfaktoren. Alle Skalierungsfaktoren liegen im Intervall [0,1].
| Parameter | (fR, fG, fB, fA) |
| GL_ZERO | (0,0,0,0) |
| GL_ONE | (1,1,1,1) |
| GL_SRC_COLOR | (Rs/kR, Gs/kG, Bs/kB, As/kA) |
| GL_ONE_MINUS_SRC_COLOR | (1,1,1,1) - (Rs/kR, Gs/kG, Bs/kB, As/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 | (As/kA, As/kA, As/kA, As/kA) |
| GL_ONE_MINUS_SRC_ALPHA | (1,1,1,1) - (As/kA, As/kA, As/kA, As/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_CONSTANT_COLOR | (Rc, Gc, Bc, Ac) |
| GL_ONE_MINUS_CONSTANT_COLOR | (1,1,1,1) - (Rc, Gc, Bc, Ac) |
| GL_CONSTANT_ALPHA | (Ac, Ac, Ac, Ac) |
| GL_ONE_MINUS_CONSTANT_ALPHA | (1,1,1,1) - (Ac, Ac, Ac, Ac) |
| GL_SRC_ALPHA_SATURATE | (i,i,i,1) |
In der Tabelle ist
i = min(As, kA - Ad) /kA
Um die gemischten RGBA-Werte eines Pixels im RGBA-Modus zu ermitteln, nutzt das System folgende Gleichungen (wenn die Mischungs-Gleichung Erweiterung nicht unterstützt wird) :
Rd = min(kR, RssR + RddR) Gd = min(kG, GssG + GddR) Bd = min(kB, BssB + BddB) Ad = min(kA, AssB + AddA)
Trotz der offensichtlichen Präzisions obiger Gleichungen, ist die Mischungsarithmetik nicht exakt spezifiziert, aufgrund Mischungsoperationen mit unpräzisen Ganzzahlwerten. Bei einem Mischungsfaktor von 1 ist jedoch garantiert, dass dieser seinen Mulitplikanten nicht verändert, und ein Mischungsfaktor gleich 0 verrringert seinen Multiplikanten auf 0. Wenn sfactor z.B. GL_SCR_ALPHA ist, und dfactor gleich GL_ONE_MINUS_SRC_ALPHA, dann ist As gleich kA, und die Funktionen können auf ihre einfache Entsprechung reduziert werden :
Rd = Rs Gd = Gs Bd = Bs Ad = As
Wenn die Erweiterung für Mischungsgleichungen vorhanden ist, werden die gemischten RGBA-Werte anhand der gesetzten Mischungsgleichung gesetzt. Siehe dazu glBlendEquation.
Hinweise
Der Alpha-Eingangswert (Quelle) kann im Endeffekt als Materialdurchlässigkeit betrachtet werden, reichend von KA = 1, also komplett solide, bis KA=0, was ein komplett transparentes (=unsichtbares) Material darstellen würde.
Wenn mehr als ein Farbpuffer zum Rendern aktiv ist, wird die GL für jeden dieser Puffer separat Mischung durchführen, unter Nutzung des entsprechenden Pufferinhaltes als Zielkomponente. Siehe glDrawBuffer.
Mischung funktioniert übrigens nur im RGBA-Modus. Im Farbindex-Modus nicht.
Änderungen
Ab OpenGL Version 1.4
GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA und GL_ONE_MINUS_CONSTANT_ALPHA stehen sowohl für sfactor als auch für dfactor zur Verfügung (oder schon vorher, falls ARB_imaging durch die Implementation unterstützt wird).
GL_SRC_COLOR und GL_ONE_MINUS_SRC_COLOR stehen für sfactor zur Verfügung.
GL_DST_COLOR und GL_ONE_MINUS_DST_COLOR stehen für dfactor zur Verfügung.
Beispiele
Transparenz implementiert man am besten mit den Mischungsfunktionen (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) und Sortierung der Primitiven von hinten nach vorne.
Die Mischungsfunktion(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) ist auch zum Rendern kantengeglätteter Punkte nützlich, egal in welcher Reihenfolge diese vorkommen.
Kantenglättung von Polygonen lässt sich mit der Mischungsfunktion (GL_SRC_ALPHA_SATURATE, GL_ONE) optimieren, wobei die Polygone von vorne nach hinten sortiert werden.
Nachfolgend finden Sie eine Übersicht einiger Blendergebnisse. Der Code blieb unverändert, nur die Blendfunktion wurde geändert.
| code | ||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
glClearColor(1.0,1.0,1.0,0.0);
[...]
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glBegin(GL_QUADS);
glColor4f(0.8,0.2,0.2,0.7);
glVertex3f(-1, 1, 1);
glVertex3f(-1,-1, 1);
glVertex3f( 1,-1, 1);
glVertex3f( 1, 1, 1);
glColor4f(0.2,0.8,0.2,0.5);
glVertex3f(-1, 1, 1.5);
glVertex3f(-1,-1, 1.5);
glVertex3f( 1,-1, 1.5);
glVertex3f( 1, 1, 1.5);
glColor4f(0.2,0.2,0.8,0.3);
glVertex3f(-1, 1, 2);
glVertex3f(-1,-1, 2);
glVertex3f( 1,-1, 2);
glVertex3f( 1, 1, 2);
glEnd;
| ||||||||||||||
|
Sinnvolle Kombinationen
Im folgenden sind Rq, Gq, Bq und Aq die Farbkomponenten des Fragmentes, dass neu dazukommt. Rz, Gz, Bz und Az sind die Farbkomponenten des bereits im Framebuffer enthaltenen Pixels und Rn, Gn, Bn und An sind die Farbkomponenten des sich ergebenden Fragmentes. Alle Werte sind skaliert auf einen Bereich von 0.0 bis 1.0, inklusive. Die Ergebnisswerte werden danach auf den Bereich 0.0 bis 1.0 geclampt.
Normales Blending
Das normale Blending ist das, was wohl am meisten gebraucht wird. Je stärker die Deckkraft (also das Alpha) der Quelle ist, desto weniger bleibt vom ursprünglichen Framebufferinhalt erhalten und desto mehr wird von der Quelle genommen. Daraus ergibt sich:
Rn = Rz * (1.0 - Aq) + Rq * Aq; Gn = Gz * (1.0 - Aq) + Gq * Aq; Bn = Bz * (1.0 - Aq) + Bq * Aq; An = Az * (1.0 - Aq) + Aq * Aq;
Die beiden Konstanten hierfür sind GL_SRC_ALPHA und GL_ONE_MINUS_SRC_ALPHA.
Additives Blending (ohne Alpha)
Das additive Blending wird zum Beispiel für Lichteffekte und dergleichen verwendet. Eben für Dinge, wo man die Helligkeit im Framebuffer erhöhen will.
Rn = Rz + Rq; Gn = Gz + Gq; Bn = Bz + Bq; An = Az + Aq;
Die beiden Konstanten hierfür sind GL_ONE und GL_ONE.
Additives Blending (mit Alpha)
Das funktioniert eigentlich genauso wie das andere additive Blending, nur wird hier der Alphawert des neuen Fragmentes beachtet.
Rn = Rz + Rq * Aq; Gn = Gz + Gq * Aq; Bn = Bz + Bq * Aq; An = Az + Aq * Aq;
Die beiden Konstanten hierfür sind GL_SRC_ALPHA und GL_ONE.
Multiplikatives Blending
Beim multiplikativen Blending werden die beiden Werte multipliziert. Zum Einfärben eines Bildes ist das sehr praktisch, aber auch für andere Effekte kann man es gebrauchen.
Rn = Rz * Rq; Gn = Gz * Gq; Bn = Bz * Bq; An = Az * Aq;
Die beiden Konstanten hierfür sind GL_DST_COLOR und GL_ZERO.
Fehlermeldungen
GL_INVALID_ENUM wird generiert, wenn sfactor oder dfactor keine gültigen Werte darstellen.
GL_INVALID_OPERATION wird generiert, wenn glBlendFunc in einem glBegin-glEnd-Block aufgerufen wird.
Zugehörige Wertrückgaben
glGet mit dem Argument GL_BLEND_SRC
glGet mit dem Argument GL_BLEND_DST
glGet mit dem Argument GL_BLEND_COLOR
glIsEnabled mit dem Argument GL_BLEND
Siehe auch
glAlphaFunc, glBlendColor, glBlendEquation, glBlendFuncSeparate, glClear, glDrawBuffer, glEnable, glLogicOp, glStencilFunc
Literatur
RedBook Kapitel 7
