Perché gli oggetti Vertex Buffer migliorano le prestazioni?

Dalla mia comprensione di base, un oggetto buffer vertice funziona in questo modo (pseudo codice):

Normalmente, se si volesse dire, disegnare un quadrato, si potrebbero emettere comandi di disegno al tratto.

line (0, 0) -> (1, 0)
line (1, 0) -> (1, 1)
line (1, 1) -> (0, 1)
line (0, 1) -> (0, 0)

L'uso di un VBO, se ho capito bene, carica i vertici in un VBO.

define VBO
load (0,0) -> VBO
load (1,0) -> VBO
load (1,1) -> VBO
load (0,1) -> VBO
load (0,0) -> VBO

Quindi è possibile emettere un comando di disegno.

draw VBO vertices

Mentre capisco come funzionano i VBO, non so perché migliorino le prestazioni.

Come migliorano le prestazioni?

In generale, quando si esegue il rendering di un oggetto in una modalità immediata, ad esempio inviando comandi di disegno al tratto, si crea una serie di comandi che si invia alla scheda grafica per disegnare. Se stai disegnando molti dati o disegni molto frequentemente, puoi perdere molto tempo a inviare questi dati più e più volte.

Un buffer di vertici consente di produrre un singolo oggetto che si invia alla scheda grafica una volta. Se non è necessario modificare la geometria, è possibile lasciarla sulla scheda grafica e inviare semplicemente alla scheda grafica una richiesta per disegnare quell'oggetto. Dal momento che evita la copia ogni volta che disegni, c'è molto meno sovraccarico per ogni disegno.

Si noti che l'utilizzo di un oggetto buffer vertici non fornisce sempre un'accelerazione molto significativa. Se stai disegnando l'oggetto una sola volta per fotogramma e stai sostituendo la geometria tra ciascun fotogramma, non otterrai i vantaggi di evitare la copia di ogni fotogramma.

La maggior parte della mia esperienza proviene dalla scrittura di programmi che utilizzano API grafiche come OpenGL, quindi qualcuno che ha pasticciato con il backend di un driver grafico può probabilmente fornire una risposta più dettagliata, ma spero che questo renda le cose un po 'più chiare.

Esistono due passaggi che rendono il VBO più efficiente della modalità immediata.

1. La modalità immediata ( glBegin / glEnd , glVertex * , ecc.) Significa che ad ogni fotogramma, si alimentano i vertici, l'attributo per attributo (posizione, normale, colore, ecc.) Al driver, che quindi li riformatta e infine invia l'intero pacchetto come comando per la GPU. Che molte funzioni chiamano per vertice su ciascun frame.
   (Si noti che la modalità immediata è obsoleta a partire da OpenGL 3.0 e viene completamente rimossa da 3.2 .)

2. Usando gli array di vertici (vedi glDrawArrays , glDrawElements , glVertexPointer , ecc.), Puoi dare al guidatore tutto in una volta e risparmiargli il carico di riformattare i vertici. Stai sostituendo efficacemente diverse chiamate di funzione per vertice con solo una manciata di chiamate per l'intera mesh. Ma devi ancora farlo una volta in una cornice.

3. Vertex Buffer Object o VBO (vedi glGenBuffers , glBindBuffer , ecc.) Fai un ulteriore passo avanti e memorizza i dati sul lato GPU: li invii solo una volta e poi li fai riferimento con un handle. Risparmiate larghezza di banda non inviando gli stessi dati più e più volte su ogni frame.

Usando un'interfaccia in modalità immediata (ad es. Vecchio stile OpenGL glBegin () / glEnd () / glVertex ()) si gocciolano effettivamente i dati di alimentazione al conducente un pezzo alla volta. Deve quindi prendere quel singolo pezzo di dati, riformattarlo e trasmetterlo all'hardware (che oggigiorno significa metterlo in un buffer di comando).

Utilizzando un oggetto buffer vertici, si fornisce un driver (si spera) di grandi dimensioni di dati al driver prima di quando deve essere utilizzato. Può eseguire una serie di ottimizzazioni (riformattazione, inserimento nella memoria video) oltre a non dover alimentare la GPU frammentaria.

In pratica se stai disegnando solo un piccolo numero di primitive, probabilmente non farà molta differenza, tuttavia se stai disegnando una maglia multi-milioni di triangoli, i VBO nella memoria video sono la strada da percorrere.