Qual é o objetivo dos índices na renderização em 3D?

Suponha que você estivesse criando um cubo 3D no OpenGL. Você implementa os dados de vértice necessários para o objeto (cubo). Qual seria o sentido de usar índices?

 void CreateCube()
        {
            const Vertex VERTICES[8] =
            {
                { { -.5f, -.5f,  .5f, 1 }, { 0, 0, 1, 1 } },
                { { -.5f,  .5f,  .5f, 1 }, { 1, 0, 0, 1 } },
                { {  .5f,  .5f,  .5f, 1 }, { 0, 1, 0, 1 } },
                { {  .5f, -.5f,  .5f, 1 }, { 1, 1, 0, 1 } },
                { { -.5f, -.5f, -.5f, 1 }, { 1, 1, 1, 1 } },
                { { -.5f,  .5f, -.5f, 1 }, { 1, 0, 0, 1 } },
                { {  .5f,  .5f, -.5f, 1 }, { 1, 0, 1, 1 } },
                { {  .5f, -.5f, -.5f, 1 }, { 0, 0, 1, 1 } }
            };

            const GLuint INDICES[36] =
            {
                0,2,1,  0,3,2,
                4,3,0,  4,7,3,
                4,1,5,  4,0,1,
                3,6,2,  3,7,6,
                1,6,5,  1,2,6,
                7,5,6,  7,4,5
            };

    //....

    glBufferData(GL_ARRAY_BUFFER, sizeof(VERTICES), VERTICES, GL_STATIC_DRAW);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(INDICES), INDICES, GL_STATIC_DRAW);

No exemplo acima, um cubo é criado com os vértices necessários no espaço do mundo. Qual a relevância para os índices?

Existem índices para reduzir a pegada de memória necessária para representar um modelo 3D, da mesma maneira que as paletas de cores podem ser usadas para reduzir a pegada de memória de uma imagem 2D.

A indexação permite evitar repetir uma definição completa de um vértice se você precisar duplicar os dados desse vértice, como geralmente é necessário para um modelo complexo.

As APIs 3D modernas são renderizadas usando triângulos; cada face de um cubo requer dois triângulos:

A--B 
|\ |   This cube face has two triangles:
| \|   ABD and ADC.
C--D

Para especificar essa face sem índices, você deve especificar os vértices A, B, D, A, D, C. Dois vértices ( Ae D) são repetidos no buffer de vértice.

No entanto, com índices, você pode ter um buffer de vértices contendo apenas os vértices necessários ( A, B, Ce D) e seis índices: 0, 1, 3, 0, 3, 2. Como os índices são geralmente muito menores que os vértices e muitos vértices geralmente se repetem em modelos práticos, isso pode ser uma economia significativa de espaço.

Observe que alguns vértices compartilham apenas atributos parciais. Por exemplo, ao renderizar um cubo com mapeamento de textura, geralmente se deseja coordenadas de textura exclusivas por face, para que você tenha vários vértices com a mesma posição e coordenadas de textura diferentes. Essa quantidade de duplicação é aceitável e necessária; é quando você duplica um conjunto inteiro de atributos de vértice que começa a ver os benefícios da indexação.

Se de fato todos os seus vértices da malha são 100% distintos, não há benefício para os índices (na verdade, você usaria mais espaço no consumo do buffer de índice redundante). Isso nem sempre ocorre, no entanto.

O uso de índices serve para três propósitos principais:

• Reduzindo os requisitos de memória, permitindo que os vértices duplicados sejam removidos da malha original.
• Reduzindo os cálculos de sombreadores de vértices, permitindo que vértices duplicados sejam transformados apenas uma vez.
• Concatenar primitivas, permitindo reduzir as chamadas de empate.

Destes, o primeiro é óbvio, porque você pode medi-lo diretamente em seu próprio código: se uma malha tiver, digamos, 50k vértices, mas se 30k deles forem duplicados, você terá uma economia de memória.

O segundo e o terceiro não são tão óbvios - você já deve ter tomado a decisão de usar índices e precisa criar um perfil de seu código e isolar o desempenho "antes" e "depois" para obter uma medição deles.

Para o segundo, o hardware pode armazenar em cache o resultado dos vértices recentemente transformados. Se o mesmo vértice que foi transformado recentemente aparecer, a versão em cache poderá ser usada em vez de ter que executar os cálculos novamente. O hardware usa o índice para identificá-los, portanto, os índices são absolutamente necessários para obter esse comportamento.

Na terceira, cada chamada de empate que você faz tem uma sobrecarga de CPU, independentemente da quantidade de trabalho da GPU necessária. Se tudo o resto for igual, desenhar uma malha de 50k em uma chamada de desenho será muito mais rápido do que desenhar em chamadas de desenho de 10k. Mas se sua malha é composta de várias tiras, ou (pior ainda) uma combinação de tiras e ventiladores, você não pode fazer isso em uma única chamada sem (1) usar índices ou (2) introduzir triângulos degenerados. Porém, como os índices são muito menores que os vértices, o uso de índices é preferido no caso geral.

Os índices dizem que grupos de três vértices juntos formam as faces do cubo. Nem todos os conjuntos de três vértices do triângulo são faces do triângulo.

Você pode usar cada vértice exatamente uma vez e apenas repetir várias vezes as que são usadas em mais de um triângulo, mas isso significaria transformações extras de vértice. Com os índices, você transforma os vértices apenas uma vez e os utiliza quantas vezes for necessário.