X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffg_geometry.c;h=0ab14ac040f987b4fd97eb333ed9fa7116c57577;hb=18530d133238f83763d65e8384111eafe21fd382;hp=3c1ecb91a5845a46838610024ce92cc454f2b374;hpb=1feb202b2d028db371116442bae561580d245f52;p=freeglut

diff --git a/src/fg_geometry.c b/src/fg_geometry.c
index 3c1ecb9..0ab14ac 100644
--- a/src/fg_geometry.c
+++ b/src/fg_geometry.c
@@ -55,6 +55,8 @@
  * from face to face.
  */
 
+/** See comment for fghDrawGeometryWire **/
+
 /* Version for OpenGL (ES) 1.1 */
 #ifndef GL_ES_VERSION_2_0
 static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals,
@@ -89,15 +91,16 @@ static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals,
 #endif
 
 /* Version for OpenGL (ES) >= 2.0 */
-static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals,
+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 = numParts * numVertPerPart;
-
+    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) {
@@ -114,6 +117,22 @@ static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals,
                       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);
@@ -125,6 +144,7 @@ static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals,
             0,                  /* no extra data between each position */
             0                   /* offset of first element */
         );
+        fghBindBuffer(FGH_ARRAY_BUFFER, 0);
     }
 
     if (vbo_normals) {
@@ -138,12 +158,32 @@ static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *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<numParts; i++)
-        glDrawArrays(vertexMode, i*numVertPerPart, numVertPerPart);
-    
+    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);
@@ -154,9 +194,27 @@ static void fghDrawGeometryWire20(GLfloat *vertices, GLfloat *normals,
         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,
+/**
+ * Draw geometric shape in wire mode (only edges)
+ *
+ * Arguments: the sphere, in wire mode, consists of multiple line
+ * loops for the stacks, and for the slices. The vertex indices for
+ * all slices are thrown together. numParts is how many separate loops
+ * are in the array, numVertIdxsPerPart is how many vertices there are
+ * per loop.  For those suffixed with 2, its exactly the same
+ * principle, the number of stacks and slices is not the same.
+ *
+ * Feel free to contribute better naming ;)
+ *
+ * See comment for fghDrawGeometrySolid
+ */
+static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
     GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
     GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2
     )
@@ -166,7 +224,7 @@ static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals,
 
     if (fgState.HasOpenGL20 && (attribute_v_coord != -1 || attribute_v_normal != -1))
         /* User requested a 2.0 draw */
-        fghDrawGeometryWire20(vertices, normals,
+        fghDrawGeometryWire20(vertices, normals, numVertices,
                               vertIdxs, numParts, numVertPerPart, vertexMode,
                               vertIdxs2, numParts2, numVertPerPart2,
                               attribute_v_coord, attribute_v_normal);
@@ -179,15 +237,6 @@ static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals,
 }
 
 
-/* Draw the geometric shape with filled triangles
- *
- * - If the shape is naturally triangulated (numEdgePerFace==3), each
- *   vertex+normal pair is used only once, so no vertex indices.
- * 
- * - If the shape was triangulated (DECOMPOSE_TO_TRIANGLE), some
- *   vertex+normal pairs are reused, so use vertex indices.
- */
-
 /* Version for OpenGL (ES) 1.1 */
 #ifndef GL_ES_VERSION_2_0
 static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLushort *vertIdxs,
@@ -220,12 +269,15 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLushort
                                    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) {
@@ -233,13 +285,15 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLushort
         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) {
         fghGenBuffers(1, &ibo_elements);
         fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, ibo_elements);
-        fghBufferData(FGH_ELEMENT_ARRAY_BUFFER, numVertIdxsPerPart * sizeof(vertIdxs[0]),
+        fghBufferData(FGH_ELEMENT_ARRAY_BUFFER, numVertIdxs * sizeof(vertIdxs[0]),
                       vertIdxs, FGH_STATIC_DRAW);
+        fghBindBuffer(FGH_ELEMENT_ARRAY_BUFFER, 0);
     }
     
     if (vbo_coords) {
@@ -253,6 +307,7 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLushort
             0,                  /* no extra data between each position */
             0                   /* offset of first element */
         );
