X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffg_geometry.c;h=aa2439ee7903a116e4d274c24eee7db3a1817565;hb=6a60b56aaf6dc5d9b0d2dd81b20a568e74232a43;hp=57301a066e7df40c4036180ed7823378a0ccf78d;hpb=bd6ea30351da7505f3ffd923402774c51c1fdb3f;p=freeglut

diff --git a/src/fg_geometry.c b/src/fg_geometry.c
index 57301a0..aa2439e 100644
--- a/src/fg_geometry.c
+++ b/src/fg_geometry.c
@@ -34,20 +34,27 @@
    have a nice code order below */
 #ifndef GL_ES_VERSION_2_0
 static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals,
-    GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
-    GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2
+                                  GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
+                                  GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2
     );
 static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
-    GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart);
+                                   GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart);
 #endif
 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
+                                  GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
+                                  GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2,
+                                  GLint attribute_v_coord, GLint attribute_v_normal
     );
 static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
-    GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart,
-    GLint attribute_v_coord, GLint attribute_v_normal);
+                                   GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart,
+                                   GLint attribute_v_coord, GLint attribute_v_normal);
+/* declare function for generating visualization of normals */
+static void fghGenerateNormalVisualization(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
+                                           GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart);
+#ifndef GL_ES_VERSION_2_0
+static void fghDrawNormalVisualization11();
+#endif
+static void fghDrawNormalVisualization20(GLint attribute_v_coord);
 
 /* Drawing geometry:
  * Explanation of the functions has to be separate for the polyhedra and
@@ -116,8 +123,8 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLsizei
  * Feel free to contribute better naming ;)
  */
 static void fghDrawGeometryWire(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
-    GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
-    GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2
+                                GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
+                                GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2
     )
 {
     GLint attribute_v_coord  = fgStructure.CurrentWindow->Window.attribute_v_coord;
@@ -169,15 +176,32 @@ static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLsizei nu
     GLint attribute_v_coord  = fgStructure.CurrentWindow->Window.attribute_v_coord;
     GLint attribute_v_normal = fgStructure.CurrentWindow->Window.attribute_v_normal;
 
+    if (fgStructure.CurrentWindow->State.VisualizeNormals)
+        /* generate normals for each vertex to be drawn as well */
+        fghGenerateNormalVisualization(vertices, normals, numVertices,
+                                       vertIdxs, numParts, numVertIdxsPerPart);
+
     if (fgState.HasOpenGL20 && (attribute_v_coord != -1 || attribute_v_normal != -1))
+    {
         /* User requested a 2.0 draw */
         fghDrawGeometrySolid20(vertices, normals, numVertices,
                                vertIdxs, numParts, numVertIdxsPerPart,
                                attribute_v_coord, attribute_v_normal);
+
+        if (fgStructure.CurrentWindow->State.VisualizeNormals)
+            /* draw normals for each vertex as well */
+            fghDrawNormalVisualization20(attribute_v_coord);
+    }
 #ifndef GL_ES_VERSION_2_0
     else
+    {
         fghDrawGeometrySolid11(vertices, normals, numVertices,
                                vertIdxs, numParts, numVertIdxsPerPart);
+
+        if (fgStructure.CurrentWindow->State.VisualizeNormals)
+            /* draw normals for each vertex as well */
+            fghDrawNormalVisualization11();
+    }
 #endif
 }
 
