Quando chiamare glEnable (GL_FRAMEBUFFER_SRGB)?

Question

Ho un sistema di rendering in cui disegno su un FBO con un renderbuffer a campionamento multiplo, quindi lo confondono con un altro FBO con una texture per risolvere i campioni in modo da leggere la texture per eseguire l'ombreggiatura post-elaborazione mentre disegno al backbuffer (indice FBO 0).

Ora mi piacerebbe ottenere un output sRGB corretto ... Il problema è il comportamento del programma è piuttosto incoerente tra quando lo eseguo su OS X e Windows e questo cambia anche a seconda della macchina: Su Windows con Intel HD 3000 non si applica la non linearità sRGB ma sull'altra mia macchina con una Nvidia GTX 670. Su Intel HD 3000 in OS X lo applicherà anche.

Quindi questo probabilmente significa che non sto impostando lo stato di abilitazione GL_FRAMEBUFFER_SRGB nei punti corretti del programma. Tuttavia non riesco a trovare alcun tutorial che in realtà mi dica quando dovrei abilitarlo, dicono solo che è facile e non ha costi di performance.

Attualmente non sto caricando in nessuna trama, quindi non ho ancora avuto la necessità di gestire la linearizzazione dei loro colori.

Per forzare il programma a non sputare semplicemente indietro i valori di colore lineari, ciò che ho provato è semplicemente commentare la mia riga glDisable(GL_FRAMEBUFFER_SRGB), che in pratica significa che questa impostazione è abilitata per l'intera pipeline e in realtà la forza indietro di forza su ogni frame.

Non so se questo è corretto o meno. Certamente applica una non linearizzazione ai colori, ma non posso dire se questo viene applicato due volte (il che sarebbe male). Potrebbe applicare la gamma mentre eseguo il rendering al mio primo FBO. Potrebbe farlo quando bliterò il primo FBO al secondo FBO. Perchè no?

Sono andato al punto di prendere i colpi dello schermo del mio fotogramma finale e confrontare i valori di colore dei pixel prima per i colori li ho impostato al programma:

ho impostato il colore ingresso RGB (1, 2,3) e l'uscita è RGB (13,22,28).

Sembra quasi una compressione di colori molto bassa e mi porta a chiedermi se la gamma viene applicata più volte.

Ho appena eseguito l'equazione sRGB e posso verificare che la conversione sembra essere applicata solo una volta in quanto i valori 1/255, 2/255 e 3/255 lineari corrispondono a sRGB 13/255, 22/255 e 28/255 utilizzando l'equazione 1.055*C^(1/2.4)+0.055. Dato che l'espansione è così grande per questi bassi valori di colore, dovrebbe essere ovvio se la trasformazione del colore sRGB viene applicata più volte.

Quindi, non ho ancora determinato quale sia la cosa giusta da fare. fa glEnable(GL_FRAMEBUFFER_SRGB) si applica solo ai valori del framebuffer finale, nel qual caso posso semplicemente impostarlo durante la mia routine GL init e dimenticarlo qui di seguito?

Answer 1

Quando GL_FRAMEBUFFER_SRGB è abilitato, tutte le scritture su un'immagine con an sRGB image format presuppongono che i colori di input (i colori in fase di scrittura) si trovino in uno spazio colore lineare. Pertanto, li convertirà nello spazio colori sRGB.

Qualsiasi scrittura su immagini che sono non nel formato sRGB non dovrebbe essere interessata. Quindi se stai scrivendo su un'immagine a virgola mobile, non dovrebbe accadere nulla. Pertanto, dovresti essere in grado di accenderlo e lasciarlo in quel modo; OpenGL saprà quando si esegue il rendering su un framebuffer sRGB.

In generale, si desidera lavorare in uno spazio cromatico lineare il più a lungo possibile.Solo il rendering finale, dopo la post-elaborazione, dovrebbe coinvolgere lo spazio colore sRGB. Quindi il tuo framebuffer multisampling dovrebbe probabilmente rimanere lineare (anche se dovresti dargli una risoluzione più alta per i suoi colori per preservare la precisione. Utilizza GL_RGB10_A2, GL_R11F_G11F_B10F o GL_RGBA16F come ultima risorsa).

Per quanto riguarda questo:

Su Windows con il processore Intel HD 3000 non applicherà la non linearità sRGB

che è quasi certamente dovuto al Intel succhiare a scrivere driver OpenGL. Se non sta facendo la cosa giusta quando abiliti GL_FRAMEBUFFER_SRGB, questo è dovuto a Intel, non al tuo codice.

Ovviamente, potrebbe anche darsi che i driver di Intel non abbiano fornito un'immagine sRGB per cominciare (se si esegue il rendering sul framebuffer predefinito).