+        fghBindBuffer(FGH_ARRAY_BUFFER, 0);
     };
     
     if (vbo_normals) {
@@ -266,19 +321,24 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLushort
             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, numVertIdxsPerPart, GL_UNSIGNED_SHORT, 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);
@@ -293,6 +353,14 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLushort
         fghDeleteBuffers(1, &ibo_elements);
 }
 
+/* Draw the geometric shape with filled triangles
+ *
+ * - If the shape is naturally triangulated (numEdgePerFace==3), each
+ *   vertex+normal pair is used only once, so no vertex indices.
+ * 
+ * - If the shape was triangulated (DECOMPOSE_TO_TRIANGLE), some
+ *   vertex+normal pairs are reused, so use vertex indices.
+ */
 static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLushort *vertIdxs,
                                  GLsizei numVertices, GLsizei numParts, GLsizei numVertIdxsPerPart)
 {
@@ -311,6 +379,8 @@ static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLushort *
 #endif
 }
 
+
+
 /* Shape decomposition to triangles
  * We'll use glDrawElements to draw all shapes that are not naturally
  * composed of triangles, so generate an index vector here, using the
@@ -1199,7 +1269,7 @@ void fghGenerateTorus(
         \
         if (useWireMode)\
         {\
-            fghDrawGeometryWire (name##_verts,name##_norms,\
+            fghDrawGeometryWire (name##_verts,name##_norms,nameCaps##_VERT_PER_OBJ, \
                                  NULL,nameCaps##_NUM_FACES,nameCaps##_NUM_EDGE_PER_FACE,GL_LINE_LOOP,\
                                  NULL,0,0);\
         }\
@@ -1243,7 +1313,7 @@ static void fghCube( GLfloat dSize, GLboolean useWireMode )
         vertices = cube_verts;
 
     if (useWireMode)
-        fghDrawGeometryWire(vertices, cube_norms,
+        fghDrawGeometryWire(vertices, cube_norms, CUBE_VERT_PER_OBJ,
                             NULL,CUBE_NUM_FACES, CUBE_NUM_EDGE_PER_FACE,GL_LINE_LOOP,
                             NULL,0,0);
     else
@@ -1287,7 +1357,7 @@ static void fghSierpinskiSponge ( int numLevels, double offset[3], GLfloat scale
 
         /* Draw and cleanup */
         if (useWireMode)
-            fghDrawGeometryWire (vertices,normals,
+            fghDrawGeometryWire (vertices,normals,numVert,
                                  NULL,numFace,TETRAHEDRON_NUM_EDGE_PER_FACE,GL_LINE_LOOP,
                                  NULL,0,0);
         else
@@ -1351,7 +1421,7 @@ static void fghSphere( double radius, GLint slices, GLint stacks, GLboolean useW
         }
 
         /* draw */
-        fghDrawGeometryWire(vertices,normals,
+        fghDrawGeometryWire(vertices,normals,nVert,
             sliceIdx,slices,stacks+1,GL_LINE_STRIP,
             stackIdx,stacks-1,slices);
         
@@ -1473,7 +1543,7 @@ static void fghCone( double base, double height, GLint slices, GLint stacks, GLb
         }
 
         /* draw */
-        fghDrawGeometryWire(vertices,normals,
+        fghDrawGeometryWire(vertices,normals,nVert,
             sliceIdx,1,slices*2,GL_LINES,
             stackIdx,stacks,slices);
 
@@ -1584,7 +1654,7 @@ static void fghCylinder( double radius, double height, GLint slices, GLint stack
         }
 
         /* draw */
-        fghDrawGeometryWire(vertices,normals,
+        fghDrawGeometryWire(vertices,normals,nVert,
             sliceIdx,1,slices*2,GL_LINES,
             stackIdx,stacks+1,slices);
 
@@ -1696,7 +1766,7 @@ static void fghTorus( double dInnerRadius, double dOuterRadius, GLint nSides, GL
                 sideIdx[idx] = j * nSides + i;
 
         /* draw */
-        fghDrawGeometryWire(vertices,normals,
+        fghDrawGeometryWire(vertices,normals,nVert,
             ringIdx,nRings,nSides,GL_LINE_LOOP,
             sideIdx,nSides,nRings);