* Need more types of polyhedra? See CPolyhedron in MRPT
*/
+/* VC++6 in C mode doesn't have C99's sinf/cos/sqrtf */
+#ifndef HAVE_SINF
+#define sinf(x) (float)sin((double)(x))
+#endif
+#ifndef HAVE_COSF
+#define cosf(x) (float)cos((double)(x))
+#endif
+#ifndef HAVE_SQRTF
+#define sqrtf(x) (float)sqrt((double)(x))
+#endif
/* General functions for drawing geometry
* Solids are drawn by glDrawArrays if composed of triangles, or by
/* Version for OpenGL (ES) 1.1 */
#ifndef GL_ES_VERSION_2_0
-static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals, GLsizei numFaces, GLsizei numEdgePerFace)
+static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals,
+ GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
+ GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2
+ )
{
int i;
glVertexPointer(3, GL_FLOAT, 0, vertices);
glNormalPointer(GL_FLOAT, 0, normals);
- /* Draw per face (TODO: could use glMultiDrawArrays if available) */
- for (i=0; i<numFaces; i++)
- glDrawArrays(GL_LINE_LOOP, i*numEdgePerFace, numEdgePerFace);
+
+ if (!vertIdxs)
+ /* Draw per face (TODO: could use glMultiDrawArrays if available) */
+ for (i=0; i<numParts; i++)
+ glDrawArrays(vertexMode, i*numVertPerPart, numVertPerPart);
+ else
+ for (i=0; i<numParts; i++)
+ glDrawElements(vertexMode,numVertPerPart,GL_UNSIGNED_SHORT,vertIdxs+i*numVertPerPart);
+
+ if (vertIdxs2)
+ for (i=0; i<numParts2; i++)
+ glDrawElements(GL_LINE_LOOP,numVertPerPart2,GL_UNSIGNED_SHORT,vertIdxs2+i*numVertPerPart2);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
#endif
/* Version for OpenGL (ES) >= 2.0 */
-static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei numFaces, GLsizei numEdgePerFace,
- GLint attribute_v_coord, GLint attribute_v_normal)
+static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
+ GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
+ GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2,
+ GLint attribute_v_coord, GLint attribute_v_normal
+ )
{
- GLuint vbo_coords = 0, vbo_normals = 0;
- GLuint numVertices = numFaces * numEdgePerFace;
-
+ GLuint vbo_coords = 0, vbo_normals = 0,
+ ibo_elements = 0, ibo_elements2 = 0;
+ GLsizei numVertIdxs = numParts * numVertPerPart;
+ GLsizei numVertIdxs2 = numParts2 * numVertPerPart2;
int i;
if (numVertices > 0 && attribute_v_coord != -1) {
normals, FGH_STATIC_DRAW);
}
+ if (vertIdxs != NULL) {
+ fghGenBuffers(1, &ibo_elements);
+ fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements);
+ fghBufferData(FGH_ELEMENT_ARRAY_BUFFER, numVertIdxs * sizeof(vertIdxs[0]),
+ vertIdxs, FGH_STATIC_DRAW);
+ fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, 0);
+ }
+
+ if (vertIdxs2 != NULL) {
+ fghGenBuffers(1, &ibo_elements2);
+ fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements2);
+ fghBufferData(FGH_ELEMENT_ARRAY_BUFFER, numVertIdxs2 * sizeof(vertIdxs2[0]),
+ vertIdxs2, FGH_STATIC_DRAW);
+ fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, 0);
+ }
+
if (vbo_coords) {
fghEnableVertexAttribArray(attribute_v_coord);
fghBindBuffer(FGH_ARRAY_BUFFER, vbo_coords);
0, /* no extra data between each position */
0 /* offset of first element */
);
+ fghBindBuffer(FGH_ARRAY_BUFFER, 0);
}
if (vbo_normals) {
0, /* no extra data between each position */
0 /* offset of first element */
);
+ fghBindBuffer(FGH_ARRAY_BUFFER, 0);
}
- /* Draw per face (TODO: could use glMultiDrawArrays if available) */
- for (i=0; i<numFaces; i++)
- glDrawArrays(GL_LINE_LOOP, i*numEdgePerFace, numEdgePerFace);
-
+ if (!vertIdxs) {
+ /* Draw per face (TODO: could use glMultiDrawArrays if available) */
+ for (i=0; i<numParts; i++)
+ glDrawArrays(vertexMode, i*numVertPerPart, numVertPerPart);
+ } else {
+ fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements);
+ for (i=0; i<numParts; i++)
+ glDrawElements(vertexMode, numVertPerPart,
+ GL_UNSIGNED_SHORT, (GLvoid*)(sizeof(vertIdxs[0])*i*numVertPerPart));
+ /* Clean existing bindings before clean-up */
+ /* Android showed instability otherwise */
+ fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, 0);
+ }
+
+ if (vertIdxs2) {
+ fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements2);
+ for (i=0; i<numParts2; i++)
+ glDrawElements(GL_LINE_LOOP, numVertPerPart2,
+ GL_UNSIGNED_SHORT, (GLvoid*)(sizeof(vertIdxs2[0])*i*numVertPerPart2));
+ /* Clean existing bindings before clean-up */
+ /* Android showed instability otherwise */
+ fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, 0);
+ }
if (vbo_coords != 0)
fghDisableVertexAttribArray(attribute_v_coord);
fghDeleteBuffers(1, &vbo_coords);
if (vbo_normals != 0)
fghDeleteBuffers(1, &vbo_normals);
+ if (ibo_elements != 0)
+ fghDeleteBuffers(1, &ibo_elements);
+ if (ibo_elements2 != 0)
+ fghDeleteBuffers(1, &ibo_elements2);
}
-static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei numFaces, GLsizei numEdgePerFace)
+static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
+ GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
+ GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2
+ )
{
GLint attribute_v_coord = fgStructure.CurrentWindow->Window.attribute_v_coord;
GLint attribute_v_normal = fgStructure.CurrentWindow->Window.attribute_v_normal;
if (fgState.HasOpenGL20 && (attribute_v_coord != -1 || attribute_v_normal != -1))
/* User requested a 2.0 draw */
- fghDrawGeometryWire20(vertices, normals, numFaces, numEdgePerFace,
- attribute_v_coord, attribute_v_normal);
+ fghDrawGeometryWire20(vertices, normals, numVertices,
+ vertIdxs, numParts, numVertPerPart, vertexMode,
+ vertIdxs2, numParts2, numVertPerPart2,
+ attribute_v_coord, attribute_v_normal);
#ifndef GL_ES_VERSION_2_0
else
- fghDrawGeometryWire11(vertices, normals, numFaces, numEdgePerFace);
+ fghDrawGeometryWire11(vertices, normals,
+ vertIdxs, numParts, numVertPerPart, vertexMode,
+ vertIdxs2, numParts2, numVertPerPart2);
#endif
}
/* Version for OpenGL (ES) 1.1 */
#ifndef GL_ES_VERSION_2_0
-static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLubyte *vertIdxs,
- GLsizei numVertices, GLsizei numVertIdxs)
+static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLushort *vertIdxs,
+ GLsizei numVertices, GLsizei numParts, GLsizei numVertIdxsPerPart)
{
+ int i;
+
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
if (vertIdxs == NULL)
glDrawArrays(GL_TRIANGLES, 0, numVertices);
else
- glDrawElements(GL_TRIANGLES, numVertIdxs, GL_UNSIGNED_BYTE, vertIdxs);
+ if (numParts>1)
+ for (i=0; i<numParts; i++)
+ glDrawElements(GL_TRIANGLE_STRIP, numVertIdxsPerPart, GL_UNSIGNED_SHORT, vertIdxs+i*numVertIdxsPerPart);
+ else
+ glDrawElements(GL_TRIANGLES, numVertIdxsPerPart, GL_UNSIGNED_SHORT, vertIdxs);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
#endif
/* Version for OpenGL (ES) >= 2.0 */
-static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLubyte *vertIdxs,
- GLsizei numVertices, GLsizei numVertIdxs,
+static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLushort *vertIdxs,
+ GLsizei numVertices, GLsizei numParts, GLsizei numVertIdxsPerPart,
GLint attribute_v_coord, GLint attribute_v_normal)
{
GLuint vbo_coords = 0, vbo_normals = 0, ibo_elements = 0;
-
+ GLsizei numVertIdxs = numParts * numVertIdxsPerPart;
+ int i;
+
if (numVertices > 0 && attribute_v_coord != -1) {
fghGenBuffers(1, &vbo_coords);
fghBindBuffer(FGH_ARRAY_BUFFER, vbo_coords);
fghBufferData(FGH_ARRAY_BUFFER, numVertices * 3 * sizeof(vertices[0]),
vertices, FGH_STATIC_DRAW);
+ fghBindBuffer(FGH_ARRAY_BUFFER, 0);
}
if (numVertices > 0 && attribute_v_normal != -1) {
fghBindBuffer(FGH_ARRAY_BUFFER, vbo_normals);
fghBufferData(FGH_ARRAY_BUFFER, numVertices * 3 * sizeof(normals[0]),
normals, FGH_STATIC_DRAW);
+ fghBindBuffer(FGH_ARRAY_BUFFER, 0);
}
if (vertIdxs != NULL) {
fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements);
fghBufferData(FGH_ELEMENT_ARRAY_BUFFER, numVertIdxs * sizeof(vertIdxs[0]),
vertIdxs, FGH_STATIC_DRAW);
+ fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, 0);
}
if (vbo_coords) {
0, /* no extra data between each position */
0 /* offset of first element */
);
+ fghBindBuffer(FGH_ARRAY_BUFFER, 0);
};
if (vbo_normals) {
0, /* no extra data between each position */
0 /* offset of first element */
);
+ fghBindBuffer(FGH_ARRAY_BUFFER, 0);
};
if (vertIdxs == NULL) {
glDrawArrays(GL_TRIANGLES, 0, numVertices);
} else {
fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements);
- glDrawElements(GL_TRIANGLES, numVertIdxs, GL_UNSIGNED_BYTE, 0);
+ if (numParts>1) {
+ for (i=0; i<numParts; i++) {
+ glDrawElements(GL_TRIANGLE_STRIP, numVertIdxsPerPart, GL_UNSIGNED_SHORT, (GLvoid*)(sizeof(vertIdxs[0])*i*numVertIdxsPerPart));
+ }
+ } else {
+ glDrawElements(GL_TRIANGLES, numVertIdxsPerPart, GL_UNSIGNED_SHORT, 0);
+ }
+ /* Clean existing bindings before clean-up */
+ /* Android showed instability otherwise */
+ fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, 0);
}
-
- /* Clean existing bindings before clean-up */
- /* Android showed instability otherwise */
- fghBindBuffer(FGH_ARRAY_BUFFER, 0);
- fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, 0);
if (vbo_coords != 0)
fghDisableVertexAttribArray(attribute_v_coord);
fghDeleteBuffers(1, &ibo_elements);
}
-static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLubyte *vertIdxs,
- GLsizei numVertices, GLsizei numVertIdxs)
+static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLushort *vertIdxs,
+ GLsizei numVertices, GLsizei numParts, GLsizei numVertIdxsPerPart)
{
GLint attribute_v_coord = fgStructure.CurrentWindow->Window.attribute_v_coord;
GLint attribute_v_normal = fgStructure.CurrentWindow->Window.attribute_v_normal;
if (fgState.HasOpenGL20 && (attribute_v_coord != -1 || attribute_v_normal != -1))
/* User requested a 2.0 draw */
fghDrawGeometrySolid20(vertices, normals, vertIdxs,
- numVertices, numVertIdxs,
+ numVertices, numParts, numVertIdxsPerPart,
attribute_v_coord, attribute_v_normal);
#ifndef GL_ES_VERSION_2_0
else
fghDrawGeometrySolid11(vertices, normals, vertIdxs,
- numVertices, numVertIdxs);
+ numVertices, numParts, numVertIdxsPerPart);
#endif
}
static GLubyte vert4Decomp[6] = {0,1,2, 0,2,3}; /* quad : 4 input vertices, 6 output (2 triangles) */
static GLubyte vert5Decomp[9] = {0,1,2, 0,2,4, 4,2,3}; /* pentagon: 5 input vertices, 9 output (3 triangles) */
-static void fghGenerateGeometryWithIndexArray(int numFaces, int numEdgePerFace, GLfloat *vertices, GLubyte *vertIndices, GLfloat *normals, GLfloat *vertOut, GLfloat *normOut, GLubyte *vertIdxOut)
+static void fghGenerateGeometryWithIndexArray(int numFaces, int numEdgePerFace, GLfloat *vertices, GLubyte *vertIndices, GLfloat *normals, GLfloat *vertOut, GLfloat *normOut, GLushort *vertIdxOut)
{
int i,j,numEdgeIdxPerFace;
GLubyte *vertSamps = NULL;
static GLboolean name##Cached = FALSE;\
static GLfloat name##_verts[nameCaps##_VERT_ELEM_PER_OBJ];\
static GLfloat name##_norms[nameCaps##_VERT_ELEM_PER_OBJ];\
- static GLubyte name##_vertIdxs[nameCaps##_VERT_PER_OBJ_TRI];\
+ static GLushort name##_vertIdxs[nameCaps##_VERT_PER_OBJ_TRI];\
static void fgh##nameICaps##Generate()\
{\
fghGenerateGeometryWithIndexArray(nameCaps##_NUM_FACES, nameCaps##_NUM_EDGE_PER_FACE,\
}
}
-#ifndef GL_ES_VERSION_2_0
/* -- Now the various shapes involving circles -- */
/*
* Compute lookup table of cos and sin values forming a circle
for (i=1; i<size; i++)
{
-#ifdef __cplusplus
(*sint)[i] = sinf(angle*i);
(*cost)[i] = cosf(angle*i);
-#else
- (*sint)[i] = (float)sin((double)(angle*i));
- (*cost)[i] = (float)cos((double)(angle*i));
-#endif /* __cplusplus */
}
const GLfloat rStep = (GLfloat)base / ( ( stacks > 0 ) ? stacks : 1 );
/* Scaling factors for vertex normals */
-#ifdef __cplusplus
const GLfloat cosn = ( (GLfloat)height / sqrtf( height * height + base * base ));
const GLfloat sinn = ( (GLfloat)base / sqrtf( height * height + base * base ));
-#else
- const GLfloat cosn = ( (GLfloat)height / (GLfloat)sqrt( (double)(height * height + base * base) ));
- const GLfloat sinn = ( (GLfloat)base / (GLfloat)sqrt( (double)(height * height + base * base) ));
-#endif /* __cplusplus */
free(sphi);
free(cphi);
}
-#endif
/* -- INTERNAL DRAWING functions --------------------------------------- */
#define _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,vertIdxs)\
\
if (useWireMode)\
{\
- fghDrawGeometryWire (name##_verts,name##_norms,\
- nameCaps##_NUM_FACES,nameCaps##_NUM_EDGE_PER_FACE);\
+ fghDrawGeometryWire (name##_verts,name##_norms,nameCaps##_VERT_PER_OBJ, \
+ NULL,nameCaps##_NUM_FACES,nameCaps##_NUM_EDGE_PER_FACE,GL_LINE_LOOP,\
+ NULL,0,0);\
}\
else\
{\
fghDrawGeometrySolid(name##_verts,name##_norms,vertIdxs,\
- nameCaps##_VERT_PER_OBJ, nameCaps##_VERT_PER_OBJ_TRI); \
+ nameCaps##_VERT_PER_OBJ, 1, nameCaps##_VERT_PER_OBJ_TRI); \
}\
}
#define DECLARE_INTERNAL_DRAW(name,nameICaps,nameCaps) _DECLARE_INTERNAL_DRAW_DO_DECLARE(name,nameICaps,nameCaps,NULL)
vertices = cube_verts;
if (useWireMode)
- fghDrawGeometryWire(vertices, cube_norms,
- CUBE_NUM_FACES, CUBE_NUM_EDGE_PER_FACE);
+ fghDrawGeometryWire(vertices, cube_norms, CUBE_VERT_PER_OBJ,
+ NULL,CUBE_NUM_FACES, CUBE_NUM_EDGE_PER_FACE,GL_LINE_LOOP,
+ NULL,0,0);
else
fghDrawGeometrySolid(vertices, cube_norms, cube_vertIdxs,
- CUBE_VERT_PER_OBJ, CUBE_VERT_PER_OBJ_TRI);
+ CUBE_VERT_PER_OBJ, 1, CUBE_VERT_PER_OBJ_TRI);
if (dSize!=1.f)
/* cleanup allocated memory */
/* Draw and cleanup */
if (useWireMode)
- fghDrawGeometryWire (vertices,normals,numFace,TETRAHEDRON_NUM_EDGE_PER_FACE);
+ fghDrawGeometryWire (vertices,normals,numVert,
+ NULL,numFace,TETRAHEDRON_NUM_EDGE_PER_FACE,GL_LINE_LOOP,
+ NULL,0,0);
else
- fghDrawGeometrySolid(vertices,normals,NULL,numVert,numVert);
+ fghDrawGeometrySolid(vertices,normals,NULL,numVert,1,0);
free(vertices);
free(normals );
}
-#ifndef GL_ES_VERSION_2_0
static void fghSphere( double radius, GLint slices, GLint stacks, GLboolean useWireMode )
{
int i,j,idx, nVert;
}
/* draw */
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_NORMAL_ARRAY);
-
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glNormalPointer(GL_FLOAT, 0, normals);
- /*draw slices*/
- for (i=0; i<slices; i++)
- glDrawElements(GL_LINE_STRIP,stacks+1,GL_UNSIGNED_SHORT,sliceIdx+i*(stacks+1));
- /*draw stacks*/
- for (i=0; i<stacks-1; i++)
- glDrawElements(GL_LINE_LOOP, slices,GL_UNSIGNED_SHORT,stackIdx+i*slices);
-
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
-
+ fghDrawGeometryWire(vertices,normals,nVert,
+ sliceIdx,slices,stacks+1,GL_LINE_STRIP,
+ stackIdx,stacks-1,slices);
+
/* cleanup allocated memory */
free(sliceIdx);
free(stackIdx);
/* draw */
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_NORMAL_ARRAY);
-
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glNormalPointer(GL_FLOAT, 0, normals);
- /*draw stacks*/
- for (i=0; i<stacks; i++)
- glDrawElements(GL_TRIANGLE_STRIP,(slices+1)*2,GL_UNSIGNED_SHORT,stripIdx+i*(slices+1)*2);
-
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
+ fghDrawGeometrySolid(vertices,normals,stripIdx,nVert,stacks,(slices+1)*2);
/* cleanup allocated memory */
free(stripIdx);
}
/* draw */
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_NORMAL_ARRAY);
-
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glNormalPointer(GL_FLOAT, 0, normals);
- /*draw slices*/
- glDrawElements(GL_LINES,slices*2,GL_UNSIGNED_SHORT,sliceIdx);
- /*draw stacks*/
- for (i=0; i<stacks; i++)
- glDrawElements(GL_LINE_LOOP, slices,GL_UNSIGNED_SHORT,stackIdx+i*slices);
-
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
+ fghDrawGeometryWire(vertices,normals,nVert,
+ sliceIdx,1,slices*2,GL_LINES,
+ stackIdx,stacks,slices);
/* cleanup allocated memory */
free(sliceIdx);
}
/* draw */
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_NORMAL_ARRAY);
-
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glNormalPointer(GL_FLOAT, 0, normals);
- /*draw stacks*/
- for (i=0; i<stacks+1; i++)
- glDrawElements(GL_TRIANGLE_STRIP,(slices+1)*2,GL_UNSIGNED_SHORT,stripIdx+i*(slices+1)*2);
-
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
+ fghDrawGeometrySolid(vertices,normals,stripIdx,nVert,stacks+1,(slices+1)*2);
/* cleanup allocated memory */
free(stripIdx);
}
/* draw */
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_NORMAL_ARRAY);
-
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glNormalPointer(GL_FLOAT, 0, normals);
- /*draw slices*/
- glDrawElements(GL_LINES,slices*2,GL_UNSIGNED_SHORT,sliceIdx);
- /*draw stacks*/
- for (i=0; i<stacks+1; i++)
- glDrawElements(GL_LINE_LOOP, slices,GL_UNSIGNED_SHORT,stackIdx+i*slices);
-
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
+ fghDrawGeometryWire(vertices,normals,nVert,
+ sliceIdx,1,slices*2,GL_LINES,
+ stackIdx,stacks+1,slices);
/* cleanup allocated memory */
free(sliceIdx);
stripIdx[idx+1] = nVert-1; /* repeat first slice's idx for closing off shape */
/* draw */
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_NORMAL_ARRAY);
-
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glNormalPointer(GL_FLOAT, 0, normals);
- /*draw stacks*/
- for (i=0; i<stacks+2; i++)
- glDrawElements(GL_TRIANGLE_STRIP,(slices+1)*2,GL_UNSIGNED_SHORT,stripIdx+i*(slices+1)*2);
-
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
+ fghDrawGeometrySolid(vertices,normals,stripIdx,nVert,stacks+2,(slices+1)*2);
/* cleanup allocated memory */
free(stripIdx);
sideIdx[idx] = j * nSides + i;
/* draw */
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_NORMAL_ARRAY);
-
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glNormalPointer(GL_FLOAT, 0, normals);
- /*draw rings*/
- for( i=0; i<nSides; i++ )
- glDrawElements(GL_LINE_LOOP,nRings,GL_UNSIGNED_SHORT,ringIdx+i*nRings);
- /*draw sides*/
- for (i=0; i<nRings; i++)
- glDrawElements(GL_LINE_LOOP,nSides,GL_UNSIGNED_SHORT,sideIdx+i*nSides);
-
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
-
+ fghDrawGeometryWire(vertices,normals,nVert,
+ ringIdx,nRings,nSides,GL_LINE_LOOP,
+ sideIdx,nSides,nRings);
+
/* cleanup allocated memory */
free(sideIdx);
free(ringIdx);
}
/* draw */
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_NORMAL_ARRAY);
-
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glNormalPointer(GL_FLOAT, 0, normals);
- for (i=0; i<nSides; i++)
- glDrawElements(GL_TRIANGLE_STRIP,(nRings+1)*2,GL_UNSIGNED_SHORT,stripIdx+i*(nRings+1)*2);
-
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
+ fghDrawGeometrySolid(vertices,normals,stripIdx,nVert,nSides,(nRings+1)*2);
/* cleanup allocated memory */
free(stripIdx);
fghSphere( radius, slices, stacks, TRUE );
}
-#endif /* GL_ES_VERSION_2_0 */
-#ifndef EGL_VERSION_1_0
/*
* Draws a solid cone
*/
fghTorus(dInnerRadius, dOuterRadius, nSides, nRings, FALSE);
}
-#endif /* EGL_VERSION_1_0 */
projects / freeglut / blobdiff