In quale ordine dovrei inviare i miei vertici a OpenGL per Culling

Question

Sto imparando un punto di 3d opengl, e sta andando piuttosto bene, ho una bella macchina fotografica in movimento e alcuni oggetti cubo semplici, al momento. Attualmente utilizzo gli array di vertici, ma sto passando a VBO abbastanza velocemente qui. Sto solo cercando di consentire l'abbattimento, ma non sono sicuro che ordine in cui dovrei specificare i miei vertici, in questo momento questo è quello che sto facendo:

void cube::update_verts(){ 
GLushort cur=0; 

///back face 
verts[cur++]=x; verts[cur++]=y; verts[cur++]=z; 
verts[cur++]=x+sx; verts[cur++]=y; verts[cur++]=z; 
verts[cur++]=x+sx; verts[cur++]=y+sy; verts[cur++]=z; 
verts[cur++]=x; verts[cur++]=y+sy; verts[cur++]=z; 

///right face 
verts[cur++]=x+sx; verts[cur++]=y+sy; verts[cur++]=z; 
verts[cur++]=x+sx; verts[cur++]=y; verts[cur++]=z; 
verts[cur++]=x+sx; verts[cur++]=y; verts[cur++]=z+sz; 
verts[cur++]=x+sx; verts[cur++]=y+sy; verts[cur++]=z+sz; 

///top face 
verts[cur++]=x+sx; verts[cur++]=y+sy; verts[cur++]=z; 
verts[cur++]=x; verts[cur++]=y+sy; verts[cur++]=z; 
verts[cur++]=x; verts[cur++]=y+sy; verts[cur++]=z+sz; 
verts[cur++]=x+sx; verts[cur++]=y+sy; verts[cur++]=z+sz; 

///front face 
verts[cur++]=x; verts[cur++]=y; verts[cur++]=z+sz; 
verts[cur++]=x+sx; verts[cur++]=y; verts[cur++]=z+sz; 
verts[cur++]=x+sx; verts[cur++]=y+sy; verts[cur++]=z+sz; 
verts[cur++]=x; verts[cur++]=y+sy; verts[cur++]=z+sz; 

///bottom face 
verts[cur++]=x+sx; verts[cur++]=y; verts[cur++]=z; 
verts[cur++]=x; verts[cur++]=y; verts[cur++]=z; 
verts[cur++]=x; verts[cur++]=y; verts[cur++]=z+sz; 
verts[cur++]=x+sx; verts[cur++]=y; verts[cur++]=z+sz; 

///left face 
verts[cur++]=x; verts[cur++]=y+sy; verts[cur++]=z; 
verts[cur++]=x; verts[cur++]=y; verts[cur++]=z; 
verts[cur++]=x; verts[cur++]=y; verts[cur++]=z+sz; 
verts[cur++]=x; verts[cur++]=y+sy; verts[cur++]=z+sz; 


} 

///Drawing Code: 

glVertexPointer(3,GL_FLOAT,0,object.verts); 
glColorPointer(3,GL_UNSIGNED_BYTE,0,object.colors); 
glDrawArrays(GL_QUADS,0,6*4); 

Tuttavia è sicuramente sbagliato, perché quando I glEnable(GL_CULL_FACE); i miei cubi non mostrano i volti corretti (come visto sotto).

Normale

Problem Child

Con entrambe queste immagini abbattimento è abilitato.

In quale ordine devo specificare i vertici?

---

(EDIT) Funzione di lavoro Aggiornato:

