ZFX + Developia

Ich würde gerne in einem Fragment Shader eine Lookup-Texture für Farbwerte benutzen... also mit einem originalen (unverfälschtem) Farbwert (r,g,b) in einer Textur nachsehen, welche Farbe der Pixel bekommen soll.
Ich grüble gerade darüber, wie man das möglichst effizient machen könnte und wie dann die dazugehörige Paletten-Textur aussehen sollte.

Gibt es dafür bewährte Verfahren?

P.S.: das ganze wäre in OpenGL ES 2.0... also nur texture2D (nix 1D) ;)

Wie genau soll dieser Lookup (r,g,b) -> ? denn aussehen?

Naja... sagen wir mal beispielhaft die Palettentextur hat eine Größe von 64*64 Pixeln (=4096 mögliche Farben) und folgenden Pseudocode:

vec3 color; <---- enthält die ermittelte Farbe des aktuellen Pixels.
float px = (some magic);
float py = (some magic);
vec4 finalcolor = texture2D(paletteTexture, vec2(px, py));

es ginge also darum, die korrekten Koordinaten für den Lookup nach einem möglichst effizientem System zu berechnen und in der Umkehrung vorher eine passende Paletten-Textur zu erstellen (da wäre der Rechenaufwand ja egal).

Und nach welchem Verfahren soll entschieden werden auf welche der 4096 Farben ein gegebenes (r, g, b) Triplet fällt?

Das Verfahren hängt ja von der vorher erzeugten Palette ab würd ich sagen... fürs erste würde ich mal davon ausgehen, den vollen Farbraum auf 4096 Farben (64 x 64) "runter zu rechnen". D.h. in diesem Fall wäre das Ergebnis der Ausgangsfarbe ziemlich ähnlich. Anschliessend könnte man dann die Palette entsprechend verfälschen.

Damit wir alle verstehen, was hier vor sich geht – du meinst sowas
http://udn.epicgames.com/Three/ColorGrading.html

Ich würde einen 3D-Lookup simulieren, also die Tabelle – wie dort – in n×1 Quadraten anordnen. Dann benutzt du RG für die x- und y-Basiskoordinate. Den B-Wert multiplizierst du mit n. floor() und ceil() liefern dir zwei Offsets, die du je auf x nochmal draufpackst. Das normalisierst du (falls du nicht mit Pixelkoordinaten samplen kannst), samplest die beiden Positionen und interpolierst sie gemäß dem frac() mit dem skalierten B.

Falls du nur einzelne Kanäle korrigieren musst, ist es ja noch einfacher (weil du die Helligkeiten der Kanäle z.B. in 128×3 anordnen könntest).

Hi!

Ja... sowas Ähnliches meinte ich. Vielen Dank erstmal für den Wink in die richtige Richtung.
In meinem Fall möchte ich nur nicht interpolieren, da hier "harte" Übergänge durchaus gewollt sind.

Somit habe ich nun Folgendes, was recht gut funktioniert:

float px = (floor((texel.b - 0.001) * 16.0) / 16.0) + ((texel.r - 0.001) / 16.0);
float py = 1.0 - texel.g;

Vielen Dank nochmal!