@@ -186,8 +210,8 @@ static void fghDrawGeometrySolid(GLfloat *vertices, GLfloat *normals, GLsizei nu
 /* Version for OpenGL (ES) 1.1 */
 #ifndef GL_ES_VERSION_2_0
 static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals,
-    GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
-    GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2
+                                  GLushort *vertIdxs, GLsizei numParts, GLsizei numVertPerPart, GLenum vertexMode,
+                                  GLushort *vertIdxs2, GLsizei numParts2, GLsizei numVertPerPart2
     )
 {
     int i;
@@ -217,7 +241,7 @@ static void fghDrawGeometryWire11(GLfloat *vertices, GLfloat *normals,
 
 
 static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
-    GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart)
+                                   GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart)
 {
     int i;
 
@@ -243,10 +267,9 @@ static void fghDrawGeometrySolid11(GLfloat *vertices, GLfloat *normals, GLsizei
 
 /* Version for OpenGL (ES) >= 2.0 */
 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
-    )
+                                  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,
         ibo_elements = 0, ibo_elements2 = 0;
@@ -447,6 +470,113 @@ static void fghDrawGeometrySolid20(GLfloat *vertices, GLfloat *normals, GLsizei
 
 
 /**
+ * Generate vertex indices for visualizing the normals.
+ */
+static GLfloat *verticesForNormalVisualization;
+static GLushort numNormalVertices = 0;
+static void fghGenerateNormalVisualization(GLfloat *vertices, GLfloat *normals, GLsizei numVertices,
+                                           GLushort *vertIdxs, GLsizei numParts, GLsizei numVertIdxsPerPart)
+{
+    GLushort i,j;
+    /* calc number of vertices to generate, allocate. Must be freed by caller
+     * We do the free at the end of fghDrawNormalVisualization11/fghDrawNormalVisualization20
+     */
+    if (!vertIdxs)
+        numNormalVertices = numVertices * 2;
+    else
+        numNormalVertices = numParts * numVertIdxsPerPart * 2;
+    verticesForNormalVisualization = malloc(numNormalVertices*3 * sizeof(GLfloat));
+
+    /* Now generate vertices for lines to draw the normals */
+    if (!vertIdxs)
+    {
+        for (i=0,j=0; i<numNormalVertices*3/2; i+=3, j+=6)
+        {
+            verticesForNormalVisualization[j+0] = vertices[i+0];
+            verticesForNormalVisualization[j+1] = vertices[i+1];
+            verticesForNormalVisualization[j+2] = vertices[i+2];
+            verticesForNormalVisualization[j+3] = vertices[i+0] + normals[i+0]/4.f;
+            verticesForNormalVisualization[j+4] = vertices[i+1] + normals[i+1]/4.f;
+            verticesForNormalVisualization[j+5] = vertices[i+2] + normals[i+2]/4.f;
+        }
+    }
+    else
+    {
+        for (i=0,j=0; i<numNormalVertices/2; i++, j+=6)
+        {
+            GLushort idx = vertIdxs[i]*3;
+            verticesForNormalVisualization[j+0] = vertices[idx+0];
+            verticesForNormalVisualization[j+1] = vertices[idx+1];
+            verticesForNormalVisualization[j+2] = vertices[idx+2];
+            verticesForNormalVisualization[j+3] = vertices[idx+0] + normals[idx+0]/4.f;
+            verticesForNormalVisualization[j+4] = vertices[idx+1] + normals[idx+1]/4.f;
+            verticesForNormalVisualization[j+5] = vertices[idx+2] + normals[idx+2]/4.f;
+        }
+    }
+}
+
+/* Version for OpenGL (ES) 1.1 */
+#ifndef GL_ES_VERSION_2_0
+static void fghDrawNormalVisualization11()
+{
+    GLfloat currentColor[4];
+    /* Setup draw color: (1,1,1)-shape's color */
+    glGetFloatv(GL_CURRENT_COLOR,currentColor);
+    glColor4f(1-currentColor[0],1-currentColor[1],1-currentColor[2],currentColor[3]);
+
+    glEnableClientState(GL_VERTEX_ARRAY);
+
+    glVertexPointer(3, GL_FLOAT, 0, verticesForNormalVisualization);
+    glDrawArrays(GL_LINES, 0, numNormalVertices);
+
+    glDisableClientState(GL_VERTEX_ARRAY);
+
+    /* Done, free memory, reset color */
+    free(verticesForNormalVisualization);
+    glColor4fv(currentColor);
+}
+#endif
+
+/* Version for OpenGL (ES) >= 2.0 */
+static void fghDrawNormalVisualization20(GLint attribute_v_coord)
+{
+    GLuint vbo_coords = 0;
+
+    if (attribute_v_coord != -1) {
+        fghGenBuffers(1, &vbo_coords);
+        fghBindBuffer(FGH_ARRAY_BUFFER, vbo_coords);
+        fghBufferData(FGH_ARRAY_BUFFER, numNormalVertices * 3 * sizeof(verticesForNormalVisualization[0]),
+            verticesForNormalVisualization, FGH_STATIC_DRAW);
+    }
+
+
+    if (vbo_coords) {
+        fghEnableVertexAttribArray(attribute_v_coord);
+        fghBindBuffer(FGH_ARRAY_BUFFER, vbo_coords);
+        fghVertexAttribPointer(
+            attribute_v_coord,  /* attribute */
+            3,                  /* number of elements per vertex, here (x,y,z) */
+            GL_FLOAT,           /* the type of each element */
+            GL_FALSE,           /* take our values as-is */
+            0,                  /* no extra data between each position */
+            0                   /* offset of first element */
+            );
+        fghBindBuffer(FGH_ARRAY_BUFFER, 0);
+    }
+
+    glDrawArrays(GL_LINES, 0, numNormalVertices);
+
+    if (vbo_coords != 0)
+        fghDisableVertexAttribArray(attribute_v_coord);
+
+    if (vbo_coords != 0)
+        fghDeleteBuffers(1, &vbo_coords);
+
+    /* Done, free memory */
+    free(verticesForNormalVisualization);
+}
+
+/**
  * Generate all combinations of vertices and normals needed to draw object.
  * Optional shape decomposition to triangles:
  * We'll use glDrawElements to draw all shapes that are not naturally
@@ -894,7 +1024,18 @@ DECLARE_SHAPE_CACHE(tetrahedron,Tetrahedron,TETRAHEDRON)
 /* -- Sierpinski Sponge -- */
 static unsigned int ipow (int x, unsigned int y)
 {
-    return y==0? 1: y==1? x: (y%2? x: 1) * ipow(x*x, y/2);
+    /* return y==0? 1: y==1? x: (y%2? x: 1) * ipow(x*x, y/2); */
+    if (y==0)
+        return 1;
+    else
+    {
+        if (y==1)
+            return x;
+        else
+        {
+            return (y%2? x: 1) * ipow(x*x, y/2);
+        }
+    }
 }
 
 static void fghSierpinskiSpongeGenerate ( int numLevels, double offset[3], GLfloat scale, GLfloat* vertices, GLfloat* normals )
@@ -1157,9 +1298,9 @@ void fghGenerateCone(
             (*vertices)[idx  ] = cost[j]*r;
             (*vertices)[idx+1] = sint[j]*r;
             (*vertices)[idx+2] = z;
-            (*normals )[idx  ] = cost[j]*sinn;
-            (*normals )[idx+1] = sint[j]*sinn;
-            (*normals )[idx+2] = cosn;
+            (*normals )[idx  ] = cost[j]*cosn;
+            (*normals )[idx+1] = sint[j]*cosn;
+            (*normals )[idx+2] = sinn;
         }
 
         z += zStep;