Dibujando un globo con OpenGL ES

Estoy tratando de representar un globo (esfera con maps) con OpenGL ES 1.1 en iOS.

Soy capaz de dibujar la esfera y mapear los bordes pero con un problema: las líneas que no están de frente en mi vista también se dibujan en la pantalla . Me gusta esto:

Globo con líneas en la parte posterior que se muestra

En la image, puedes ver que Estados Unidos está bien, pero puedes ver Australia en la parte posterior. No se supone que se muestre porque está en la parte posterior del globo, y las rayas NEGRAS y PÚRPURAS en el globo no son transparentes.

¿Alguna idea sobre qué parameters debo ajustar para get un globo apropiado?

Si ayuda, puedo publicar las partes relevantes del código . Solo pregunta qué parte y actualizaré la pregunta.

Muchas gracias por adelantado.

Actualización: Esto es lo que estoy usando para la representación de Sphere:

glEnableClientState(GL_VERTEX_ARRAY); glPolygonOffset(-1.0f, -1.0f); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); int x, y; GLfloat curR, curG, curB; curR = curG = curB = 0.15f; for (y=0; y<EARTH_LAT_RES; y++) { if (y%10 == 0) { glColor4f(curR, curG, curB, 1.0f); curR = curR == 0.15f ? 0.6f : 0.15f; curB = curB == 0.15f ? 0.6f : 0.15f; } for (x=0; x<EARTH_LON_RES; x++) { Vertex3D vs[4]; vs[1] = vertices[x][y]; vs[0] = vertices[x][y+1]; vs[3] = vertices[x+1][y]; vs[2] = vertices[x+1][y+1]; glVertexPointer(3, GL_FLOAT, 0, vs); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); } } glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glDisable(GL_POLYGON_OFFSET_FILL); glDisableClientState(GL_VERTEX_ARRAY); 

Esto es lo que estoy usando para representar las líneas de borde:

 // vxp is a data structure with vertex arrays that represent // border lines int i; glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnableClientState(GL_VERTEX_ARRAY); for (i=0; i<vxp->nFeatures; i++) { glVertexPointer(3, GL_FLOAT, 0, vxp->pFeatures[i].pVerts); glDrawArrays(GL_LINE_STRIP, 0, vxp->pFeatures[i].nVerts); } glDisableClientState(GL_VERTEX_ARRAY); glDisable(GL_BLEND); 

Estas son las configuraciones que estoy usando antes de representar cualquiera de los objects:

 glMatrixMode(GL_PROJECTION); glLoadIdentity(); glEnable(GL_DEPTH_TEST); /* enable depth testing; requinetworking for z-buffer */ glEnable(GL_CULL_FACE); /* enable polygon face culling */ glCullFace(GL_BACK); glOrthof(-1.0f, 1.0f, -1.5f, 1.5f, -1.0f, 1.0f); glFrustumf (-1.0, 1.0, -1.5, 1.5, -1.0, 1.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); 

La forma más obvia, si no obstruye el rest de su código, es dibujar la esfera como un object sólido de una forma invisible para cebar el búfer de profundidad, luego deje que la testing de profundidad determine cuál de las líneas es visible. Puede usar glPolygonOffset para agregar una 'pequeña cantidad' específica de la implementación a los valores que se utilizan para los cálculos de profundidad, de modo que puede evitar la lucha en el buffer de profundidad. Entonces sería algo así:

 // add a small bit of offset, so that lines that should be visible aren't // clipped due to depth rounding errors; note that ES allows GL_POLYGON_OFFSET_FILL // but not GL_POLYGON_OFFSET_LINE, so we're going to push the polygons back a bit // in terms of values written to the depth buffer, rather than the more normal // approach of pulling the lines forward a bit glPolygonOffset(-1.0, -1.0); glEnable(GL_POLYGON_OFFSET_FILL); // disable writes to the colour buffer glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); drawSolidPolygonalSphere(); // enable writing again glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); // disable the offset glDisable(GL_POLYGON_OFFSET_FILL); drawVectorMap(); 

Entonces, eso dejará valores en el búfer de profundidad como si el globo fuera sólido. Si eso no es aceptable, entonces la única alternativa en la que puedo pensar es hacer cálculos de visibilidad en la CPU. Puede usar glGet para get la matriz de vista actual, determinar la normal en cada vértice directamente desde la forma en que los asigna a la esfera (solo será su location relativa al centro), luego dibujar cualquier línea para la cual al less una vértice devuelve un valor negativo para el producto de punto del vector desde la camera hasta el punto y lo normal.