O desenho de índice é mais rápido que o desenho não indexado

Eu preciso desenhar muitos polígonos consistindo em 6 vértices (dois triângulos).

Sem coordenadas de textura, normais etc., ambas as abordagens resultam em 72 bytes. No futuro, eu definitivamente também precisaria de coordenadas e normais de textura, o que faria o desenho do índice consumir menos memória. Não muito embora.

Então, minha pergunta é: para VAOs com poucas sobreposições de vértices, qual abordagem é mais rápida? Eu não ligo para a memória extra consumida pelo desenho não indexado, apenas pela velocidade.

Editar: para deixar claro.

Abordagem não indexada:

float[18] vertices = {
//Triangle 1
1,1,0,
1,0,0,
0,0,0,

//Triangle 2
1,0,0,
0,1,0,
0,0,0,
};

Abordagem de índice:

float[12] vertices = {
1,1,0,
1,0,0,
0,0,0,
0,1,0,
};

int[6] indices = {
//Triangle 1
0,1,2,

//Triangle 2
0,3,2
};

Eu tento responder a pergunta. Eu acho que você deve ir com índices, por alguns motivos:

1) Em qualquer caso, a indexação é uma operação livre no lado da GPU, você não aplica penalidades lá. (adicionado) Obviamente, os índices são operações de acesso aleatório e podem prejudicar o desempenho do cache de memória da GPU.

2) A indexação pode permitir que o cache de vértices da GPU faça essas poucas otimizações para vértices sobrepostos.

3) Menor espaço de memória no lado da GPU muitas vezes significa melhor desempenho, pois a largura de banda da memória é um dos gargalos e porque muitas vezes as operações de extração (por exemplo, 10_10_10_2 -> 4 x flutuação) não são caras.

A diferença de velocidade provavelmente não é perceptível se não houver muitos vértices sobrepostos nos quais você poderá obter melhorias na velocidade. Mas eu realmente não tenho fatos concretos para apoiar minha opinião (para acompanhar os índices).

Veja também isto:

/programming/17503787/buffers-indexed-or-direct-interlaced-or-separate

Se as posições são sempre as mesmas, você pode ficar sem buffers armazenando a matriz no sombreador e usando gl_VertexIDpara selecionar o vértice no sombreador de vértices.

#version 330 core

const vec3 data[4] = vec3[]
(
//Triangle 1
vec3(1,1,0),
vec3(1,0,0),
vec3(0,0,0),

//Triangle 2
vec3(1,0,0),
vec3(0,1,0),
vec3(0,0,0)
);

void main()
{
  gl_Position = vec4( data[ gl_VertexID ], 1.0);
}

como em todas as coisas de desempenho, não adivinhe, crie um perfil para descobrir.

variará dependendo do hardware e de muitos fatores complicados. medi-lo por perfil considerará automaticamente todas essas coisas para você sem que você precise saber nada sobre elas.

Minha suposição é que o uso de indexação para vértices seria mais lento.

Eu não entendi a pergunta original, mas aqui está a resposta para a indexação de cores. Eu estou supondo que as mesmas regras se aplicariam à indexação de vértices (sem perda de precisão), mas isso é apenas um palpite.

Mas...

• Como regra geral, sugiro a indexação.
• A indexação é mais lenta.
• A não indexação é mais rápida.
• A indexação é mais eficiente em memória.
• Não indexar é menos eficiente em memória.
• A indexação perde a precisão das cores.
• A não indexação não perde a precisão das cores.

72 bytes é tão pequeno que provavelmente seria mais eficiente na memória não indexá-lo.

Algumas regras práticas: A indexação é mais eficiente em memória. A indexação perde a precisão das cores. A não indexação é mais rápida.

Isso pode fazer com que você nunca queira usar a indexação, mas a troca de memória é bastante significativa para imagens de tamanho decente. A precisão da cor é imperceptível.

A maneira como a indexação funciona é que, ao desenhar um pixel, ele recebe um índice e deve procurar a cor em uma tabela de tamanho predeterminado. (Digamos 256 bytes, então você está limitado a 256 cores). Então desenha esse pixel. Nenhuma indexação armazena os dados de pixel diretamente, portanto, não há limite de cores para 256. Mas em uma imagem de 100x100, sua imagem de 400 bytes é agora 10000 bytes.

Isenção de responsabilidade, estou tirando esses números do meu chapéu.