Bezeichnung
gl.BlendFunc -- definiert die Pixelarithmetik
Übersicht
gl.BlendFunc(sfactor, dfactor)
Beschreibung
Im RGBA-Modus können Pixel mit einer Funktion gezeichnet werden, die die eingehenden (Quell-) RGBA-Werte mit den RGBA-Werten mischt, die sich bereits im Bildpuffer befinden (die Zielwerte). Mischen ist anfänglich deaktiviert. Verwenden Sie gl.Enable() und gl.Disable() mit dem Argument #GL_BLEND, um die Überblendung zu aktivieren und zu deaktivieren.

gl.BlendFunc() definiert den Vorgang des Mischens, wenn es aktiviert ist. sfactor gibt an, welche der neun Methoden zum Skalieren der Quellfarbkomponenten verwendet wird. dfactor gibt an, welche von acht Methoden zum Skalieren der Zielfarbkomponenten verwendet wird. Die elf möglichen Methoden sind in der folgenden Tabelle beschrieben. Jede Methode definiert vier Skalierungsfaktoren, je einen für Rot, Grün, Blau und Alpha.

In der Tabelle und in den nachfolgenden Gleichungen werden Quell- und Zielfarbkomponenten als (Rs, Gs, Bs, As) und (Rd, Gd, Bd, Ad) bezeichnet. Sie sind so zu verstehen, dass sie ganzzahlige Werte zwischen 0 und (kR, kG, kB, kA) haben, wobei

 
kc = 2^mc - 1

und (mR, mG, mB, mA) ist die Anzahl der roten, grünen, blauen und Alpha-Bit-Ebenen.

Quell- und Zielskalierungsfaktoren werden als (sR, sG, sB, sA) und (dR, dG, dB, dA) bezeichnet. Die in der Tabelle beschriebenen Skalierungsfaktoren (fR, fG, fB, fA) repräsentieren entweder Quell- oder Zielfaktoren. Alle Skalierungsfaktoren haben einen Bereich [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_SRC_ALPHA_SATURATE  |                 (i, i, i, 1)

In der Tabelle,

 
i = min(As, kA  - Ad) / kA

Um die gemischten RGBA-Werte eines Pixels beim Zeichnen im RGBA-Modus zu bestimmen, verwendet das System die folgenden Gleichungen:

 
Rd = min(kR, Rs sR + Rd dR)
Gd = min(kG, Gs sG + Gd dG)
Bd = min(kB, Bs sB + Bd dB)
Ad = min(kA, As sA + Ad dA)

Trotz der scheinbaren Genauigkeit der obigen Gleichungen ist die Mischarithmetik nicht genau definiert, da das Mischen mit ungenauen ganzzahligen Farbwerten arbeitet. Ein Mischfaktor, der gleich 1 sein sollte, garantiert jedoch nicht, seinen Multiplikanten zu modifizieren und ein Mischfaktor von 0 reduziert seinen Multiplikanten auf 0. Zum Beispiel, wenn sfactor #GL_SRC_ALPHA ist, ist dfactor #GL_ONE_MINUS_SRC_ALPHA und As ist gleich kA, die Gleichungen reduzieren sich auf einfachen Ersatz:

 
Rd = Rs
Gd = Gs
Bd = Bs
Ad = As

Die Transparenz wird am besten mit der Mischfunktion (#GL_SRC_ALPHA, #GL_ONE_MINUS_SRC_ALPHA) implementiert, wobei die Grundelemente von am weitesten zum nächsten sortiert sind. Beachten Sie, dass diese Transparenzberechnung nicht das Vorhandensein von Alpha-Bitebenen im Framepuffer erfordert. Die Blend-Funktion (#GL_SRC_ALPHA, #GL_ONE_MINUS_SRC_ALPHA) ist auch nützlich, um Antialias-Punkte und -Linien in beliebiger Reihenfolge darzustellen.

Polygon-Antialiasing wird mithilfe der Überblendungsfunktion (#GL_SRC_ALPHA_SATURATE, #GL_ONE) mit Polygonen optimiert, die von der nächsten bis zur am weitesten entfernten Seite sortiert sind. Siehe gl.Enable für Informationen zum Polygon-Antialiasing. Suchen Sie nach #GL_POLYGON_SMOOTH) Ziel-Alpha-Bitebenen, die vorhanden sein müssen, damit diese Mischfunktion ordnungsgemäß funktioniert, und speichern Sie die akkumulierte Deckkraft.

Ankommende (Quell-) Alpha wird korrekt als eine Materialdeckkraft betrachtet, die von 1.0 (KA) reicht, was eine vollständige Deckkraft darstellt, bis zu 0.0 (0), was eine vollständige Transparenz darstellt.

Wenn mehr als ein Farbpuffer für das Zeichnen aktiviert ist, führt GL das Mischen für jeden aktivierten Puffer separat durch, wobei der Inhalt dieses Puffers für die Zielfarbe verwendet wird. Siehe gl.DrawBuffer für Details.

Die Überblendung wirkt sich nur auf das RGBA-Rendering aus. Es wird von Farbindex-Renderern ignoriert.

Weitere Informationen finden Sie in einem OpenGL-Referenzhandbuch.

Eingaben
sfactor
gibt an, wie die Mischungsfaktoren für Rot, Grün, Blau und Alpha-Quellen berechnet werden (siehe oben)
dfactor
gibt an, wie die Mischungsfaktoren für Rot, Grün, Blau und Alpha-Ziel berechnet werden (siehe oben)
Fehler
#GL_INVALID_ENUM wird generiert, wenn entweder sfactor oder dfactor kein akzeptierter Wert ist.

#GL_INVALID_OPERATION wird erzeugt, wenn gl.BlendFunc() zwischen gl.Begin() und gl.End() ausgeführt wird.

Verbundene get-operationen
gl.Get() mit dem Argument #GL_BLEND_SRC

gl.Get() mit dem Argument #GL_BLEND_DST

gl.IsEnabled() mit dem Argument #GL_BLEND


Navigation zeigen