Modalità di fusione "normale" con problemi OpenGL

Ho avuto molti problemi a provare a far funzionare una funzione di fusione OpenGL come mi aspetterei con quello che mi aspetto (o da qualsiasi programma di editing di immagini sensato). Ad esempio, userò queste due immagini per fondere (un po 'difficile da vedere su sfondi bianchi in modo che i colori siano etichettati):

Immagini da miscelare

Questo è quello che mi aspetto che accada (e cosa succede in paint.net):

Risultato atteso

Ovviamente la funzione di fusione predefinita di opengl la fa apparire così (molto sbagliata):

glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

Dopo un sacco di test, questo è il più vicino che potrei arrivare a creare una "buona" funzione di fusione:

glBlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA)

Guardando indietro al risultato atteso originale, noterete che alcuni dei colori sono leggermente più tenui di quanto dovrebbero essere (la parte centrale sinistra). In particolare, sono premoltiplicati per metà del loro valore di colore (a causa della .5 alfa) e non riesco a fare una funzione che non lo fa (senza causare strani problemi di fusione con la parte trasparente rossa appena visibile).

Qualcuno conosce una soluzione a questo problema? Uno che avevo era usare l'alfa premoltiplicato nelle fonti (mentre non voglio farlo perché richiede un lavoro extra per convertire tutti i colori che uso nel mio gioco in premoltiplicato o semplicemente scrivere alcune cose in ogni shader) e farlo in quel modo :

glBlendFuncSeparate (GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA) (Nessuna premoltiplicazione)

Ovviamente anche quello è sbagliato, ma questo è in realtà l'unico risultato corretto che ho ottenuto finora:

glBlendFuncSeparate (GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA) (input premoltiplicati)

L'unico problema è, come potrei sbarazzarmi della premoltiplicazione per visualizzarla sullo schermo? Probabilmente richiederebbe un ciclo di rendering aggiuntivo per ogni cosa che mescolo e questo sembra troppo complesso per questo problema, quindi sto ancora cercando una risposta (è interessante che non riesco a trovare nulla su questo, perché OpenGL è così ampiamente usato che Immagino che qualcun altro abbia riscontrato questo problema).

fonti:

Test delle funzioni di fusione online - http://www.andersriggelsen.dk/glblendfunc.php
Immagine livello inferiore - http://i.stack.imgur.com/XjLNW.png
Immagine livello superiore - http: //i.stack.imgur .com / 9CN6w.png

Nel tuo primo esempio ( glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)), gli stai dicendo di fondere i colori in base all'alfa dell'immagine che viene disegnata in alto (quella "Primo piano"). Quindi, quando si fonde il 50% tra il colore di primo piano (38,50,168)e il colore di sfondo (38,50,168)nell'angolo in basso a sinistra dell'immagine, non sorprende che tu abbia esattamente lo stesso colore (38,50,168). Perché quella fusione incrociata è esattamente ciò che hai detto a OpenGL di fare.

A giudicare dalla tua immagine "prevista", non vuoi fare una fusione incrociata tra i due colori: vuoi sovrapporre il colore di primo piano al colore di sfondo a piena forza, non una fusione incrociata tra di loro.

Per fare ciò, vuoi usare glBlendFuncSeparate (dato che stai trattando il colore dello sfondo in modo diverso dalla sua alfa) e specificare che durante l'operazione di fusione, il valore alfa dello sfondo dovrebbe essere trattato al 100%.

Per semplificare la visualizzazione, ecco i valori RGB finali in uscita:

Ed ecco i valori di trasparenza finali in uscita.

(Quell'area di trasparenza "100%" dovrebbe in realtà essere etichettata come trasparente al 99,7%, e l'area "50%" in basso a destra dovrebbe essere etichettata come trasparente al 49,7%, entrambe a causa del bit rosso sul lato destro della prima immagine. Inoltre, mi dispiace per elencare i numeri usando "trasparenza" anziché opacità; forse un po 'di confusione.)

In caso di problemi specifici, indicare l'area dell'immagine RGB o alfa che produce valori errati.

Ho avuto lo stesso identico problema quando volevo renderizzare una serie di oggetti framebuffer sovrapposti come i livelli. Il problema è che le funzioni di fusione Open GL sono lineari e funzionano quando lo sfondo della destinazione è opaco. Ma l'equazione di fusione effettiva per la fusione di due livelli trasparenti non è un'equazione lineare e contiene una parte di divisione.

out_color = {src_color * src_alpha + dest_color * dest_alpha * (1-src_alpha)} / out_alpha

Non credo sia possibile farlo con le attuali implementazioni di OpengGL. Quindi, per ovviare a questo problema, ho dovuto utilizzare un pixel shader per calcolare manualmente l'output di ciascun pixel.