void cube::update_verts(){ 
GLushort cur=0; 

///top face 
verts[cur++]=x; verts[cur++]=y+sy; verts[cur++]=z; 
verts[cur++]=x; verts[cur++]=y+sy; verts[cur++]=z+sz; 
verts[cur++]=x+sx; verts[cur++]=y+sy; verts[cur++]=z+sz; 
verts[cur++]=x+sx; verts[cur++]=y+sy; verts[cur++]=z; 


///bottom face 
verts[cur++]=x; verts[cur++]=y; verts[cur++]=z; 
verts[cur++]=x+sx; verts[cur++]=y; verts[cur++]=z; 
verts[cur++]=x+sx; verts[cur++]=y; verts[cur++]=z+sz; 
verts[cur++]=x; verts[cur++]=y; verts[cur++]=z+sz; 

///left face 
verts[cur++]=x; verts[cur++]=y; verts[cur++]=z; 
verts[cur++]=x; verts[cur++]=y; verts[cur++]=z+sz; 
verts[cur++]=x; verts[cur++]=y+sy; verts[cur++]=z+sz; 
verts[cur++]=x; verts[cur++]=y+sy; verts[cur++]=z; 

///right face 
verts[cur++]=x+sx; verts[cur++]=y; verts[cur++]=z; 
verts[cur++]=x+sx; verts[cur++]=y+sy; verts[cur++]=z; 
verts[cur++]=x+sx; verts[cur++]=y+sy; verts[cur++]=z+sz; 
verts[cur++]=x+sx; verts[cur++]=y; verts[cur++]=z+sz; 

///front face 
verts[cur++]=x; verts[cur++]=y; verts[cur++]=z+sz; 
verts[cur++]=x+sx; verts[cur++]=y; verts[cur++]=z+sz; 
verts[cur++]=x+sx; verts[cur++]=y+sy; verts[cur++]=z+sz; 
verts[cur++]=x; verts[cur++]=y+sy; verts[cur++]=z+sz; 


///back face 
verts[cur++]=x; verts[cur++]=y; verts[cur++]=z; 
verts[cur++]=x; verts[cur++]=y+sy; verts[cur++]=z; 
verts[cur++]=x+sx; verts[cur++]=y+sy; verts[cur++]=z; 
verts[cur++]=x+sx; verts[cur++]=y; verts[cur++]=z; 

} 

Answer 1

Per impostazione predefinita? In senso antiorario.

consideri un triangolo di fronte alla telecamera:

A 
|\ 
| \ 
| \ 
B---C 

A-> B-> C sarebbe sul davanti (ordine antiorario), A-> C> B sarebbe rivolto all'indietro (in senso orario ordine).

È possibile modificare la direzione OpenGL considera "sul davanti" via glFrontFace():

La proiezione di un poligono per finestra coordinate viene detto avere avvolgimento se un oggetto immaginario seguendo il percorso dal suo prima in senso orario vertice, il suo secondo vertice, e così via, fino all'ultimo vertice, e finalmente tornato al suo primo vertice, si muove in senso orario su all'interno del poligono. Si dice che l'avvolgimento del poligono sia in senso antiorario se l'oggetto immaginario che segue lo stesso percorso si sposta su in senso antiorario all'interno del poligono. glFrontFace specifica se i poligoni con avvolgimento oraria nelle coordinate della finestra o in senso antiorario nelle coordinate della finestra, devono essere orientati frontalmente. Il passaggio da GL_CCW a mode seleziona i poligoni in senso antiorario in senso antiorario come frontali; GL_CW seleziona i poligoni in senso orario come frontali.

Per impostazione predefinita, i poligoni in senso antiorario sono considerati rivolti verso il lato anteriore.

Per ordinare i tuoi vertici, si consideri un cubo ideale:

6---7 
/| /| 
2---3 | 
| 4-|-5 
|/ |/ 
0---1 

per ogni faccia mentalmente ruotarlo di fronte alla telecamera (occhio della mente):

Sides: 
2---3 3---7 7---6 6---2 
| | | | | | | | 
| | | | | | | | 
0---1 1---5 5---4 4---0 

Bottom/Top 
0---1 6---7 
| | | | 
| | | | 
4---5 2---3 

allora si può solo leggere visivamente i quad o le coppie di triangoli nell'ordine in senso antiorario destro:

2---3    3   2---3 
| | becomes  /| and |/
| |   /|   |/ 
0---1   0---1   0 

Triangles 0-1-3 and 0-3-2 
Quad 0-1-3-2 

Answer 2

Ho appreso un'altra regola empirica (letteralmente) per determinare l'ordine dei vertici noto come "regola della mano destra".
Immagina la tua mano aperta (a destra) all'interno del cubo con il pollice rivolto verso il centro del cubo. Se poi pieghi la mano in un pugno, le tue dita supereranno i vertici nell'ordine corretto. Poiché stai usando la tua mano destra per questo, è chiamata la "regola della mano destra".

Viceversa, se si inizia con la mano sinistra e si punta il pollice lontano dal centro del cubo, le dita eseguiranno nuovamente i vertici nell'ordine corretto. Questa è conosciuta come la "regola della mano sinistra" (sorpresa).

Entrambi i metodi funzionano per fornire un ordine in senso antiorario. Per ordinare in senso orario, basta usare la mano opposta.