Por que os objetos de buffer do vértice melhoram o desempenho?

Do meu entendimento básico, um objeto de buffer do vértice funciona mais ou menos assim (pseudo-código):

Normalmente, se alguém quiser dizer, desenhe um quadrado, poderá emitir comandos de desenho de linha.

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

Usar um VBO, se bem entendi, carregaria os vértices em um VBO.

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

Então você pode emitir um comando de desenho.

draw VBO vertices

Embora eu entenda como os VBOs funcionam, não sei por que eles melhoram o desempenho.

Como eles melhoram o desempenho?

Em geral, quando você renderiza um objeto em um modo imediato - emitindo comandos de desenho de linha, por exemplo - você cria uma série de comandos que envia à placa gráfica para desenhar. Se você estiver desenhando muitos dados ou desenhando com muita frequência, poderá perder muito tempo enviando esses dados repetidamente.

Um buffer de vértice permite produzir um único objeto que você envia à placa gráfica uma vez. Se você não precisar alterar sua geometria, poderá deixá-la na placa gráfica e simplesmente enviar à placa gráfica uma solicitação para desenhar esse objeto. Como evita a cópia toda vez que você desenha, há muito menos sobrecarga para cada desenho.

Observe que o uso de um objeto de buffer de vértice nem sempre fornece uma aceleração muito significativa. Se você estiver desenhando o objeto apenas uma vez por quadro e substituindo a geometria entre cada quadro, não terá os benefícios de evitar a cópia de cada quadro.

A maior parte da minha experiência vem da criação de programas usando APIs gráficas como o OpenGL; portanto, alguém que mexeu com o back-end de um driver gráfico provavelmente pode fornecer uma resposta mais detalhada, mas espero que isso torne as coisas um pouco mais claras.

Há duas etapas que tornam o VBO mais eficiente que o modo imediato.

1. O modo imediato ( glBegin / glEnd , glVertex * , etc.) significa que, em cada quadro, você alimenta os vértices, atributo por atributo (posição, normal, cor etc.), ao driver, que os reformata e finalmente envia o pacote inteiro como um comando para a GPU. Que muitas funções chamam por vértice em cada quadro.
   (Observe que o modo imediato está obsoleto desde o OpenGL 3.0 e foi totalmente removido do 3.2 .)

2. Usando matrizes de vértices (consulte glDrawArrays , glDrawElements , glVertexPointer etc.), você pode fornecer ao driver a coisa toda de uma só vez e poupar o ônus de reformatar os vértices. Você está efetivamente substituindo várias chamadas de função por vértice por apenas algumas chamadas para toda a malha. Mas você ainda precisa fazer isso uma vez por quadro.

3. O Vertex Buffer Object , ou VBO (consulte glGenBuffers , glBindBuffer , etc.) vai um passo além e armazena os dados no lado da GPU: você envia apenas uma vez e depois refere-se a ele por um identificador. Você economiza largura de banda ao não enviar os mesmos dados repetidamente em cada quadro.

Ao usar uma interface de modo imediato (por exemplo, OpenGL glBegin () / glEnd () / glVertex ()), você efetivamente pinga dados de alimentação ao motorista, uma peça de cada vez. Em seguida, ele precisa pegar esse único dado, reformatá-lo e transmiti-lo ao hardware (o que hoje em dia significa colocá-lo em um buffer de comando).

Ao usar um objeto de buffer de vértice, você está fornecendo (esperançosamente) um grande bloco de dados ao driver antes do momento em que ele precisa ser usado. Ele pode executar várias otimizações (reformatação, colocação na memória de vídeo), além de não ter que alimentar a GPU aos poucos.

Na prática, se você estiver desenhando apenas um pequeno número de primitivas, provavelmente não fará muita diferença; no entanto, se você estiver desenhando uma malha de vários milhões de triângulos, os VBOs na memória de vídeo serão o caminho a seguir.