Destiny unterstützt die Nutzung von PixelBlend.dll zum Zeichnen von Pixeln mit insgesamt 58 verschiedenen Formeln für eine Vielzahl an Blendmodi, sofern die Bibliothek in den Darstellungsprozess von RPG_RT eingebunden ist (dies ist bei RPG2000 1.62EX der Fall).
Die nachfolgend aufgelisteten Modi, unterteilt in mehrere Kategorien, sind verfügbar.
#0 | Set / Mix |
---|---|
![]() |
Die Standardmethode, mit der Pixel normalerweise aufeinander gezeichnet werden, bei voller Sichtbarkeit verschwindet der Bildpunkt des Hintergrundes vollständig.
C = I
C = ((I * F) + (S * (F - 255))) / 255
|
#1 | Add / LinearDodge |
![]() |
Die RGB-Werte des Hintergrunds und Vordergrunds werden addiert, was zu intensiv leuchtenden Ergebnissen führen kann. Überschreitet die Vordergrundsichtbarkeit das Maximum von 255, verstärkt sich dieser Effekt, ohne zu verglitchen.
C = [S + I, 255].min
C = [S + (((I * F) + (S * (255 - F))) / 255), 255].min
|
#2 | Sub / Subtract |
![]() |
Die RGB-Werte des Hintergrunds und Vordergrunds werden voneinander subtrahiert, was zu sehr finster aussehenden Ergebnissen führen kann, je heller die Vordergrundpixel ausfallen. Überschreitet die Vordergrundsichtbarkeit das Maximum von 255, verstärkt sich dieser Effekt, ohne zu verglitchen.
C = [S - I, 0].max
C = [S - (((I * F) + (S * (255 - F))) / 255), 0].max
|
#3 | Mul / Multiply |
![]() |
Die RGB-Werte des Hintergrunds und Vordergrunds werden miteinander multipliziert und dabei wie Kommazahlen zwischen 0 und 1 behandelt (dies entspricht einer anschließenden Division durch 255). Dadurch entstehen Verdunkelungen abhängig davon, wie dunkel der Vordergrund ausfällt, während ein weißer Pixel nichts am Hintergrund verändert.
C = (I * S) / 255
C = ((((I * S) * F) / 255) + (S * (255 - F))) / 255
|
#4 | Div / Divide |
![]() |
Die RGB-Werte des Hintergrunds werden durch die des Vordergrunds geteilt und dabei wie Kommazahlen zwischen 0 und 1 behandelt (dies entspricht einer vorausgehenden Multiplikation mit 255 für den Hintergrund, bevor die eigentliche Formel angewendet wird). Sollte der Vordergrund 0 betragen, durch den man nicht teilen kann, beträgt das Ergebnis automatisch 255.
C = [(S << 8) / (I + 1), 255].min
C = [((((S << 8) / (I + 1)) * F) / 255) + ((S * (255 - F)) / 255), 255].min
|
#5 | Mod / Rem / Remainder |
![]() |
Führt den gleichen Prozess wie bei "Div / Divide" (#4) durch, verwendet allerdings den bei der Division entstandenen Restbetrag als Wert, der als neuer Pixel gespeichert wird, was sehr bizarre Muster und kaputt wirkende Ergebnisse hervorbringen kann.
C = (S << 8) % (I + 1)
C = ((((S << 8) % (I + 1)) * F) / 255) + ((S * (255 - F)) / 255)
|
#6 | Difference |
![]() |
Errechnet die jeweiligen Differenzen zwischen den RGB-Werten des Hintergrunds und Vordergrunds, ein negatives Ergebnis wird automatisch in das positive Gegenstück umgewandelt.
C = (I - S).abs
C = (((I - S).abs * F) + (S * (255 - F))) / 255
|
#7 | Difference (Fill) |
![]() |
Führt den gleichen Prozess wie bei "Difference" (#6) durch, verrechnet allerdings bereits vor statt nach Anwenden der Formel die Sichtbarkeit mit den RGB-Werten des Vordergrunds.
C = (((I * F) / 255) - S).abs
|
#8 | Exclude / Exclusion |
![]() |
Multipliziert die RGB-Werte des Hintergrunds mit denen des Vordergrunds sowie 255 und halbiert das Resultat anschließend. Der dabei entstehende Wert wird von einer Addition aus Hintergrund und Vordergrund abgezogen und schlussendlich auf den gültigen Wertebereich beschränkt.
C = [[(I + S) - ((I * S) / 128), 255].min, 0].max
C = (([[(I + S) - ((I * S) / 128), 255].min, 0].max * F) + (S * (255 - F))) / 255
|
#9 | Negate / Negation |
![]() |
Zieht die RGB-Werte des Hintergrunds sowie Vordergrunds zusammen von 255 ab und wandelt das Ergebnis in einen positiven Betrag um, der wiederum von 255 abgezogen wird.
C = 255 - (255 - ((I * F) / 255) - S).abs
|
#10 | Phoenix |
![]() |
Zieht die RGB-Werte des Hintergrunds von denen des Vordergrunds ab und wandelt ein positives Ergebnis automatisch in sein negatives Pendant um, auf das anschließend von 255 draufgerechnet werden.
C = [-((I - S).abs) + 255, 255].min
C = [(((-((I - S).abs) + 255) * F) + (S * (255 - F))) / 255, 255].min
|
#11 | Darken |
![]() |
Wendet die individuellen RGB-Werte des Vordergrunds nur dann an, wenn sie niedriger als die des Hintergrunds ausfallen.
C = I < S ? I : S
C = I < S ? ((I * F) + (S * (255 - F))) : S
|
#12 | Lighten |
![]() |
Wendet die individuellen RGB-Werte des Vordergrunds nur dann an, wenn sie höher als die des Hintergrunds ausfallen.
C = I > S ? I : S
C = I > S ? (I * F) + (S * (255 - F)) : S
|
#13 | DarkerColor (HSI) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSI-Farbsystem als dunkler gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der Gesamtsummen beider RGB-Farbkanalgruppen.
C = (IR + IG + IB) < (SR + SG + SB) ? I : S
C = (IR + IG + IB) < (SR + SG + SB) ? ((I * F) + (S * (255 - F))) / 255 : S
|
#14 | DarkerColor (HSL) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSL-Farbsystem als dunkler gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der Summen aus dem jeweils höchsten und niedrigsten Farbkanalwert.
C = (IMAX + IMIN) < (SMAX + SMIN) ? I : S
C = (IMAX + IMIN) < (SMAX + SMIN) ? ((I * F) + (S * (255 - F))) / 255 : S
|
#15 | DarkerColor (HSV) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSV-Farbsystem als dunkler gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der höchsten Werte beider RGB-Farbkanalgruppen.
C = IMAX < SMAX ? I : S
C = IMAX < SMAX ? ((I * F) + (S * (255 - F))) / 255 : S
|
#16 | DarkerColor (HSY: SDTV) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2990, 5870, 1140] als dunkler gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.
C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? I : S
C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
|
#17 | DarkerColor (HSY: HDTV) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2120, 7010, 870] als dunkler gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.
C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? I : S
C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
|
#18 | DarkerColor (HSY: Adobe) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2126, 7152, 722] als dunkler gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.
C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? I : S
C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
|
#19 | DarkerColor (HSY: HDR) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2627, 6780, 593] als dunkler gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.
C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? I : S
C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
|
#20 | LighterColor (HSI) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSI-Farbsystem als heller gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der Gesamtsummen beider RGB-Farbkanalgruppen.
C = (IR + IG + IB) > (SR + SG + SB) ? I : S
C = (IR + IG + IB) > (SR + SG + SB) ? ((I * F) + (S * (255 - F))) / 255 : S
|
#21 | LighterColor (HSL) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSL-Farbsystem als heller gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der Summen aus dem jeweils höchsten und niedrigsten Farbkanalwert.
C = (IMAX + IMIN) > (SMAX + SMIN) ? I : S
C = (IMAX + IMIN) > (SMAX + SMIN) ? ((I * F) + (S * (255 - F))) / 255 : S
|
#22 | LighterColor (HSV) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSV-Farbsystem als heller gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der höchsten Werte beider RGB-Farbkanalgruppen.
C = IMAX > SMAX ? I : S
C = IMAX > SMAX ? ((I * F) + (S * (255 - F))) / 255 : S
|
#23 | LighterColor (HSY: SDTV) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2990, 5870, 1140] als heller gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.
C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? I : S
C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
|
#24 | LighterColor (HSY: HDTV) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2120, 7010, 870] als heller gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.
C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? I : S
C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
|
#25 | LighterColor (HSY: Adobe) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2126, 7152, 722] als heller gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.
C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? I : S
C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
|
#26 | LighterColor (HSY: HDR) |
![]() |
Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2627, 6780, 593] als heller gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.
C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? I : S
C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
|
#27 | DodgeScreen |
![]() |
Multipliziert die RGB-Werte des Hintergrunds und Vordergrunds miteinander, nachdem sie jeweils von 255 abgezogen wurden. Das Ergebnis wird erneut von 255 abgezogen.
C = 255 - (((255 - I) * (255 - S)) / 255)
C = (255 - (((255 - I) * (255 - S)) / 255) * F) + (S * (255 - F)) / 255
|
#28 | ColorDodge |
![]() |
Dividiert die RGB-Werte des Hintergrunds durch die des Vordergrunds, nachdem letztere von 255 abgezogen wurden (das Ergebnis ist automatisch 255, wenn der Vordergrundwert 255 beträgt).
C = 0 if S == 0
X = 255 - I C = 255 if S >= X C = (S * 255) / X C = 0 if S == 0
X = 255 - ((I * F) / 255) C = 255 if S >= X C = (S * 255) / X |
#29 | SoftDodge |
![]() |
Falls der jeweilige RGB-Wert des Hindergrunds addiert mit dem des Vordergrunds 255 nicht übersteigt, wird die Hälfte des Hintergrundwertes durch den Vordergrundwert dividiert, nachdem letzterer von 255 abgezogen wurde (das Ergebnis ist automatisch 255, wenn der Vordergrundwert 255 beträgt). Andernfalls wird die Hälfte vom Vordergrundwert, nachdem er von 255 abgezogen wurde, durch den Hintergrundwert geteilt und anschließend von 255 abgezogen (das Endergebnis ist automatisch 0, wenn der Hintergrundwert 0 beträgt).
C = I if S + I < 256 && I == 255
C = [(S * 128) / (255 - I), 255].min if S + I < 256 C = S == 0 ? S : [255 - (((255 - I) * 128) / S), 0].max X = I if S + I < 256 && I == 255
X = [(S * 128) / (255 - I), 255].min if S + I < 256 X = S == 0 ? S : [255 - (((255 - I) * 128) / S), 0].max C = ((X * F) + (S * (255 - F))) / 255 |
#30 | ColorBurn |
![]() |
Dividiert die RGB-Werte des Hintergrunds, nachdem diese von 255 abgezogen wurden, durch die des Vordergrunds. Das Ergebnis wird anschließend von 255 abgezogen. Das Ergebnis ist automatisch 0, wenn der Vordergrundwert 0 beträgt.
C = 255 if S == 255
X = ((I * F) / 255) + (255 - F) C = 0 if (255 - S) >= X C = 255 - (((255 - S) * 255) / X) |
#31 | LinearBurn |
![]() |
Addiert die RGB-Werte des Hintergrunds und Vordergrunds, um anschließend 255 vom Ergebnis abzuziehen.
C = [S + I - 255, 0].max
C = [(((S + I - 255) * F) + (S * (255 - F))) / 255, 0].max
|
#32 | LinearBurn (Fill) |
![]() |
Führt den gleichen Prozess durch wie bei LinearBurn (#31) durch, verrechnet allerdings bereits vor statt nach Anwenden der Formel die Sichtbarkeit mit den RGB-Werten des Vordergrunds.
C = [S + (((I - 255) * F) / 255), 0].max
|
#33 | SoftBurn |
![]() |
Falls der jeweilige RGB-Wert des Hindergrunds addiert mit dem des Vordergrunds 255 nicht übersteigt, wird die Hälfte des Vordergrundwertes durch den Hintergrundwert dividiert, nachdem letzterer von 255 abgezogen wurde (das Ergebnis ist automatisch 255, wenn der Hintergrundwert 255 beträgt). Andernfalls wird die Hälfte vom Hintergrundwert, nachdem er von 255 abgezogen wurde, durch den Vordergrundwert geteilt und anschließend von 255 abgezogen (das Endergebnis ist automatisch 0, wenn der Vordergrundwert 0 beträgt).
C = S if S + I < 256 && S == 255
C = [(I * 128) / (255 - S), 255].min if S + I < 256 C = I == 0 ? I : [255 - (((255 - S) * 128) / I), 0].max X = S if S + I < 256 && S == 255
X = [(I * 128) / (255 - S), 255].min if S + I < 256 X = I == 0 ? I : [255 - (((255 - S) * 128) / I), 0].max C = ((X * F) + (S * (255 - F))) / 255 |
#34 | GeometricMean |
![]() |
Die RGB-Werte des Hintergrunds und Vordergrunds werden miteinander mulitipliziert und aus dem Ergebnis die Quadratwurzel gezogen.
C = sqrt(I * S)
C = sqrt(((I * S) * F) / 255) + ((S * (255 - F)) / 255)
|
#35 | Overlay |
![]() |
Falls der Hintergrundwert niedriger als 128 ist, wird er mit dem Vordergrundwert multipliziert und das Ergebnis anschließend verdoppelt (da eine Division durch 255 notwendig ist, wird anstelle zweier Rechenschritte durch 128 geteilt). Andernfalls werden der Hintergrundwert und Vordergrundwert miteinander multipliziert, nachdem sie jeweils von 255 abgezogen wurden, anschließend das Ergebnis (auch hier mit Vereinfachung) verdoppelt und von 255 abgezogen.
C = (S * I) >> 7 if S < 128
C = 255 - ((255 - S) * (255 - I) >> 7) C = ((((S * I) >> 7) * F) + (S * (255 - F))) / 255
C = (((255 - (((255 - S) * (255 - I)) >> 7)) * F) + (S * (255 - F))) / 255 |
#36 | SoftLight |
![]() |
Die RGB-Werte des Hintergrunds und Vordergrunds werden miteinander mulitipliziert und als Zwischenergebnis vermerkt. Der Hintergrundwert und der Vordergrundwert, nachdem sie jeweils von 255 abgezogen wurden, werden multipliziert und von 255 abgezogen. Das vermerkte Zwischenergebnis wird anschließend vom dadurch entstandenen Wert abgezogen, mit dem Hintergrundwert multipliziert und auf das vermerkte Zwischenergebnis nochmal aufaddiert.
X = (S * I) / 255
C = X + (S * (255 - (((255 - S) * (255 - I)) / 255) - X) / 255) X = (S * I) / 255
X = X + (S * (255 - (((255 - S) * (255 - I)) / 255) - X) / 255) C = ((X * F) + (S * (255 - F))) / 255 |
#37 | HardLight |
![]() |
Falls der Vordergrundwert niedriger als 128 ist, wird er mit dem Hintergrundwert multipliziert und das Ergebnis anschließend verdoppelt (da eine Division durch 255 notwendig ist, wird anstelle zweier Rechenschritte durch 128 geteilt). Andernfalls werden der Hintergrundwert und Vordergrundwert miteinander multipliziert, nachdem sie jeweils von 255 abgezogen wurden, das Ergebnis (auch hier mit Vereinfachung) verdoppelt und von 255 abgezogen.
C = (I * S) >> 7 if I < 128
C = (255 - (((255 - I) * (255 - S)) >> 7)) C = (((I * S >> 7) * F) + (S * (255 - F))) / 255 if I < 128
C = (((255 - (((255 - I) * (255 - S)) >> 7)) * F) + (S * (255 - F))) / 255 |
#38 | VividLight |
![]() |
Falls der Vordergrundwert niedriger als 128 ist, wird der Hintergrundwert, nachdem er von 255 abgezogen wurde, durch das Doppelte vom Vordergrundwert geteilt und das Ergebnis anschließend von 255 abgezogen (das Ergebnis ist automatisch 0, wenn der Vordergrundwert 0 beträgt). Andernfalls wird der Hintergrundwert durch den Vordergrundwert geteilt, nachdem letzterer von 255 abgezogen und anschließend verdoppelt wurde (das Ergebnis ist automatisch 255, falls der Vordergrundwert 255 beträgt).
X = ((I * 2 * F) / 255) + (255 - F)
C = 0 if I < 128 && X == 0
C = 255 - ((255 - S) * 255) / X if I < 128 C = 255 if (((I * 2) - 255) * F) / 255 == 255 C = (S * 255) / (255 - (((I * 2) - 255) * F) / 255) |
#39 | LinearLight |
![]() |
Der Vordergrundwert wird verdoppelt und auf den Hintergrundwert addiert, anschließend wird 255 vom Ergebnis abgezogen.
C = S + ((2 * I) - 255)
C = ((S + ((2 * I) - 255) * F) + (S * (255 - F))) / 255
|
#40 | LinearLight (Fill) |
![]() |
Führt den gleichen Prozess durch wie bei LinearLight (#39) durch, verrechnet allerdings bereits vor statt nach Anwenden der Formel die Sichtbarkeit mit den RGB-Werten des Vordergrunds.
C = S + ((((2 * I) - 255) * F) / 255)
|
#41 | LinearInvert |
![]() |
Der Vordergrundwert wird von 255 abgezogen, verdoppelt und auf den Hintergrundwert addiert, nachdem 255 vom Ergebnis abgezogen wurde.
C = S + ((2 * (255 - I)) - 255)
C = ((S + ((2 * (255 - I)) - 255) * F) + (S * (255 - F))) / 255
|
#42 | LinearInvert (Fill) |
![]() |
Führt den gleichen Prozess durch wie bei LinearInvert (#41) durch, verrechnet allerdings bereits vor statt nach Anwenden der Formel die Sichtbarkeit mit den RGB-Werten des Vordergrunds.
C = S + ((((2 * (255 - I)) - 255) * F) / 255)
|
#43 | PinLight |
![]() |
Falls der Hintergrundwert geringer ausfällt als das Doppelte vom Vordergrundwert, von dem 255 abgezogen wird, wird selbige Formel angewandt. Andernfalls wird der verdoppelte Vordergrundwert als Ergebnis gespeichert (die Anwendung der Formel wird übersprungen, wenn der Hintergrundwert geringer als der verdoppelte Vordergrundwert ausfällt).
C = [(I * 2) - 255, 0].max if S < [(I * 2) - 255, 0].max
C = S < I * 2 ? S : [I * 2, 255].min X = [(I * 2) - 255, 0].max if S < [(I * 2) - 255, 0].max
X = S < I * 2 ? S : [I * 2, 255].min C = ((X * F) + (S * (255 - F))) / 255 |
#44 | StampDodge |
![]() |
Multipliziert den Hintergrundwert mit 255 und dividiert ihn durch den Vordergrundwert. Wenn der Hintergrundwert niedriger als der Vordergrundwert sein sollte, werden beide zuvor von 255 abgezogen. Das Endergebnis ist automatisch 255, falls je nach Fall der direkte oder von 255 abgezogene Vordergrundwert zu einer Division durch 0 führen würde.
C = 255 if I == (S < I ? 0 : 255)
C = S < I ? ((S * 255) / I) : (((255 - S) * 255) / (255 - I)) C = ((255 * F) + (S * (255 - F))) / 255 if I == (S < I ? 0 : 255)
C = (((S < I ? ((S * 255) / I) : (((255 - S) * 255) / 255 - I)) * F) + (S * (255 - F))) / 255 |
#45 | StampBurn |
![]() |
Multipliziert den Hintergrundwert mit 255 und dividiert ihn durch den Vordergrundwert. Wenn der Hintergrundwert niedriger als der Vordergrundwert sein sollte, werden beide zuvor von 255 abgezogen. Ebenfalls von 255 abgezogen wird das bei dieser Berechnung entstehende Resultat. Das Endergebnis ist automatisch 0, falls je nach Fall der direkte oder von 255 abgezogene Vordergrundwert zu einer Division durch 0 führen würde.
C = 0 if I == (S < I ? 0 : 255)
C = 255 - (S < I ? ((S * 255) / I) : (((255 - S) * 255) / (255 - I))) C = ((255 * F) + (S * (255 - F))) / 255 if I == (S < I ? 0 : 255)
C = (((255 - (S < I ? ((S * 255) / I) : (((255 - S) * 255) / (255 - I)))) * F) + (S * (255 - F))) / 255 |
#46 | HardMix |
![]() |
Verringert die Anzahl an möglichen Farbkanalwerten, abhängig von der Sichtbarkeit des Vordergrunds. Bei voller Sichtbarkeit beträgt das Ergebnis immer 0, wenn der Vordergrundwert geringer ist als der Hintergrundwert, nachdem letzterer von 255 abgezogen wurde, andernfalls 255.
C = ((255 * (256 - F)) - (65025 - [(S * 255) + (I * F), 65025].min)) / (256 - F)
|
#47 | QuadraticReflect |
![]() |
Der quadrierte Hintergrundwert wird durch den Vordergrundwert geteilt, nachdem letzterer von 255 abgezogen wurde (das Ergebnis ist automatisch 255, wenn der Vordergrundwert 255 beträgt).
C = I == 255 ? I : (S * S) / (255 - I)
C = ((I == 255 ? I : ((S * S) / (255 - I) * F)) + (S * (255 - F))) / 255
|
#48 | QuadraticGlow |
![]() |
Der quadrierte Vordergrundwert wird durch den Hintergrundwert geteilt, nachdem letzterer von 255 abgezogen wurde (das Ergebnis ist automatisch 255, wenn der Hintergrundwert 255 beträgt).
C = S == 255 ? S : (I * I) / (255 - S)
C = ((S == 255 ? S : ((I * I) / (255 - S) * F)) + (S * (255 - F))) / 255
|
#49 | QuadraticFreeze |
![]() |
Der Hintergrundwert wird von 255 abgezogen, anschließend quadriert und durch den Vordergrundwert geteilt. Das Ergebnis wird anschließend von 255 abgezogen (das Ergebnis ist automatisch 0, wenn der Vordergrundwert 0 beträgt).
C = I == 0 ? I : 255 - (((255 - S) * (255 - S)) / I)
C = ((I == 0 ? I : 255 - (((255 - S) * (255 - S)) / I)) * F) + (S * (255 - F))) / 255
|
#50 | QuadraticHeat |
![]() |
Der Vordergrundwert wird von 255 abgezogen, anschließend quadriert und durch den Hintergrundwert geteilt. Das Ergebnis wird anschließend von 255 abgezogen (das Ergebnis ist automatisch 0, wenn der Hintergrundwert 0 beträgt).
C = S == 0 ? S : 255 - (((255 - I) * (255 - I)) / S)
C = ((S == 0 ? S : 255 - (((255 - I) * (255 - I)) / S)) * F) + (S * (255 - F))) / 255
|
#51 | Conjunction / AND |
![]() |
Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem AND-Gatter verschaltet.
C = S & I
C = (((S & I) * F) + (S * (255 - F))) / 255
|
#52 | Disjunction / OR |
![]() |
Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem OR-Gatter verschaltet.
C = S | I
C = (((S | I) * F) + (S * (255 - F))) / 255
|
#53 | ExclusiveDisjunction / XOR |
![]() |
Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem XOR-Gatter verschaltet.
C = S ^ I
C = (((S ^ I) * F) + (S * (255 - F))) / 255
|
#54 | NegatedConjunction / NAND |
![]() |
Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem AND-Gatter verschaltet, nachdem letzterer von 255 abgezogen wurde.
C = S & (255 - I)
C = (((S & (255 - I)) * F) + (S * (255 - F))) / 255
|
#55 | NegatedDisjunction / NOR |
![]() |
Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem OR-Gatter verschaltet, nachdem letzterer von 255 abgezogen wurde.
C = S | (255 - I)
C = (((S | (255 - I)) * F) + (S * (255 - F))) / 255
|
#56 | Equivalence / XNOR |
![]() |
Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem XOR-Gatter verschaltet, nachdem letzterer von 255 abgezogen wurde.
C = S ^ (255 - I)
C = (((S ^ (255 - I)) * F) + (S * (255 - F))) / 255
|
#57 | Interpolate |
![]() |
Die RGB-Werte vom Hintergrund und Vordergrund werden durch Werte aus einer vorberechneten Liste an Kosinuswerten ersetzt und anschließend zusammengezählt.
cos = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,
4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 9, 9, 10, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25, 26, 26, 27, 27, 28, 29, 29, 30, 31, 31, 32, 33, 34, 34, 35, 36, 36, 37, 38, 39, 39, 40, 41, 41, 42, 43, 44, 44, 45, 46, 47, 48, 48, 49, 50, 51, 51, 52, 53, 54, 54, 55, 56, 57, 58, 58, 59, 60, 61, 62, 62, 63, 64, 65, 65, 66, 67, 68, 69, 69, 70, 71, 72, 73, 73, 74, 75, 76, 76, 77, 78, 79, 79, 80, 81, 82, 83, 83, 84, 85, 86, 86, 87, 88, 88, 89, 90, 91, 91, 92, 93, 93, 94, 95, 95, 96, 97, 98, 98, 99, 100, 100, 101, 101, 102, 103, 103, 104, 105, 105, 106, 106, 107, 107, 108, 109, 109, 110, 110, 111, 111, 112, 112, 113, 113, 114, 114, 115, 115, 116, 116, 117, 117, 117, 118, 118, 119, 119, 120, 120, 120, 121, 121, 121, 122, 122, 122, 123, 123, 123, 123, 124, 124, 124, 124, 125, 125, 125, 125, 126, 126, 126, 126, 126, 126, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 128] C = cos(S) + cos(I)
C = (((cos(S) + cos(I)) * F) + (S * (255 - F))) / 255
|