¿Cuántos vértices se necesitan para dibujar un cubo en OpenGL ES?

Question

Veo una cantidad diferente de vértices en diferentes sitios en línea para representar el mismo cubo en OpenGL ES. Por ejemplo, este es uno:

float vertices[] = { -width, -height, -depth, // 0 
           width, -height, -depth, // 1 
           width, height, -depth, // 2 
          -width, height, -depth, // 3 
          -width, -height, depth, // 4 
           width, -height, depth, // 5 
           width, height, depth, // 6 
          -width, height, depth // 7 
     }; 
    short indices[] = { 0, 2, 1, 
       0, 3, 2, 

       1,2,6, 
       6,5,1, 

       4,5,6, 
       6,7,4, 

       2,3,6, 
       6,3,7, 

       0,7,3, 
       0,4,7, 

       0,1,5, 
       0,5,4 
         }; 

Y aquí es otra:

float vertices[] = { 
      //Vertices according to faces 
       -1.0f, -1.0f, 1.0f, //Vertex 0 
       1.0f, -1.0f, 1.0f, //v1 
       -1.0f, 1.0f, 1.0f, //v2 
       1.0f, 1.0f, 1.0f, //v3 

       1.0f, -1.0f, 1.0f, //... 
       1.0f, -1.0f, -1.0f,   
       1.0f, 1.0f, 1.0f, 
       1.0f, 1.0f, -1.0f, 

       1.0f, -1.0f, -1.0f, 
       -1.0f, -1.0f, -1.0f,    
       1.0f, 1.0f, -1.0f, 
       -1.0f, 1.0f, -1.0f, 

       -1.0f, -1.0f, -1.0f, 
       -1.0f, -1.0f, 1.0f,   
       -1.0f, 1.0f, -1.0f, 
       -1.0f, 1.0f, 1.0f, 

       -1.0f, -1.0f, -1.0f, 
       1.0f, -1.0f, -1.0f,   
       -1.0f, -1.0f, 1.0f, 
       1.0f, -1.0f, 1.0f, 

       -1.0f, 1.0f, 1.0f, 
       1.0f, 1.0f, 1.0f,   
       -1.0f, 1.0f, -1.0f, 
       1.0f, 1.0f, -1.0f, 
            }; 

Cuál es la representación más alto rendimiento en OpenGL ES (Tenga en cuenta que se trata de OpenGL ES y no OpenGL)? Cuál es la mejor representación cuando quiero especificar las normales para la iluminación. En uno de mis otros quations en SO, tengo la impresión de que necesito especificar 24 vértices para el cubo, otro dice que necesito 36 vértices, y otro dice que necesito un número diferente para obtener respuestas contradictorias a la misma pregunta. De todos modos, quiero saber la respuesta única correcta que es técnicamente correcta.

Yo sé que hay un concepto de aficionados Triángulo Triángulo de Gaza o de dibujo, etc., pero en mi caso estoy usando:

gl.glDrawElements(GL10.GL_TRIANGLES, mNumOfIndices, 
       GL10.GL_UNSIGNED_SHORT, mIndicesBuffer); 

lo que este debe aclarar con claridad lo que estoy pidiendo.

Answer 1

Si usa índices, solo necesita proporcionar 8 vértices distintos para definir un cubo en OpenGL ES. Por ejemplo:

static const GLfloat cubeVertices[] = { 
    -1.0, -1.0, 1.0, 
    1.0, -1.0, 1.0, 
    -1.0, 1.0, 1.0, 
    1.0, 1.0, 1.0, 
    -1.0, -1.0, -1.0, 
    1.0, -1.0, -1.0, 
    -1.0, 1.0, -1.0, 
    1.0, 1.0, -1.0, 
}; 

static const GLushort cubeIndices[] = { 
    0, 1, 2, 3, 7, 1, 5, 4, 7, 6, 2, 4, 0, 1 
}; 

Usando una tira de triángulos de la geometría aquí, sólo se necesitaba para proporcionar 14 índices de especificar el cubo. Puede eliminar los índices anteriores y proporcionar vértices en ese orden, si lo desea.

genpfault describe el caso en el que proporciona triángulos puros para OpenGL ES, en cuyo caso necesitaría 36 vértices. Como puede ver, muchos de estos vértices son redundantes, por lo que las tiras o índices pueden reducir la geometría que necesita enviar.

Eric trae a colación un buen punto en su comentario, que si necesita proporcionar una textura o color a cada cara (que appears to be your goal) querrá usar 24 vértices o índices. Lo necesita para poder abordar cada cara por separado.

El rendimiento más alto para su aplicación en particular dependerá del hardware con el que esté ejecutando esto. Por ejemplo, en los chips PowerVR dentro de los dispositivos IOS, Apple has this to say:

Para un mejor rendimiento, sus modelos debe presentarse como una sola tira triángulo no indexados usando glDrawArrays con tan sólo duplicados vértices como sea posible. Si sus modelos requieren muchos vértices a ser duplicadas (debido a que muchos vértices son compartidos por triángulos que no aparecen secuencialmente en la tira triángulo o debido a que su aplicación se fusionó muchas menor tiras de triángulos), es posible que obtener mejor rendimiento al utilizar a búfer de índice separado y llamar a glDrawElements en su lugar. Hay un equilibrio fuera: una tira de triángulos no indexados debe duplicar periódicamente enteras vértices, mientras que una lista indexada triángulo requiere memoria adicional para los índices implica una sobrecarga y mirar hacia arriba vértices.Para obtener los mejores resultados, pruebe sus modelos usando tiras triangulares sin indexar indexadas y , y utilice el que sea el que tenga el mejor rendimiento.