GLSL esegue davvero calcoli superflui con valori uniformi (non per vertice)?

Question

Per esempio, se io uso vertex shader come la seguente:

#version 400 core 

uniform mat4 projM; 
uniform mat4 viewM; 
uniform mat4 modelM; 

in vec4 in_Position; 

out vec4 pass_position_model; 

void main(void) { 
    gl_Position = projM * viewM * modelM * in_Position; 
    pass_position_model = modelM * in_Position; 
} 

intende fare projM * viewM * modelM moltiplicazione di matrici per ogni vertice, o abbastanza intelligente per calcolare se una volta e non ricalcolare fino variabili uniformi sono cambiati? Se non è "abbastanza intelligente", c'è un modo per ottimizzarlo se non quello di calcolare tutti i valori dipendenti dalla CPU e inviarli come variabili uniformi alla GPU?
Inoltre sono interessato alle soluzioni che possono essere convertite in OpenGL ES 2.0 in seguito senza problemi.

Answer 1

Quindi non c'è una risposta generale, come ho capito. Ho fatto alcuni test sul mio hardware, però. Ho 2 GPU nel mio inventario, Intel HD Graphics 3000 e NVidia GeForce GT 555M. Ho testato il mio programma (il programma stesso è stato scritto in java/scala) con moltiplicazione della matrice in vertex shader, quindi ho spostato la moltiplicazione nel programma della CPU e ho testato di nuovo.

(sferaN: è una sfera a rotazione continua con 2 * N^2 quad, disegnata con glDrawElements (GL_QUADS, ...) Con 1 consistenza e senza alcuna illuminazione/altri effetti)

matrice moltiplicazione nella vertex:

intel: 
    sphere400: 57.17552887364208 fps 
    sphere40: 128.1394156842645 fps 
nvidia: 
    sphere400: 134.9527665317139 fps 
    sphere40: 242.0135527589545 fps 

moltiplicazione matriciale sulla CPU:

intel: 
    sphere400: 57.37234652897303 fps 
    sphere40: 128.2051282051282 fps 
nvidia: 
    sphere400: 142.28799089356858 fps 
    sphere40: 247.1576866040534 fps 

test dimostrano che multiplicating (uniforme) le matrici in vertex shader sono una pessima idea, almeno su questo hardware. Quindi in generale non si può fare affidamento sull'ottimizzazione del compilatore GLSL corrispondente.

Answer 2

Effettua moltiplicazione di matrice projM * viewM * modelM per ogni vertice o è abbastanza intelligente da calcolare se una volta e non ricalcolare fino a quando non vengono modificate le variabili uniformi?

Chiedi allo sviluppatore l'implementazione di OpenGL in questione. Le specifiche OpenGL non hanno nulla da dire su questo, ma i produttori di compilatori di driver e GLSL potrebbero aver implementato ottimizzazioni per questo.

Se non lo è "abbastanza intelligente", allora c'è un modo per ottimizzarlo altro di calcolare tutti i valori uniformi-dipendente dalla CPU e inviarli come variabili uniformi per GPU?

No. Devi fare il legwork da solo.

Answer 3

Tutte le ottimizzazioni OpenGL e GLSL sono specifiche del fornitore. È piuttosto difficile stabilire quale sia l'output finale del compilatore glsl.

Potete guardare qui per informazioni specifiche del fornitore: http://renderingpipeline.com/graphics-literature/low-level-gpu-documentation/

Per il vostro codice è possibile sempre 'pack' matrici in nuova uniforme: matModelViewProjection, moltiplicarlo nella domanda e inviarla al vertex shader.

Answer 4

Questo dipende interamente dal conducente. OpenGL è una specifica, se li paghi per i diritti di fare un'implantosa ti daranno una implzione di esempio da usare, ma il gioco è fatto.

Oltre a ciò è necessario considerare le limitazioni di moltiplicazione della matrice, facendo projM * viewM * modelM * vertex non è lo stesso di vertex * projM * viewM * modelM. Questo perché le matrici vengono moltiplicate da destra a sinistra e l'ordine conta con questo. Quindi lo shader non ha potuto calcolare lo projM * viewM * modelM pre-calcolato da condividere tra i vertici, perché ciò darebbe risultati fasulli.