Version vom 2. September 2008, 22:03 Uhr

Hinweis: Dieser Artikel wurde von den Benutzern des Wikis zum exzellenten Artikel berufen! (weitere exzellente Artikel)

glBlendFunc

Name

glBlendFunc - Bestimmt das Verhalten beim Schreiben von Fragmenten (Pixeln) in den Framebuffer

Delphi-Spezifikation

procedure glBlendFunc(sfactor : TGLEnum; dfactor: TGLEnum);

Parameter

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].

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.

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;
GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA GL_DST_COLOR, GL_SRC_COLOR GL_DST_COLOR, GL_SRC_ALPHA GL_ONE, GL_ZERO GL_ONE, GL_ONE mit glClearColor(0,0,0,0) entspricht additiven Blending GL_ONE, GL_ONE mit glClearColor(1,1,1,0) weiß wegen "Überbelichtung" GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA GL_SRC_ALPHA, GL_SRC_COLOR GL_ZERO, GL_ZERO GL_ZERO, GL_ONE

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 man 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_SRC_ONE_MINUS_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_EXT.
glIsEnabled mit dem Argument GL_BLEND.

Siehe auch

glAlphaFunc, glClear, glBlendColor, glBlendEquation, glBlendFuncSeparate, glDrawBuffer, glEnable, glLogicOp, glStencilFunc

Literatur

RedBook Kapitel 7