# RGB Wert Heller machen (Dunkler machen klappt)



## korbmeister (22. Jan 2014)

Hallo Leute, hab vor ner Weile mal gefragt wie ich einen RGB wert dunkler mache, hab ne sehr gut Antwort bekommen die ich zwar nicht verstehe aber sie hat gut funktioniert:

```
public int render_shadow(int zahl){
		
		
		int gamma = 155;
		int b = zahl & 255;
		zahl >>= 8;
	    int g = zahl & 255;
	    zahl >>= 8;
	    int r = zahl & 255;
	    zahl >>= 8;
	    b = gamma > b ? 0 : b - gamma;
	    g = gamma > g ? 0 : g - gamma;
	    r = gamma > r ? 0 : r - gamma;
	    zahl =  b + g * 256 + r * 256 * 256 + zahl * 256 * 256 * 256;
	    return zahl;
	
	}
```

Jetzt musste es ja zwangsläufig drauf hinauslaufen, dass ich diese Methode brauche um etwas Heller zu machen, wäre jemand so nett und würde das schnell für mich machen, oder mir helfen weil ich da echt nicht durchblicke bei : > ? &,  >> war doch eine binärverschiebung oder nicht? ;D


----------



## Alph0r (23. Jan 2014)

> ist in dem Fall einfach ein vergleich, das:

```
b = gamma > b ? 0 : b - gamma;
        g = gamma > g ? 0 : g - gamma;
        r = gamma > r ? 0 : r - gamma;
```

Ist der ternäre Operator und ist im Grunde nur eine Kurzschreibweise für ein if/else.

Du solltest schon versuchen es zu verstehen. Du bekommst den RGB Wert in einem einzigen int, jetzt wird mit dem & 255 alles bis auf die letzten 8 bin auf 0 gesetzt (mach es dir binär mal klar) und dann wird geshiftet, da die Zahl quasi
xxxxxxxxrrrrrrrrggggggggbbbbbbbb ist, also erstmal hast du das Blau ohne shift, dann shiftest du um das grüne an der rechten Stelle zu haben und dann nochmal für Rot.

Dann wird Gamma einfach abgezogen aber wird noch geprüft, ob das Ergebnis kleiner 0 wäre, in dem Fall wird 0 für den Wert genommen.

Die Bit Operationen erscheinen anfangs verwirrend und unnötig, aber sie können schon helfen.


----------



## Sen-Mithrarin (23. Jan 2014)

naja ... da hat aber jemand gewollt aber nich gekonnt ... oder es zumindest nicht zum fertigen abschluss gebracht

ich versuch es mal aufzuklären

in den ersten zeilen wird dein int in r,g,b und a zerlegt
stimmt mathematisch so zwar, kann man aber einfach schöner wie folgt machen

```
int argb=...;
int b=argb&0xFF;
int g=(argb>>8)&0xFF;
int r=(argb>>16)&0xFF;
int a=(argb>>24)&0xFF;
```
am ende wird das ganze wieder umständlich wieder zusammen gebastelt ... auch das kann man einfach schöner machen

```
int argb=(a<<24)|(r<<16)|(g<<8)|b;
```

und die eigentliche magie geschiet im mittleren block mit dem ternär-op

bildlich gesprochen : ist gamma (155) größer als farbwert x ? wenn ja : dann setze farbwert auf 0 (schwarz) / wenn nein dann setze farbwert auf gamma (155) - aktuellen farbwert x


warum überhaupt alpha weiterverwendet wird ... naja ... ist normalerweise eh entweder 0 oder 0xFF und spielt nur bei bestimmten formaten eine rolle



so ... das ist die magie des "dunkler machens" : den farbwert um den gamma-wert verringern
die abfrage in der mitte dient nur dem schutz vor einem überlauf

um etwas also heller zu machen musst du das ganze nur umdrehen : den farbwert und den gamma-wert erhöhen ...
und auch dabei wieder korrekt auf den überlauf achten

ausgehend von deinem code musst du nur die drei "magischen zeilen" etwas ändern


----------

