Changeset 3079 for trunk/src

Timestamp:

Mar 11, 2000, 10:05:07 AM (26 years ago)

Author:

jeroen

Message:

* empty log message *

Location:

trunk/src/opengl

Files:

• glu/nurbs/interface/glcurveval.cpp (modified) (9 diffs)
• glu/nurbs/interface/glcurveval.h (modified) (5 diffs)
• glu/nurbs/interface/glinterface.cpp (modified) (12 diffs)
• glu/nurbs/interface/glrenderer.h (modified) (5 diffs)
• glu/nurbs/interface/glsurfeval.cpp (modified) (5 diffs)
• glu/nurbs/interface/glsurfeval.h (modified) (14 diffs)
• glu/nurbs/interface/insurfeval.cpp (modified) (21 diffs)
• glu/nurbs/internals/slicer.cpp (modified) (42 diffs)
• glu/tess/tess.c (modified) (28 diffs)
• glu/tess/tess.h (modified) (4 diffs)
• glu/util/quad.c (modified) (24 diffs)
• glut/glut_event.c (modified) (6 diffs)
• glut/glut_term.c (modified) (2 diffs)
• glut/glut_win.c (modified) (4 diffs)
• glut/glutint.h (modified) (4 diffs)
• glut/win32_menu.c (modified) (2 diffs)
• mesa/GL/glu.h (modified) (9 diffs)
• mesa/api1.c (modified) (42 diffs)

trunk/src/opengl/glu/nurbs/interface/glcurveval.cpp

@@ -1 @@
-/* $Id: glcurveval.cpp,v 1.1 2000-02-09 08:49:00 jeroen Exp $ */
+/* $Id: glcurveval.cpp,v 1.2 2000-03-11 09:05:01 jeroen Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
@@ -37 +37 @@
  * glcurveval.c++
  *
- * $Date: 2000-02-09 08:49:00 $ $Revision: 1.1 $
- * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/glcurveval.cpp,v 1.1 2000-02-09 08:49:00 jeroen Exp $
+ * $Date: 2000-03-11 09:05:01 $ $Revision: 1.2 $
+ * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/glcurveval.cpp,v 1.2 2000-03-11 09:05:01 jeroen Exp $
  */
 
@@ -88 +88 @@
 OpenGLCurveEvaluator::addMap(CurveMap *m)
 {
-        m = m;
+        m = m;
 }
 
@@ -94 +94 @@
 OpenGLCurveEvaluator::range1f(long type, REAL *from, REAL *to)
 {
-        type = type;
-        from = from;
-        to = to;
+        type = type;
+        from = from;
+        to = to;
 }
 
@@ -102 +102 @@
 OpenGLCurveEvaluator::domain1f(REAL ulo, REAL uhi)
 {
-        ulo = ulo;
-        uhi = uhi;
+        ulo = ulo;
+        uhi = uhi;
 }
 
@@ -202 +202 @@
 void
 OpenGLCurveEvaluator::map1f(
-    long type,                  /* map type */
-    REAL ulo,                   /* lower parametric bound */
-    REAL uhi,                   /* upper parametric bound */
-    long stride,                /* distance to next point in REALS */
-    long order,                 /* parametric order */
-    REAL *pts                   /* control points */
+    long type,                  /* map type */
+    REAL ulo,                   /* lower parametric bound */
+    REAL uhi,                   /* upper parametric bound */
+    long stride,                /* distance to next point in REALS */
+    long order,                 /* parametric order */
+    REAL *pts                   /* control points */
 )
 {
@@ -216 +216 @@
       switch(type){
       case GL_MAP1_VERTEX_3:
-        which = 0;
-        dimension = 3;
-        break;
+        which = 0;
+        dimension = 3;
+        break;
       case GL_MAP1_VERTEX_4:
-        which=0;
-        dimension = 4;
-        break;
+        which=0;
+        dimension = 4;
+        break;
       case GL_MAP1_INDEX:
-        which=2;
-        dimension = 1;
-        break;
+        which=2;
+        dimension = 1;
+        break;
       case GL_MAP1_COLOR_4:
-        which=2;
-        dimension = 4;
-        break;
+        which=2;
+        dimension = 4;
+        break;
       case GL_MAP1_NORMAL:
-        which=1;
-        dimension = 3;
-        break;
+        which=1;
+        dimension = 3;
+        break;
       case GL_MAP1_TEXTURE_COORD_1:
-        which=3;
-        dimension = 1;
-        break;
+        which=3;
+        dimension = 1;
+        break;
       case GL_MAP1_TEXTURE_COORD_2:
-        which=3;
-        dimension = 2;
-        break;
-        
+        which=3;
+        dimension = 2;
+        break;
+
       case GL_MAP1_TEXTURE_COORD_3:
-        which=3;
-        dimension = 3;
-        break;
+        which=3;
+        dimension = 3;
+        break;
       case GL_MAP1_TEXTURE_COORD_4:
-        which=3;
-        dimension = 4;
-        break;  
+        which=3;
+        dimension = 4;
+        break;
       }
-      inMap1f(which, dimension, ulo, uhi, stride, order, pts);  
+      inMap1f(which, dimension, ulo, uhi, stride, order, pts);
     }
   else
     glMap1f((GLenum) type, (GLfloat) ulo, (GLfloat) uhi, (GLint) stride,
-            (GLint) order, (const GLfloat *) pts);
+            (GLint) order, (const GLfloat *) pts);
 }
 
@@ -276 +276 @@
       case N_MESHFILL:
       case N_MESHLINE:
-        glEvalMesh1((GLenum) GL_LINE, (GLint) from, (GLint) to);
-        break;
+        glEvalMesh1((GLenum) GL_LINE, (GLint) from, (GLint) to);
+        break;
       case N_MESHPOINT:
-        glEvalMesh1((GLenum) GL_POINT, (GLint) from, (GLint) to);
-        break;
+        glEvalMesh1((GLenum) GL_POINT, (GLint) from, (GLint) to);
+        break;
       }
     }
@@ -304 +304 @@
 
 void
-OpenGLCurveEvaluator::putCallBack(GLenum which, GLvoid (GLAPI *fn)(...))
+OpenGLCurveEvaluator::putCallBack(GLenum which, GLvoid (GLCALLBACK *fn)(...))
 {
   switch(which)
   {
     case GLU_NURBS_BEGIN:
-      beginCallBackN = (void (GLAPI *) (GLenum)) fn;
+      beginCallBackN = (void (GLCALLBACK *) (GLenum)) fn;
       break;
     case GLU_NURBS_END:
-      endCallBackN = (void (GLAPI *) (void)) fn;
+      endCallBackN = (void (GLCALLBACK *) (void)) fn;
       break;
     case GLU_NURBS_VERTEX:
-      vertexCallBackN = (void (GLAPI *) (const GLfloat*)) fn;
+      vertexCallBackN = (void (GLCALLBACK *) (const GLfloat*)) fn;
       break;
     case GLU_NURBS_NORMAL:
-      normalCallBackN = (void (GLAPI *) (const GLfloat*)) fn;
+      normalCallBackN = (void (GLCALLBACK *) (const GLfloat*)) fn;
       break;
     case GLU_NURBS_COLOR:
-      colorCallBackN = (void (GLAPI *) (const GLfloat*)) fn;
+      colorCallBackN = (void (GLCALLBACK *) (const GLfloat*)) fn;
       break;
     case GLU_NURBS_TEXTURE_COORD:
-      texcoordCallBackN = (void (GLAPI *) (const GLfloat*)) fn;
+      texcoordCallBackN = (void (GLCALLBACK *) (const GLfloat*)) fn;
       break;
     case GLU_NURBS_BEGIN_DATA:
-      beginCallBackData = (void (GLAPI *) (GLenum, void*)) fn;
+      beginCallBackData = (void (GLCALLBACK *) (GLenum, void*)) fn;
       break;
     case GLU_NURBS_END_DATA:
-      endCallBackData = (void (GLAPI *) (void*)) fn;
+      endCallBackData = (void (GLCALLBACK *) (void*)) fn;
       break;
     case GLU_NURBS_VERTEX_DATA:
-      vertexCallBackData = (void (GLAPI *) (const GLfloat*, void*)) fn;
+      vertexCallBackData = (void (GLCALLBACK *) (const GLfloat*, void*)) fn;
       break;
     case GLU_NURBS_NORMAL_DATA:
-      normalCallBackData = (void (GLAPI *) (const GLfloat*, void*)) fn;
+      normalCallBackData = (void (GLCALLBACK *) (const GLfloat*, void*)) fn;
       break;
     case GLU_NURBS_COLOR_DATA:
-      colorCallBackData = (void (GLAPI *) (const GLfloat*, void*)) fn;
+      colorCallBackData = (void (GLCALLBACK *) (const GLfloat*, void*)) fn;
       break;
     case GLU_NURBS_TEXTURE_COORD_DATA:
-      texcoordCallBackData = (void (GLAPI *) (const GLfloat*, void*)) fn;
+      texcoordCallBackData = (void (GLCALLBACK *) (const GLfloat*, void*)) fn;
       break;
   }

trunk/src/opengl/glu/nurbs/interface/glcurveval.h

@@ -1 @@
-/* $Id: glcurveval.h,v 1.1 2000-02-09 08:49:01 jeroen Exp $ */
+/* $Id: glcurveval.h,v 1.2 2000-03-11 09:05:02 jeroen Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
@@ -37 +37 @@
  * glcurveval.h
  *
- * $Date: 2000-02-09 08:49:01 $ $Revision: 1.1 $
- * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/glcurveval.h,v 1.1 2000-02-09 08:49:01 jeroen Exp $
+ * $Date: 2000-03-11 09:05:02 $ $Revision: 1.2 $
+ * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/glcurveval.h,v 1.2 2000-03-11 09:05:02 jeroen Exp $
  */
 
@@ -72 +72 @@
 class OpenGLCurveEvaluator : public BasicCurveEvaluator  {
 public:
-                        OpenGLCurveEvaluator(void);
-                        ~OpenGLCurveEvaluator(void);
-    void                range1f(long, REAL *, REAL *);
-    void                domain1f(REAL, REAL);
-    void                addMap(CurveMap *);
+                        OpenGLCurveEvaluator(void);
+                        ~OpenGLCurveEvaluator(void);
+    void                range1f(long, REAL *, REAL *);
+    void                domain1f(REAL, REAL);
+    void                addMap(CurveMap *);
 
-    void                enable(long);
-    void                disable(long);
-    void                bgnmap1f(long);
-    void                map1f(long, REAL, REAL, long, long, REAL *);
-    void                mapgrid1f(long, REAL, REAL);
-    void                mapmesh1f(long, long, long);
-    void                evalpoint1i(long);
-    void                evalcoord1f(long, REAL);
-    void                endmap1f(void);
+    void                enable(long);
+    void                disable(long);
+    void                bgnmap1f(long);
+    void                map1f(long, REAL, REAL, long, long, REAL *);
+    void                mapgrid1f(long, REAL, REAL);
+    void                mapmesh1f(long, long, long);
+    void                evalpoint1i(long);
+    void                evalcoord1f(long, REAL);
+    void                endmap1f(void);
 
-    void                bgnline(void);
-    void                endline(void);
+    void                bgnline(void);
+    void                endline(void);
 
     void                put_vertices_call_back(int flag)
       {
-        output_triangles = flag;
+        output_triangles = flag;
       }
-    void               putCallBack(GLenum which, GLvoid (GLAPI *fn)(...));
+    void               putCallBack(GLenum which, GLvoid (GLCALLBACK *fn)(...));
     void               set_callback_userData(void *data)
       {
-        userData = data;
+        userData = data;
       }
 
@@ -116 +116 @@
 
 void inMap1f(int which, //0: vert, 1: norm, 2: color, 3: tex
-             int dimension,
-             REAL ulower,
-             REAL uupper,
-             int ustride,
-             int uorder,
-             REAL *ctlpoints);
+             int dimension,
+             REAL ulower,
+             REAL uupper,
+             int ustride,
+             int uorder,
+             REAL *ctlpoints);
 
 void inPreEvaluate(int order, REAL vprime, REAL *coeff);
@@ -128 +128 @@
 void inMapMesh1f(int umin, int umax);
 
-void     (GLAPI *beginCallBackN) (GLenum type);
-void     (GLAPI *endCallBackN)   (void);
-void     (GLAPI *vertexCallBackN) (const GLfloat *vert);
-void     (GLAPI *normalCallBackN) (const GLfloat *normal);
-void     (GLAPI *colorCallBackN) (const GLfloat *color);
-void     (GLAPI *texcoordCallBackN) (const GLfloat *texcoord);
+void     (GLCALLBACK *beginCallBackN) (GLenum type);
+void     (GLCALLBACK *endCallBackN)   (void);
+void     (GLCALLBACK *vertexCallBackN) (const GLfloat *vert);
+void     (GLCALLBACK *normalCallBackN) (const GLfloat *normal);
+void     (GLCALLBACK *colorCallBackN) (const GLfloat *color);
+void     (GLCALLBACK *texcoordCallBackN) (const GLfloat *texcoord);
 
-void     (GLAPI *beginCallBackData) (GLenum type, void* data);
-void     (GLAPI *endCallBackData)   (void* data);
-void     (GLAPI *vertexCallBackData) (const GLfloat *vert, void* data);
-void     (GLAPI *normalCallBackData) (const GLfloat *normal, void* data);
-void     (GLAPI *colorCallBackData) (const GLfloat *color, void* data);
-void     (GLAPI *texcoordCallBackData) (const GLfloat *texcoord, void* data);
+void     (GLCALLBACK *beginCallBackData) (GLenum type, void* data);
+void     (GLCALLBACK *endCallBackData)   (void* data);
+void     (GLCALLBACK *vertexCallBackData) (const GLfloat *vert, void* data);
+void     (GLCALLBACK *normalCallBackData) (const GLfloat *normal, void* data);
+void     (GLCALLBACK *colorCallBackData) (const GLfloat *color, void* data);
+void     (GLCALLBACK *texcoordCallBackData) (const GLfloat *texcoord, void* data);
 
-void* userData; //the opaque pointer for Data callback functions
-void  beginCallBack(GLenum type, void* data);
+void* userData;           /* the opaque pointer for Data callback functions*/
+void beginCallBack(GLenum type, void* data);
 void endCallBack(void* data);
 void vertexCallBack(const GLfloat *vert, void *data);

trunk/src/opengl/glu/nurbs/interface/glinterface.cpp

@@ -1 @@
-/* $Id: glinterface.cpp,v 1.2 2000-02-29 13:56:48 sandervl Exp $ */
+/* $Id: glinterface.cpp,v 1.3 2000-03-11 09:05:02 jeroen Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
@@ -33 +33 @@
 ** compliant with the OpenGL(R) version 1.2.1 Specification.
 **
-** $Date: 2000-02-29 13:56:48 $ $Revision: 1.2 $
+** $Date: 2000-03-11 09:05:02 $ $Revision: 1.3 $
 */
 /*
-** $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/glinterface.cpp,v 1.2 2000-02-29 13:56:48 sandervl Exp $
+** $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/glinterface.cpp,v 1.3 2000-03-11 09:05:02 jeroen Exp $
 */
 
@@ -63 +63 @@
 void glu_LOD_eval_list(GLUnurbs *nurb, int level)
 {
-        nurb->LOD_eval_list(level);
+        nurb->LOD_eval_list(level);
 }
 
@@ -152 +152 @@
 void GLAPI
 gluPwlCurve(GLUnurbs *r, GLint count, INREAL array[],
-                GLint stride, GLenum type)
+                GLint stride, GLenum type)
 {
 #ifdef DOWN_LOAD_NURBS
@@ -161 +161 @@
     switch(type) {
       case GLU_MAP1_TRIM_2:
-        realType = N_P2D;
-        break;
+        realType = N_P2D;
+        break;
       case GLU_MAP1_TRIM_3:
-        realType = N_P2DR;
-        break;
+        realType = N_P2DR;
+        break;
       default:
-        realType = type;
-        break;
+        realType = type;
+        break;
     }
     r->pwlcurve(count, array, sizeof(INREAL) * stride, realType);
@@ -175 +175 @@
 void GLAPI
 gluNurbsCurve(GLUnurbs *r, GLint nknots, INREAL knot[], GLint stride,
-                  INREAL ctlarray[], GLint order, GLenum type)
+                  INREAL ctlarray[], GLint order, GLenum type)
 {
 #ifdef DOWN_LOAD_NURBS
@@ -185 +185 @@
     switch(type) {
       case GLU_MAP1_TRIM_2:
-        realType = N_P2D;
-        break;
+        realType = N_P2D;
+        break;
       case GLU_MAP1_TRIM_3:
-        realType = N_P2DR;
-        break;
+        realType = N_P2DR;
+        break;
       default:
-        realType = type;
-        break;
+        realType = type;
+        break;
     }
 
     r->nurbscurve(nknots, knot, sizeof(INREAL) * stride, ctlarray, order,
-            realType);
+            realType);
 }
 
 void GLAPI
 gluNurbsSurface(GLUnurbs *r, GLint sknot_count, GLfloat *sknot,
-                            GLint tknot_count, GLfloat *tknot,
-                            GLint s_stride, GLint t_stride,
-                            GLfloat *ctlarray, GLint sorder, GLint torder,
-                            GLenum type)
+                            GLint tknot_count, GLfloat *tknot,
+                            GLint s_stride, GLint t_stride,
+                            GLfloat *ctlarray, GLint sorder, GLint torder,
+                            GLenum type)
 {
 #ifdef DOWN_LOAD_NURBS
@@ -221 +221 @@
     }
 tempNurb = nurbSurfMake(sknot_count, sknot,
-                        tknot_count, tknot,
-                        sorder, torder,
-                        dimension,
-                        ctlarray,
-                        s_stride, t_stride);
-                        
+                        tknot_count, tknot,
+                        sorder, torder,
+                        dimension,
+                        ctlarray,
+                        s_stride, t_stride);
+
   }
 #endif
 
     r->nurbssurface(sknot_count, sknot, tknot_count, tknot,
-            sizeof(INREAL) * s_stride, sizeof(INREAL) * t_stride,
-            ctlarray, sorder, torder, type);
+            sizeof(INREAL) * s_stride, sizeof(INREAL) * t_stride,
+            ctlarray, sorder, torder, type);
 }
 
 void GLAPI
 gluLoadSamplingMatrices(GLUnurbs *r, const GLfloat modelMatrix[16],
-                            const GLfloat projMatrix[16],
-                            const GLint viewport[4])
+                            const GLfloat projMatrix[16],
+                            const GLint viewport[4])
 {
     r->useGLMatrices(modelMatrix, projMatrix, viewport);
@@ -251 +251 @@
       case GLU_AUTO_LOAD_MATRIX:
         r->setautoloadmode(value);
-        return;
+        return;
 
       case GLU_CULLING:
-        if (value != 0.0) {
-            nurbsValue = N_CULLINGON;
-        } else {
-            nurbsValue = N_NOCULLING;
-        }
-        r->setnurbsproperty(GL_MAP2_VERTEX_3, N_CULLING, nurbsValue);
-        r->setnurbsproperty(GL_MAP2_VERTEX_4, N_CULLING, nurbsValue);
-        r->setnurbsproperty(GL_MAP1_VERTEX_3, N_CULLING, nurbsValue);
-        r->setnurbsproperty(GL_MAP1_VERTEX_4, N_CULLING, nurbsValue);
+        if (value != 0.0) {
+            nurbsValue = N_CULLINGON;
+        } else {
+            nurbsValue = N_NOCULLING;
+        }
+        r->setnurbsproperty(GL_MAP2_VERTEX_3, N_CULLING, nurbsValue);
+        r->setnurbsproperty(GL_MAP2_VERTEX_4, N_CULLING, nurbsValue);
+        r->setnurbsproperty(GL_MAP1_VERTEX_3, N_CULLING, nurbsValue);
+        r->setnurbsproperty(GL_MAP1_VERTEX_4, N_CULLING, nurbsValue);
         return;
 
       case GLU_SAMPLING_METHOD:
-        if (value == GLU_PATH_LENGTH) {
-            nurbsValue = N_PATHLENGTH;
-        } else if (value == GLU_PARAMETRIC_ERROR) {
-            nurbsValue = N_PARAMETRICDISTANCE;
-        } else if (value == GLU_DOMAIN_DISTANCE) {
-            nurbsValue = N_DOMAINDISTANCE;
+        if (value == GLU_PATH_LENGTH) {
+            nurbsValue = N_PATHLENGTH;
+        } else if (value == GLU_PARAMETRIC_ERROR) {
+            nurbsValue = N_PARAMETRICDISTANCE;
+        } else if (value == GLU_DOMAIN_DISTANCE) {
+            nurbsValue = N_DOMAINDISTANCE;
             r->set_is_domain_distance_sampling(1); //optimzing untrimmed case
 
-        } else if (value == GLU_OBJECT_PARAMETRIC_ERROR) {
-            nurbsValue = N_OBJECTSPACE_PARA;
-            r->setautoloadmode( 0.0 );
-            r->setSamplingMatrixIdentity();
-        } else if (value == GLU_OBJECT_PATH_LENGTH) {
-            nurbsValue = N_OBJECTSPACE_PATH;
-            r->setautoloadmode( 0.0 );
-            r->setSamplingMatrixIdentity();
-        } else {
+        } else if (value == GLU_OBJECT_PARAMETRIC_ERROR) {
+            nurbsValue = N_OBJECTSPACE_PARA;
+            r->setautoloadmode( 0.0 );
+            r->setSamplingMatrixIdentity();
+        } else if (value == GLU_OBJECT_PATH_LENGTH) {
+            nurbsValue = N_OBJECTSPACE_PATH;
+            r->setautoloadmode( 0.0 );
+            r->setSamplingMatrixIdentity();
+        } else {
             r->postError(GLU_INVALID_VALUE);
             return;
         }
 
-        r->setnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMETHOD, nurbsValue);
-        r->setnurbsproperty(GL_MAP2_VERTEX_4, N_SAMPLINGMETHOD, nurbsValue);
-        r->setnurbsproperty(GL_MAP1_VERTEX_3, N_SAMPLINGMETHOD, nurbsValue);
-        r->setnurbsproperty(GL_MAP1_VERTEX_4, N_SAMPLINGMETHOD, nurbsValue);
-        return;
+        r->setnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMETHOD, nurbsValue);
+        r->setnurbsproperty(GL_MAP2_VERTEX_4, N_SAMPLINGMETHOD, nurbsValue);
+        r->setnurbsproperty(GL_MAP1_VERTEX_3, N_SAMPLINGMETHOD, nurbsValue);
+        r->setnurbsproperty(GL_MAP1_VERTEX_4, N_SAMPLINGMETHOD, nurbsValue);
+        return;
 
       case GLU_SAMPLING_TOLERANCE:
-        r->setnurbsproperty(GL_MAP2_VERTEX_3, N_PIXEL_TOLERANCE, value);
-        r->setnurbsproperty(GL_MAP2_VERTEX_4, N_PIXEL_TOLERANCE, value);
-        r->setnurbsproperty(GL_MAP1_VERTEX_3, N_PIXEL_TOLERANCE, value);
-        r->setnurbsproperty(GL_MAP1_VERTEX_4, N_PIXEL_TOLERANCE, value);
-        return;
+        r->setnurbsproperty(GL_MAP2_VERTEX_3, N_PIXEL_TOLERANCE, value);
+        r->setnurbsproperty(GL_MAP2_VERTEX_4, N_PIXEL_TOLERANCE, value);
+        r->setnurbsproperty(GL_MAP1_VERTEX_3, N_PIXEL_TOLERANCE, value);
+        r->setnurbsproperty(GL_MAP1_VERTEX_4, N_PIXEL_TOLERANCE, value);
+        return;
 
       case GLU_PARAMETRIC_TOLERANCE:
-        r->setnurbsproperty(GL_MAP2_VERTEX_3, N_ERROR_TOLERANCE, value);
+        r->setnurbsproperty(GL_MAP2_VERTEX_3, N_ERROR_TOLERANCE, value);
         r->setnurbsproperty(GL_MAP2_VERTEX_4, N_ERROR_TOLERANCE, value);
         r->setnurbsproperty(GL_MAP1_VERTEX_3, N_ERROR_TOLERANCE, value);
         r->setnurbsproperty(GL_MAP1_VERTEX_4, N_ERROR_TOLERANCE, value);
         return;
-        
+
 
       case GLU_DISPLAY_MODE:
-        
-        if (value == GLU_FILL) {
-          nurbsValue = N_FILL;
-        } else if (value == GLU_OUTLINE_POLYGON) {
-          nurbsValue = N_OUTLINE_POLY;
-        } else if (value == GLU_OUTLINE_PATCH) {
-          nurbsValue = N_OUTLINE_PATCH;
-        } else {
-          r->postError(GLU_INVALID_VALUE);
-          return;
-        }
-        r->setnurbsproperty(N_DISPLAY, nurbsValue);
-        
-        break;
+
+        if (value == GLU_FILL) {
+          nurbsValue = N_FILL;
+        } else if (value == GLU_OUTLINE_POLYGON) {
+          nurbsValue = N_OUTLINE_POLY;
+        } else if (value == GLU_OUTLINE_PATCH) {
+          nurbsValue = N_OUTLINE_PATCH;
+        } else {
+          r->postError(GLU_INVALID_VALUE);
+          return;
+        }
+        r->setnurbsproperty(N_DISPLAY, nurbsValue);
+
+        break;
 
       case GLU_U_STEP:
-        r->setnurbsproperty(GL_MAP1_VERTEX_3, N_S_STEPS, value);
-        r->setnurbsproperty(GL_MAP1_VERTEX_4, N_S_STEPS, value);
-        r->setnurbsproperty(GL_MAP2_VERTEX_3, N_S_STEPS, value);
-        r->setnurbsproperty(GL_MAP2_VERTEX_4, N_S_STEPS, value);
-        
-        //added for optimizing untrimmed case
+        r->setnurbsproperty(GL_MAP1_VERTEX_3, N_S_STEPS, value);
+        r->setnurbsproperty(GL_MAP1_VERTEX_4, N_S_STEPS, value);
+        r->setnurbsproperty(GL_MAP2_VERTEX_3, N_S_STEPS, value);
+        r->setnurbsproperty(GL_MAP2_VERTEX_4, N_S_STEPS, value);
+
+        //added for optimizing untrimmed case
         r->set_domain_distance_u_rate(value);
-        break;
+        break;
 
       case GLU_V_STEP:
@@ -340 +340 @@
         r->setnurbsproperty(GL_MAP2_VERTEX_4, N_T_STEPS, value);
 
-        //added for optimizing untrimmed case
+        //added for optimizing untrimmed case
         r->set_domain_distance_v_rate(value);
-        break;
-        
+        break;
+
       case GLU_NURBS_MODE:
-        if(value == GLU_NURBS_RENDERER)
-          r->put_callbackFlag(0);
-        else if(value == GLU_NURBS_TESSELLATOR)
-          r->put_callbackFlag(1);
-        else
-          r->postError(GLU_INVALID_ENUM);
-        break;
+        if(value == GLU_NURBS_RENDERER)
+          r->put_callbackFlag(0);
+        else if(value == GLU_NURBS_TESSELLATOR)
+          r->put_callbackFlag(1);
+        else
+          r->postError(GLU_INVALID_ENUM);
+        break;
 
       default:
-        r->postError(GLU_INVALID_ENUM);
-        return; 
+        r->postError(GLU_INVALID_ENUM);
+        return;
     }
 }
@@ -366 +366 @@
     switch(property) {
       case GLU_AUTO_LOAD_MATRIX:
-        if (r->getautoloadmode()) {
-            *value = GL_TRUE;
-        } else {
-            *value = GL_FALSE;
-        }
-        break;
+        if (r->getautoloadmode()) {
+            *value = GL_TRUE;
+        } else {
+            *value = GL_FALSE;
+        }
+        break;
       case GLU_CULLING:
-        r->getnurbsproperty(GL_MAP2_VERTEX_3, N_CULLING, &nurbsValue);
-        if (nurbsValue == N_CULLINGON) {
-            *value = GL_TRUE;
-        } else {
-            *value = GL_FALSE;
-        }
-        break;
+        r->getnurbsproperty(GL_MAP2_VERTEX_3, N_CULLING, &nurbsValue);
+        if (nurbsValue == N_CULLINGON) {
+            *value = GL_TRUE;
+        } else {
+            *value = GL_FALSE;
+        }
+        break;
       case GLU_SAMPLING_METHOD:
-        r->getnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMETHOD, value);
-        if(*value == N_PATHLENGTH)
-          *value = GLU_PATH_LENGTH;
-        else if(*value == N_PARAMETRICDISTANCE)
-          *value = GLU_PARAMETRIC_ERROR;
-        else if(*value == N_DOMAINDISTANCE)
-          *value = GLU_DOMAIN_DISTANCE;
-        else if(*value == N_OBJECTSPACE_PATH)
-          *value = GLU_OBJECT_PATH_LENGTH;
-        else if(*value == N_OBJECTSPACE_PARA)
-          *value = GLU_OBJECT_PARAMETRIC_ERROR; 
-        break;
+        r->getnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMETHOD, value);
+        if(*value == N_PATHLENGTH)
+          *value = GLU_PATH_LENGTH;
+        else if(*value == N_PARAMETRICDISTANCE)
+          *value = GLU_PARAMETRIC_ERROR;
+        else if(*value == N_DOMAINDISTANCE)
+          *value = GLU_DOMAIN_DISTANCE;
+        else if(*value == N_OBJECTSPACE_PATH)
+          *value = GLU_OBJECT_PATH_LENGTH;
+        else if(*value == N_OBJECTSPACE_PARA)
+          *value = GLU_OBJECT_PARAMETRIC_ERROR;
+        break;
       case GLU_SAMPLING_TOLERANCE:
-        r->getnurbsproperty(GL_MAP2_VERTEX_3, N_PIXEL_TOLERANCE, value);
-        break;
+        r->getnurbsproperty(GL_MAP2_VERTEX_3, N_PIXEL_TOLERANCE, value);
+        break;
       case GLU_PARAMETRIC_TOLERANCE:
-        r->getnurbsproperty(GL_MAP2_VERTEX_3, N_ERROR_TOLERANCE, value);
+        r->getnurbsproperty(GL_MAP2_VERTEX_3, N_ERROR_TOLERANCE, value);
         break;
 
       case GLU_U_STEP:
-        r->getnurbsproperty(GL_MAP2_VERTEX_3, N_S_STEPS, value);
-        break;
+        r->getnurbsproperty(GL_MAP2_VERTEX_3, N_S_STEPS, value);
+        break;
       case GLU_V_STEP:
-        r->getnurbsproperty(GL_MAP2_VERTEX_3, N_T_STEPS, value);
-        break;
+        r->getnurbsproperty(GL_MAP2_VERTEX_3, N_T_STEPS, value);
+        break;
       case GLU_DISPLAY_MODE:
-        r->getnurbsproperty(N_DISPLAY, &nurbsValue);
-        if (nurbsValue == N_FILL) {
-            *value = GLU_FILL;
-        } else if (nurbsValue == N_OUTLINE_POLY) {
-            *value = GLU_OUTLINE_POLYGON;
-        } else {
-            *value = GLU_OUTLINE_PATCH;
-        }
-        break;
+        r->getnurbsproperty(N_DISPLAY, &nurbsValue);
+        if (nurbsValue == N_FILL) {
+            *value = GLU_FILL;
+        } else if (nurbsValue == N_OUTLINE_POLY) {
+            *value = GLU_OUTLINE_POLYGON;
+        } else {
+            *value = GLU_OUTLINE_PATCH;
+        }
+        break;
 
       case GLU_NURBS_MODE:
-        if(r->is_callback())
-          *value = GLU_NURBS_TESSELLATOR;
-        else
-          *value = GLU_NURBS_RENDERER;
-        break;
-        
+        if(r->is_callback())
+          *value = GLU_NURBS_TESSELLATOR;
+        else
+          *value = GLU_NURBS_RENDERER;
+        break;
+
       default:
-        r->postError(GLU_INVALID_ENUM);
-        return;
+        r->postError(GLU_INVALID_ENUM);
+        return;
     }
 }
@@ -446 +446 @@
     case GLU_NURBS_TEXTURE_COORD_DATA:
     case GLU_NURBS_COLOR_DATA:
-        nobj->putSurfCallBack(which, (GLvoid (*)(...))fn);
+        nobj->putSurfCallBack(which, (GLvoid (* GLCALLBACK)(...))fn);
         break;
 
     case GLU_NURBS_ERROR:
-        nobj->errorCallback = (void (*)( GLenum )) fn;
+        nobj->errorCallback = (void (* GLCALLBACK)( GLenum )) fn;
         break;
     default:

trunk/src/opengl/glu/nurbs/interface/glrenderer.h

@@ -1 @@
-/* $Id: glrenderer.h,v 1.1 2000-02-09 08:49:01 jeroen Exp $ */
+/* $Id: glrenderer.h,v 1.2 2000-03-11 09:05:02 jeroen Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
@@ -37 +37 @@
  * glrenderer.h
  *
- * $Date: 2000-02-09 08:49:01 $ $Revision: 1.1 $
- * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/glrenderer.h,v 1.1 2000-02-09 08:49:01 jeroen Exp $
+ * $Date: 2000-03-11 09:05:02 $ $Revision: 1.2 $
+ * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/glrenderer.h,v 1.2 2000-03-11 09:05:02 jeroen Exp $
  */
 
@@ -56 +56 @@
     void        loadGLMatrices( void );
     void        useGLMatrices( const GLfloat modelMatrix[16],
-                               const GLfloat projMatrix[16],
-                               const GLint viewport[4] );
-    void                setSamplingMatrixIdentity( void );
+                               const GLfloat projMatrix[16],
+                               const GLint viewport[4] );
+    void                setSamplingMatrixIdentity( void );
 
-    void        errorHandler( int );
-    void        bgnrender( void );
-    void        endrender( void );
-    void        setautoloadmode( INREAL value )
-                    {
-                
-                      if (value) autoloadmode = GL_TRUE;
-                      else autoloadmode = GL_FALSE;
-                        
-                    }
-    GLboolean   getautoloadmode( void ) { return autoloadmode; }
+    void        errorHandler( int );
+    void        bgnrender( void );
+    void        endrender( void );
+    void        setautoloadmode( INREAL value )
+                    {
 
-    void        (GLAPI *errorCallback)( GLenum );
-    void        postError( int which )
-                    { if (errorCallback) (*errorCallback)( (GLenum)which ); }
+                      if (value) autoloadmode = GL_TRUE;
+                      else autoloadmode = GL_FALSE;
 
-    void        putSurfCallBack(GLenum which, GLvoid (GLAPI *fn)(...))
+                    }
+    GLboolean   getautoloadmode( void ) { return autoloadmode; }
+
+    void        (GLCALLBACK *errorCallback)( GLenum );
+    void        postError( int which )
+                    { if (errorCallback) (*errorCallback)( (GLenum)which ); }
+
+    void        putSurfCallBack(GLenum which, GLvoid (GLCALLBACK *fn)(...))
       {
-        curveEvaluator.putCallBack(which, fn);
-        surfaceEvaluator.putCallBack(which, fn);
+        curveEvaluator.putCallBack(which, fn);
+        surfaceEvaluator.putCallBack(which, fn);
       }
 
     int         get_vertices_call_back()
       {
-        return surfaceEvaluator.get_vertices_call_back();
+        return surfaceEvaluator.get_vertices_call_back();
       }
 
     void        put_vertices_call_back(int flag)
       {
-        surfaceEvaluator.put_vertices_call_back(flag);
+        surfaceEvaluator.put_vertices_call_back(flag);
       }
 
@@ -112 +112 @@
     void LOD_eval_list(int level)
       {
-        surfaceEvaluator.LOD_eval_list(level);
+        surfaceEvaluator.LOD_eval_list(level);
       }
 
@@ -118 +118 @@
     int        is_callback()
       {
-        return callbackFlag;
+        return callbackFlag;
       }
     void       put_callbackFlag(int flag)
       {
-        callbackFlag = flag;
-        surfaceEvaluator.put_vertices_call_back(flag);
-        curveEvaluator.put_vertices_call_back(flag);
+        callbackFlag = flag;
+        surfaceEvaluator.put_vertices_call_back(flag);
+        curveEvaluator.put_vertices_call_back(flag);
       }
 
 private:
-    GLboolean                   autoloadmode;
-    OpenGLSurfaceEvaluator      surfaceEvaluator;
-    OpenGLCurveEvaluator        curveEvaluator;
+    GLboolean                   autoloadmode;
+    OpenGLSurfaceEvaluator      surfaceEvaluator;
+    OpenGLCurveEvaluator        curveEvaluator;
 
-    void                loadSamplingMatrix( const GLfloat vmat[4][4],
-                                const GLint viewport[4] );
-    void                loadCullingMatrix( GLfloat vmat[4][4] );
-    static void         grabGLMatrix( GLfloat vmat[4][4] );
-    static void         transform4d( GLfloat A[4], GLfloat B[4],
-                                GLfloat mat[4][4] );
-    static void         multmatrix4d( GLfloat n[4][4], GLfloat left[4][4],
-                                GLfloat right[4][4] );
+    void                loadSamplingMatrix( const GLfloat vmat[4][4],
+                                const GLint viewport[4] );
+    void                loadCullingMatrix( GLfloat vmat[4][4] );
+    static void         grabGLMatrix( GLfloat vmat[4][4] );
+    static void         transform4d( GLfloat A[4], GLfloat B[4],
+                                GLfloat mat[4][4] );
+    static void         multmatrix4d( GLfloat n[4][4], GLfloat left[4][4],
+                                GLfloat right[4][4] );
 
    int                  callbackFlag;

trunk/src/opengl/glu/nurbs/interface/glsurfeval.cpp

@@ -1 @@
-/* $Id: glsurfeval.cpp,v 1.2 2000-03-04 19:10:13 jeroen Exp $ */
+/* $Id: glsurfeval.cpp,v 1.3 2000-03-11 09:05:02 jeroen Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
@@ -37 +37 @@
  * glsurfeval.c++
  *
- * $Date: 2000-03-04 19:10:13 $ $Revision: 1.2 $
- * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/glsurfeval.cpp,v 1.2 2000-03-04 19:10:13 jeroen Exp $
+ * $Date: 2000-03-11 09:05:02 $ $Revision: 1.3 $
+ * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/glsurfeval.cpp,v 1.3 2000-03-11 09:05:02 jeroen Exp $
  */
 
@@ -52 +52 @@
 #include "bezierPatchMesh.h"
 
-
 //extern int surfcount;
 //int surfcount=0;
 
-/*#define USE_INTERNAL_EVAL*/ //use internal evaluator
+#define USE_INTERNAL_EVAL                     /* use internal evaluator*/
 
 /*whether do evaluation or not*/
@@ -1126 +1125 @@
     glEvalCoord2f((GLfloat) u, (GLfloat) v);
 
-
 #endif
 
@@ -1192 +1190 @@
 
 void
-OpenGLSurfaceEvaluator::putCallBack(GLenum which, GLvoid (GLAPI *fn)(...))
+OpenGLSurfaceEvaluator::putCallBack(GLenum which, GLvoid (GLCALLBACK *fn)(...))
 {
   switch(which)
     {
     case GLU_NURBS_BEGIN:
-      beginCallBackN = (void (GLAPI *) (GLenum)) fn;
+      beginCallBackN = (void (GLCALLBACK *) (GLenum)) fn;
       break;
     case GLU_NURBS_END:
-      endCallBackN = (void (GLAPI *) (void)) fn;
+      endCallBackN = (void (GLCALLBACK *) (void)) fn;
       break;
     case GLU_NURBS_VERTEX:
-      vertexCallBackN = (void (GLAPI *) (const GLfloat*)) fn;
+      vertexCallBackN = (void (GLCALLBACK *) (const GLfloat*)) fn;
       break;
     case GLU_NURBS_NORMAL:
-      normalCallBackN = (void (GLAPI *) (const GLfloat*)) fn;
+      normalCallBackN = (void (GLCALLBACK *) (const GLfloat*)) fn;
       break;
     case GLU_NURBS_COLOR:
-      colorCallBackN = (void (GLAPI *) (const GLfloat*)) fn;
+      colorCallBackN = (void (GLCALLBACK *) (const GLfloat*)) fn;
       break;
     case GLU_NURBS_TEXTURE_COORD:
-      texcoordCallBackN = (void (GLAPI *) (const GLfloat*)) fn;
+      texcoordCallBackN = (void (GLCALLBACK *) (const GLfloat*)) fn;
       break;
     case GLU_NURBS_BEGIN_DATA:
-      beginCallBackData = (void (GLAPI *) (GLenum, void*)) fn;
+      beginCallBackData = (void (GLCALLBACK *) (GLenum, void*)) fn;
       break;
     case GLU_NURBS_END_DATA:
-      endCallBackData = (void (GLAPI *) (void*)) fn;
+      endCallBackData = (void (GLCALLBACK *) (void*)) fn;
       break;
     case GLU_NURBS_VERTEX_DATA:
-      vertexCallBackData = (void (GLAPI *) (const GLfloat*, void*)) fn;
+      vertexCallBackData = (void (GLCALLBACK *) (const GLfloat*, void*)) fn;
       break;
     case GLU_NURBS_NORMAL_DATA:
-      normalCallBackData = (void (GLAPI *) (const GLfloat*, void*)) fn;
+      normalCallBackData = (void (GLCALLBACK *) (const GLfloat*, void*)) fn;
       break;
     case GLU_NURBS_COLOR_DATA:
-      colorCallBackData = (void (GLAPI *) (const GLfloat*, void*)) fn;
+      colorCallBackData = (void (GLCALLBACK *) (const GLfloat*, void*)) fn;
       break;
     case GLU_NURBS_TEXTURE_COORD_DATA:
-      texcoordCallBackData = (void (GLAPI *) (const GLfloat*, void*)) fn;
+      texcoordCallBackData = (void (GLCALLBACK *) (const GLfloat*, void*)) fn;
       break;
 

trunk/src/opengl/glu/nurbs/interface/glsurfeval.h

@@ -1 @@
-/* $Id: glsurfeval.h,v 1.1 2000-02-09 08:49:02 jeroen Exp $ */
+/* $Id: glsurfeval.h,v 1.2 2000-03-11 09:05:03 jeroen Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
@@ -37 +37 @@
  * glsurfeval.h
  *
- * $Date: 2000-02-09 08:49:02 $ $Revision: 1.1 $
- * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/glsurfeval.h,v 1.1 2000-02-09 08:49:02 jeroen Exp $
+ * $Date: 2000-03-11 09:05:03 $ $Revision: 1.2 $
+ * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/glsurfeval.h,v 1.2 2000-03-11 09:05:03 jeroen Exp $
  */
 
@@ -62 +62 @@
 #define IN_MAX_BEZIER_ORDER 40 /*XXX should be bigger than machine order*/
 #endif
-                        
+
 #ifndef IN_MAX_DIMENSION
 #define IN_MAX_DIMENSION 4
@@ -90 +90 @@
 class StoredVertex {
 public:
-                StoredVertex() { type = 0; }
-                ~StoredVertex(void) {}
-    void        saveEvalCoord(REAL x, REAL y)
-                    {coord[0] = x; coord[1] = y; type = TYPECOORD; }
-    void        saveEvalPoint(long x, long y)
-                    {point[0] = x; point[1] = y; type = TYPEPOINT; }
-    void        invoke(OpenGLSurfaceEvaluator *eval);
+                StoredVertex() { type = 0; }
+                ~StoredVertex(void) {}
+    void        saveEvalCoord(REAL x, REAL y)
+                    {coord[0] = x; coord[1] = y; type = TYPECOORD; }
+    void        saveEvalPoint(long x, long y)
+                    {point[0] = x; point[1] = y; type = TYPEPOINT; }
+    void        invoke(OpenGLSurfaceEvaluator *eval);
 
 private:
-    int         type;
-    REAL        coord[2];
-    long        point[2];
+    int         type;
+    REAL        coord[2];
+    long        point[2];
 };
 
 class OpenGLSurfaceEvaluator : public BasicSurfaceEvaluator {
 public:
-                        OpenGLSurfaceEvaluator();
-                        ~OpenGLSurfaceEvaluator( void );
-    void                polymode( long style );
-    void                range2f( long, REAL *, REAL * );
-    void                domain2f( REAL, REAL, REAL, REAL );
-    void                addMap( SurfaceMap * ) { }
-
-    void                enable( long );
-    void                disable( long );
-    void                bgnmap2f( long );
-    void                map2f( long, REAL, REAL, long, long,
-                                     REAL, REAL, long, long, REAL * );
-    void                mapgrid2f( long, REAL, REAL, long, REAL, REAL );
-    void                mapmesh2f( long, long, long, long, long );
-    void                evalcoord2f( long, REAL, REAL );
-    void                evalpoint2i( long, long );
-    void                endmap2f( void );
-
-    void                bgnline( void );
-    void                endline( void );
-    void                bgnclosedline( void );
-    void                endclosedline( void );
-    void                bgntmesh( void );
-    void                swaptmesh( void );
-    void                endtmesh( void );
-    void                bgnqstrip( void );
-    void                endqstrip( void );
+                        OpenGLSurfaceEvaluator();
+                        ~OpenGLSurfaceEvaluator( void );
+    void                polymode( long style );
+    void                range2f( long, REAL *, REAL * );
+    void                domain2f( REAL, REAL, REAL, REAL );
+    void                addMap( SurfaceMap * ) { }
+
+    void                enable( long );
+    void                disable( long );
+    void                bgnmap2f( long );
+    void                map2f( long, REAL, REAL, long, long,
+                                     REAL, REAL, long, long, REAL * );
+    void                mapgrid2f( long, REAL, REAL, long, REAL, REAL );
+    void                mapmesh2f( long, long, long, long, long );
+    void                evalcoord2f( long, REAL, REAL );
+    void                evalpoint2i( long, long );
+    void                endmap2f( void );
+
+    void                bgnline( void );
+    void                endline( void );
+    void                bgnclosedline( void );
+    void                endclosedline( void );
+    void                bgntmesh( void );
+    void                swaptmesh( void );
+    void                endtmesh( void );
+    void                bgnqstrip( void );
+    void                endqstrip( void );
 
     void                bgntfan( void );
@@ -141 +141 @@
                                    int n_right, REAL u_right, REAL* right_val);
 
-    void                coord2f( REAL, REAL );
-    void                point2i( long, long );
-
-    void                newtmeshvert( REAL, REAL );
-    void                newtmeshvert( long, long );
-
-    void                putCallBack(GLenum which, GLvoid (GLAPI *fn)(...));
+    void                coord2f( REAL, REAL );
+    void                point2i( long, long );
+
+    void                newtmeshvert( REAL, REAL );
+    void                newtmeshvert( long, long );
+
+    void                putCallBack(GLenum which, GLvoid (GLCALLBACK *fn)(...));
     int                 get_vertices_call_back()
       {
-        return output_triangles;
+        return output_triangles;
       }
     void                put_vertices_call_back(int flag)
       {
-        output_triangles = flag;
+        output_triangles = flag;
       }
 
@@ -179 +179 @@
 
 private:
-    StoredVertex        *vertexCache[VERTEX_CACHE_SIZE];
-    int                 tmeshing;
-    int                 which;
-    int                 vcount;
+    StoredVertex        *vertexCache[VERTEX_CACHE_SIZE];
+    int                 tmeshing;
+    int                 which;
+    int                 vcount;
 
     GLint              gl_polygon_mode[2];/*to save and restore so that
-                                         *no side effect
-                                         */
+                                         *no side effect
+                                         */
     bezierPatchMesh        *global_bpm; //for output triangles
     int                output_triangles; //true 1 or false 0
@@ -192 +192 @@
 
 
-    void (GLAPI *beginCallBackN) (GLenum type);
-    void (GLAPI *endCallBackN)   (void);
-    void (GLAPI *vertexCallBackN) (const GLfloat *vert);
-    void (GLAPI *normalCallBackN) (const GLfloat *normal);
-    void (GLAPI *colorCallBackN) (const GLfloat *color);
-    void (GLAPI *texcoordCallBackN) (const GLfloat *texcoord);
-
-    void (GLAPI *beginCallBackData) (GLenum type, void* data);
-    void (GLAPI *endCallBackData)   (void* data);
-    void (GLAPI *vertexCallBackData) (const GLfloat *vert, void* data);
-    void (GLAPI *normalCallBackData) (const GLfloat *normal, void* data);
-    void (GLAPI *colorCallBackData) (const GLfloat *color, void* data);
-    void (GLAPI *texcoordCallBackData) (const GLfloat *texcoord, void* data);
-
-    void               beginCallBack (GLenum type, void* data);
-    void               endCallBack   (void* data);
-    void               vertexCallBack (const GLfloat *vert, void* data);
-    void               normalCallBack (const GLfloat *normal, void* data);
-    void               colorCallBack (const GLfloat *color, void* data);
-    void               texcoordCallBack (const GLfloat *texcoord, void* data);
-
-
-    void* userData; //the opaque pointer for Data callback functions.
+    void (GLCALLBACK *beginCallBackN) (GLenum type);
+    void (GLCALLBACK *endCallBackN)   (void);
+    void (GLCALLBACK *vertexCallBackN) (const GLfloat *vert);
+    void (GLCALLBACK *normalCallBackN) (const GLfloat *normal);
+    void (GLCALLBACK *colorCallBackN) (const GLfloat *color);
+    void (GLCALLBACK *texcoordCallBackN) (const GLfloat *texcoord);
+
+    void (GLCALLBACK *beginCallBackData) (GLenum type, void* data);
+    void (GLCALLBACK *endCallBackData)   (void* data);
+    void (GLCALLBACK *vertexCallBackData) (const GLfloat *vert, void* data);
+    void (GLCALLBACK *normalCallBackData) (const GLfloat *normal, void* data);
+    void (GLCALLBACK *colorCallBackData) (const GLfloat *color, void* data);
+    void (GLCALLBACK *texcoordCallBackData) (const GLfloat *texcoord, void* data);
+
+    void         beginCallBack (GLenum type, void* data);
+    void         endCallBack   (void* data);
+    void         vertexCallBack (const GLfloat *vert, void* data);
+    void         normalCallBack (const GLfloat *normal, void* data);
+    void         colorCallBack (const GLfloat *color, void* data);
+    void         texcoordCallBack (const GLfloat *texcoord, void* data);
+
+
+    void* userData;      /* the opaque pointer for Data callback functions.*/
 
    /*LOD evaluation*/
    void LOD_triangle(REAL A[2], REAL B[2], REAL C[2],
-                     int level);
+                     int level);
    void LOD_eval(int num_vert, REAL* verts, int type, int level);
-                
-  int LOD_eval_level; //set by LOD_eval_list()
+
+  int LOD_eval_level;                  /* set by LOD_eval_list()           */
 
    /*************begin for internal evaluators*****************/
-                        
+
  /*the following global variables are only defined in this file.
  *They are used to cache the precomputed Bezier polynomial values.
@@ -272 +272 @@
 /*functions*/
  void inDoDomain2WithDerivs(int k, REAL u, REAL v,
-                                REAL u1, REAL u2, int uorder,
-                                REAL v1,  REAL v2, int vorder,
-                                REAL *baseData,
-                                REAL *retPoint, REAL *retdu, REAL *retdv);
+                                REAL u1, REAL u2, int uorder,
+                                REAL v1,  REAL v2, int vorder,
+                                REAL *baseData,
+                                REAL *retPoint, REAL *retdu, REAL *retdv);
  void inPreEvaluate(int order, REAL vprime, REAL *coeff);
  void inPreEvaluateWithDeriv(int order, REAL vprime, REAL *coeff, REAL *coeffDeriv);
@@ -281 +281 @@
  void inComputeNormal2(REAL *pu, REAL *pv, REAL *n);
  void inDoEvalCoord2(REAL u, REAL v,
-                     REAL *retPoint, REAL *retNormal);
+                     REAL *retPoint, REAL *retNormal);
  void inDoEvalCoord2NOGE(REAL u, REAL v,
-                     REAL *retPoint, REAL *retNormal);
+                     REAL *retPoint, REAL *retNormal);
  void inMap2f(int k,
-              REAL ulower,
-              REAL uupper,
-              int ustride,
-              int uorder,
-              REAL vlower,
-              REAL vupper,
-              int vstride,
-              int vorder,
-              REAL *ctlPoints);
+              REAL ulower,
+              REAL uupper,
+              int ustride,
+              int uorder,
+              REAL vlower,
+              REAL vupper,
+              int vstride,
+              int vorder,
+              REAL *ctlPoints);
 
  void inMapGrid2f(int nu, REAL u0, REAL u1,
-                  int nv, REAL v0, REAL v1);
+                  int nv, REAL v0, REAL v1);
 
  void inEvalMesh2(int lowU, int lowV, int highU, int highV);
@@ -303 +303 @@
 
 void inEvalULine(int n_points, REAL v, REAL* u_vals,
-        int stride, REAL ret_points[][3], REAL ret_normals[][3]);
+        int stride, REAL ret_points[][3], REAL ret_normals[][3]);
 
 void inEvalVLine(int n_points, REAL u, REAL* v_vals,
-        int stride, REAL ret_points[][3], REAL ret_normals[][3]);
+        int stride, REAL ret_points[][3], REAL ret_normals[][3]);
 
 void inEvalUStrip(int n_upper, REAL v_upper, REAL* upper_val,
@@ -326 +326 @@
 
 void inDoDomain2WithDerivsBV(int k, REAL u, REAL v,
-                             REAL u1, REAL u2, int uorder,
-                             REAL v1, REAL v2, int vorder,
-                             REAL *baseData,
-                             REAL *retPoint, REAL* retdu, REAL *retdv);
+                             REAL u1, REAL u2, int uorder,
+                             REAL v1, REAL v2, int vorder,
+                             REAL *baseData,
+                             REAL *retPoint, REAL* retdu, REAL *retdv);
 
 void inDoDomain2WithDerivsBU(int k, REAL u, REAL v,
-                             REAL u1, REAL u2, int uorder,
-                             REAL v1, REAL v2, int vorder,
-                             REAL *baseData,
-                             REAL *retPoint, REAL* retdu, REAL *retdv);
+                             REAL u1, REAL u2, int uorder,
+                             REAL v1, REAL v2, int vorder,
+                             REAL *baseData,
+                             REAL *retPoint, REAL* retdu, REAL *retdv);
 
 
 void inDoEvalCoord2NOGE_BV(REAL u, REAL v,
-                           REAL *retPoint, REAL *retNormal);
+                           REAL *retPoint, REAL *retNormal);
 
 void inDoEvalCoord2NOGE_BU(REAL u, REAL v,
-                           REAL *retPoint, REAL *retNormal);
+                           REAL *retPoint, REAL *retNormal);
 
 void inBPMEval(bezierPatchMesh* bpm);
@@ -362 +362 @@
 
 void inMap2fEM(int which, //0:vert,1:norm,2:color,3:tex
-               int dimension,
-              REAL ulower,
-              REAL uupper,
-              int ustride,
-              int uorder,
-              REAL vlower,
-              REAL vupper,
-              int vstride,
-              int vorder,
-              REAL *ctlPoints);
+               int dimension,
+              REAL ulower,
+              REAL uupper,
+              int ustride,
+              int uorder,
+              REAL vlower,
+              REAL vupper,
+              int vstride,
+              int vorder,
+              REAL *ctlPoints);
 
 void inDoDomain2WithDerivsEM(surfEvalMachine *em, REAL u, REAL v,
-                                REAL *retPoint, REAL *retdu, REAL *retdv);
+                                REAL *retPoint, REAL *retdu, REAL *retdv);
 void inDoDomain2EM(surfEvalMachine *em, REAL u, REAL v,
-                                REAL *retPoint);
+                                REAL *retPoint);
  void inDoEvalCoord2EM(REAL u, REAL v);
 
@@ -386 +386 @@
 
    /*************end for internal evaluators*****************/
-                
+
 };
 
@@ -393 +393 @@
     switch(type) {
       case TYPECOORD:
-        eval->coord2f(coord[0], coord[1]);
-        break;
+        eval->coord2f(coord[0], coord[1]);
+        break;
       case TYPEPOINT:
-        eval->point2i(point[0], point[1]);
-        break;
+        eval->point2i(point[0], point[1]);
+        break;
       default:
-        break;
+        break;
     }
 }

trunk/src/opengl/glu/nurbs/interface/insurfeval.cpp

@@ -1 @@
-/* $Id: insurfeval.cpp,v 1.1 2000-02-09 08:49:02 jeroen Exp $ */
+/* $Id: insurfeval.cpp,v 1.2 2000-03-11 09:05:03 jeroen Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
@@ -33 +33 @@
 ** compliant with the OpenGL(R) version 1.2.1 Specification.
 **
-** $Date: 2000-02-09 08:49:02 $ $Revision: 1.1 $
+** $Date: 2000-03-11 09:05:03 $ $Revision: 1.2 $
 */
 /*
-** $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/insurfeval.cpp,v 1.1 2000-02-09 08:49:02 jeroen Exp $
+** $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/insurfeval.cpp,v 1.2 2000-03-11 09:05:03 jeroen Exp $
 */
 
@@ -66 +66 @@
 
 static void LOD_interpolate(REAL A[2], REAL B[2], REAL C[2], int j, int k, int pow2_level,
-                            REAL& u, REAL& v)
+                            REAL& u, REAL& v)
 {
   REAL a,a1,b,b1;
@@ -94 +94 @@
 
 void OpenGLSurfaceEvaluator::LOD_triangle(REAL A[2], REAL B[2], REAL C[2],
-                         int level)
+                         int level)
 {
   int k,j;
@@ -118 +118 @@
 
       for(k=0; k<=j; k++)
-        {
-          LOD_interpolate(A,B,C,j,j-k,pow2_level, u,v);
+        {
+          LOD_interpolate(A,B,C,j,j-k,pow2_level, u,v);
 #ifdef USE_LOD
           LOD_EVAL_COORD(u,v);
-//        glEvalCoord2f(u,v);
+//        glEvalCoord2f(u,v);
 #else
-          inDoEvalCoord2EM(u,v);
+          inDoEvalCoord2EM(u,v);
 #endif
 
-          LOD_interpolate(A,B,C,j+1,j-k,pow2_level, u,v);
+          LOD_interpolate(A,B,C,j+1,j-k,pow2_level, u,v);
 
 #ifdef USE_LOD
-          LOD_EVAL_COORD(u,v);
-//        glEvalCoord2f(u,v);
+          LOD_EVAL_COORD(u,v);
+//        glEvalCoord2f(u,v);
 #else
-          inDoEvalCoord2EM(u,v);
+          inDoEvalCoord2EM(u,v);
 #endif
-        }
-//      endCallBack();  
+        }
+//      endCallBack();
 glEnd();
     }
@@ -142 +142 @@
 
 void OpenGLSurfaceEvaluator::LOD_eval(int num_vert, REAL* verts, int type,
-                     int level
-                     )
+                     int level
+                     )
 {
   int i,k;
@@ -151 +151 @@
     for(i=2, k=4; i<=num_vert-2; i+=2, k+=4)
       {
-        LOD_triangle(verts+k-4, verts+k-2, verts+k,
-                     level
-                     );
-        LOD_triangle(verts+k-2, verts+k+2, verts+k,
-                     level
-                     );
+        LOD_triangle(verts+k-4, verts+k-2, verts+k,
+                     level
+                     );
+        LOD_triangle(verts+k-2, verts+k+2, verts+k,
+                     level
+                     );
       }
     if(num_vert % 2 ==1)
       {
-        LOD_triangle(verts+2*(num_vert-3), verts+2*(num_vert-2), verts+2*(num_vert-1),
-                     level
-                     );
+        LOD_triangle(verts+2*(num_vert-3), verts+2*(num_vert-2), verts+2*(num_vert-1),
+                     level
+                     );
       }
     break;
@@ -168 +168 @@
     for(i=1, k=2; i<=num_vert-2; i++, k+=2)
       {
-        LOD_triangle(verts,verts+k, verts+k+2,
-                     level
-                     );
+        LOD_triangle(verts,verts+k, verts+k+2,
+                     level
+                     );
       }
     break;
@@ -178 +178 @@
   }
 }
-        
+
 
 #endif //USE_LOD
@@ -256 +256 @@
   int vstride = bpm->bpatch->dimension;
   inMap2f(
-          (bpm->bpatch->dimension == 3)? GL_MAP2_VERTEX_3 : GL_MAP2_VERTEX_4,
-          bpm->bpatch->umin,
-          bpm->bpatch->umax,
-          ustride,
-          bpm->bpatch->uorder,
-          bpm->bpatch->vmin,
-          bpm->bpatch->vmax,
-          vstride,
-          bpm->bpatch->vorder,
-          bpm->bpatch->ctlpoints);
+          (bpm->bpatch->dimension == 3)? GL_MAP2_VERTEX_3 : GL_MAP2_VERTEX_4,
+          bpm->bpatch->umin,
+          bpm->bpatch->umax,
+          ustride,
+          bpm->bpatch->uorder,
+          bpm->bpatch->vmin,
+          bpm->bpatch->vmax,
+          vstride,
+          bpm->bpatch->vorder,
+          bpm->bpatch->ctlpoints);
 
   bpm->vertex_array = (float*) malloc(sizeof(float)* (bpm->index_UVarray/2) * 3+1); /*in case the origional dimenion is 4, then we need 4 space to pass to evaluator.*/
@@ -1339 +1339 @@
               leftMostV[1] = v_lower;
 
-              leftMostNormal = lowerNormal[j-1];
-              leftMostXYZ = lowerXYZ[j-1];
+              leftMostNormal = lowerNormal[j-1];
+              leftMostXYZ = lowerXYZ[j-1];
             }
         }
@@ -1423 +1423 @@
             {
               bgntfan();
-              glNormal3fv(botMostNormal);
+              glNormal3fv(botMostNormal);
               glVertex3fv(botMostXYZ);
 
               while(j<n_right){
-                glNormal3fv(rightNormal[j]);
-                glVertex3fv(rightXYZ[j]);
-                j++;
+                glNormal3fv(rightNormal[j]);
+                glVertex3fv(rightXYZ[j]);
+                j++;
 
               }
@@ -1441 +1441 @@
             {
               bgntfan();
-              glNormal3fv(botMostNormal);
-              glVertex3fv(botMostXYZ);
-        
+              glNormal3fv(botMostNormal);
+              glVertex3fv(botMostXYZ);
+
               for(k=n_left-1; k>=i; k--) /*reverse order for two-side lighting*/
-                {
-                  glNormal3fv(leftNormal[k]);
-                  glVertex3fv(leftXYZ[k]);
-                }
+                {
+                  glNormal3fv(leftNormal[k]);
+                  glVertex3fv(leftXYZ[k]);
+                }
 
               endtfan();
@@ -1458 +1458 @@
           if(left_val[i] <= right_val[j])
             {
-              bgntfan();
-
-              glNormal3fv(rightNormal[j]);
-              glVertex3fv(rightXYZ[j]);
+              bgntfan();
+
+              glNormal3fv(rightNormal[j]);
+              glVertex3fv(rightXYZ[j]);
 
               /*find the last k>=i such that
@@ -1480 +1480 @@
               for(l=k; l>=i; l--)/*the reverse is for two-side lighting*/
                 {
-                  glNormal3fv(leftNormal[l]);
-                  glVertex3fv(leftXYZ[l]);
+                  glNormal3fv(leftNormal[l]);
+                  glVertex3fv(leftXYZ[l]);
 
                 }
-              glNormal3fv(botMostNormal);
-              glVertex3fv(botMostXYZ);
+              glNormal3fv(botMostNormal);
+              glVertex3fv(botMostXYZ);
 
               endtfan();
@@ -1493 +1493 @@
               i = k+1;
 
-              botMostV[0] = u_left;
-              botMostV[1] = left_val[k];
-              botMostNormal = leftNormal[k];
-              botMostXYZ = leftXYZ[k];
+              botMostV[0] = u_left;
+              botMostV[1] = left_val[k];
+              botMostNormal = leftNormal[k];
+              botMostXYZ = leftXYZ[k];
             }
           else /*left_val[i] > right_val[j])*/
             {
-              bgntfan();
-              glNormal3fv(leftNormal[i]);
-              glVertex3fv(leftXYZ[i]);
-        
+              bgntfan();
+              glNormal3fv(leftNormal[i]);
+              glVertex3fv(leftXYZ[i]);
+
               glNormal3fv(botMostNormal);
-              glVertex3fv(botMostXYZ);
-        
+              glVertex3fv(botMostXYZ);
+
 
               /*find the last k>=j such that
@@ -1516 +1516 @@
                   if(right_val[k] >= left_val[i])
                     break;
-                  glNormal3fv(rightNormal[k]);
-                  glVertex3fv(rightXYZ[k]);
+                  glNormal3fv(rightNormal[k]);
+                  glVertex3fv(rightXYZ[k]);
 
                   k++;
@@ -1526 +1526 @@
                */
               j=k;
-              botMostV[0] = u_right;
-              botMostV[1] = right_val[j-1];
-
-              botMostNormal = rightNormal[j-1];
-              botMostXYZ = rightXYZ[j-1];
+              botMostV[0] = u_right;
+              botMostV[1] = right_val[j-1];
+
+              botMostNormal = rightNormal[j-1];
+              botMostXYZ = rightXYZ[j-1];
             }
         }
@@ -1536 +1536 @@
   //clean up
   free(leftXYZ);
-  free(leftXYZ);
-  free(rightNormal);
+  free(rightXYZ);
+  free(leftNormal);
   free(rightNormal);
 }
@@ -1543 +1543 @@
 /*-----------------------begin evalMachine-------------------*/
 void OpenGLSurfaceEvaluator::inMap2fEM(int which, int k,
-             REAL ulower,
-             REAL uupper,
-             int ustride,
-             int uorder,
-             REAL vlower,
-             REAL vupper,
-             int vstride,
-             int vorder,
-             REAL *ctlPoints)
+             REAL ulower,
+             REAL uupper,
+             int ustride,
+             int uorder,
+             REAL vlower,
+             REAL vupper,
+             int vstride,
+             int vorder,
+             REAL *ctlPoints)
 {
   int i,j,x;
@@ -2046 +2046 @@
 #endif //GENERIC_TEST
 
-            inDoEvalCoord2EM(u,v);
+            inDoEvalCoord2EM(u,v);
 
 #endif //USE_LOD
 
-          k += 2;
-        }
+          k += 2;
+        }
       endCallBack(userData);
 

trunk/src/opengl/glu/nurbs/internals/slicer.cpp

@@ -1 @@
-/* $Id: slicer.cpp,v 1.1 2000-02-09 08:50:28 jeroen Exp $ */
+/* $Id: slicer.cpp,v 1.2 2000-03-11 09:05:03 jeroen Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
@@ -37 +37 @@
  * slicer.c++
  *
- * $Date: 2000-02-09 08:50:28 $ $Revision: 1.1 $
- * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/internals/slicer.cpp,v 1.1 2000-02-09 08:50:28 jeroen Exp $
+ * $Date: 2000-03-11 09:05:03 $ $Revision: 1.2 $
+ * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/internals/slicer.cpp,v 1.2 2000-03-11 09:05:03 jeroen Exp $
  */
 
@@ -55 +55 @@
 #include "varray.h"
 
-#include "polyUtil.h" //for area()
+#include "polyUtil.h"                  /* for area()                       */
 
 //static int count=0;
@@ -111 +111 @@
 
   n_changes  = (compV2InX(loop->prev->head(), loop->prev->tail())
-                != cur_sign);
+                != cur_sign);
 
   for(temp=loop->next; temp != loop; temp = temp->next)
@@ -120 +120 @@
        {
 #ifdef DEBUG
-         printf("***change signe\n");
+         printf("***change signe\n");
 #endif
-         n_changes++;
+         n_changes++;
        }
     }
@@ -154 +154 @@
       //first find bot
       for(temp = loop->next; temp != loop; temp = temp->next)
-        {
-          if(compInY(temp->tail(), temp->prev->tail()) > 0)
-            break;
-        }
+        {
+          if(compInY(temp->tail(), temp->prev->tail()) > 0)
+            break;
+        }
       bot = temp->prev;
       //then find top
       for(temp=loop->prev; temp != loop; temp = temp->prev)
-        {
-          if(compInY(temp->tail(), temp->prev->tail()) > 0)
-            break;
-        }
+        {
+          if(compInY(temp->tail(), temp->prev->tail()) > 0)
+            break;
+        }
       top = temp;
     }
@@ -170 +170 @@
     {
       for(temp=loop->next; temp != loop; temp = temp->next)
-        {
-          if(compInY(temp->tail(), temp->prev->tail()) < 0)
-            break;
-        }
+        {
+          if(compInY(temp->tail(), temp->prev->tail()) < 0)
+            break;
+        }
       top = temp->prev;
       for(temp=loop->prev; temp != loop; temp = temp->prev)
-        {
-          if(compInY(temp->tail(), temp->prev->tail()) < 0)
-            break;
-        }
+        {
+          if(compInY(temp->tail(), temp->prev->tail()) < 0)
+            break;
+        }
       bot = temp;
     }
@@ -192 +192 @@
     {
       for(i=0; i<=jarc->pwlArc->npts-2; i++)
-        {
-          inc_chain.appendVertex(jarc->pwlArc->pts[i].param);
-        }
+        {
+          inc_chain.appendVertex(jarc->pwlArc->pts[i].param);
+        }
 
     }
@@ -201 +201 @@
     {
       for(i=jarc->pwlArc->npts-2; i>=0; i--)
-        {
-          dec_chain.appendVertex(jarc->pwlArc->pts[i].param);
-        }
+        {
+          dec_chain.appendVertex(jarc->pwlArc->pts[i].param);
+        }
     }
   for(i=bot->pwlArc->npts-2; i>=1; i--)
     {
       dec_chain.appendVertex(jarc->pwlArc->pts[i].param);
-    }   
+    }
 
   monoTriangulationRec(top->tail(), bot->tail(), &inc_chain, 0,
-                       &dec_chain, 0, &backend);
+                       &dec_chain, 0, &backend);
 
 }
@@ -225 +225 @@
       nlines++;
       if(nlines == 5)
-        break;
+        break;
     }
   if(nlines != 4)
@@ -238 +238 @@
 printf("loop->next->head=(%f,%f)\n", loop->next->head()[0], loop->next->head()[1]);
 if(fabs(loop->tail()[0] - loop->head()[0])<0.000001)
-        printf("equal 1\n");
+        printf("equal 1\n");
 if(loop->next->tail()[1] == loop->next->head()[1])
-        printf("equal 2\n");
+        printf("equal 2\n");
 */
 
@@ -290 +290 @@
       int i;
       for(i=0; i<n; i++)
-        backend.tmeshvertNOGE(&verts[i]);
+        backend.tmeshvertNOGE(&verts[i]);
     }
 }
@@ -319 +319 @@
     {
       if(loop->tail()[1] > loop->prev->prev->tail()[1])
-        {
-
-        top = loop;
-        }
+        {
+
+        top = loop;
+        }
       else{
 
-        top = loop->prev->prev;
-        }
+        top = loop->prev->prev;
+        }
     }
   else
     {
       if(loop->tail()[0] > loop->prev->prev->tail()[0])
-        {
-          //loop is the right arc
-
-          top = loop->next;
-        }
+        {
+          //loop is the right arc
+
+          top = loop->next;
+        }
       else
-        {
-
-          top = loop->prev;
-        }
+        {
+
+          top = loop->prev;
+        }
     }
   left = top->next;
@@ -353 +353 @@
       int nu = top->pwlArc->npts;
       if(nu < bot->pwlArc->npts)
-        nu = bot->pwlArc->npts;
+        nu = bot->pwlArc->npts;
       int nv = left->pwlArc->npts;
       if(nv < right->pwlArc->npts)
-        nv = right->pwlArc->npts;
+        nv = right->pwlArc->npts;
 /*
       if(nu > 2 && nv > 2)
-        {
-          triangulateRectGen(top, nu-2,  nv-2, backend);
-          return;
-        }
+        {
+          triangulateRectGen(top, nu-2,  nv-2, backend);
+          return;
+        }
 */
     }
@@ -376 +376 @@
 
       if(maxPointsTB < maxPointsLR)
-        triangulateRectAux(left->pwlArc, right->pwlArc, bot->pwlArc, top->pwlArc, backend);
+        triangulateRectAux(left->pwlArc, right->pwlArc, bot->pwlArc, top->pwlArc, backend);
       else
-        triangulateRectAux(top->pwlArc, bot->pwlArc, left->pwlArc, right->pwlArc, backend);
+        triangulateRectAux(top->pwlArc, bot->pwlArc, left->pwlArc, right->pwlArc, backend);
     }
 }
@@ -397 +397 @@
 
       if(top->npts == 2) {
-        backend.bgntfan();
-        OPT_OUTVERT(top->pts[0], backend);//the root
-        for(i=0; i<left->npts; i++){
-          OPT_OUTVERT(left->pts[i], backend);
-        }
-        for(i=1; i<= bot->npts-2; i++){
-          OPT_OUTVERT(bot->pts[i], backend);
-        }
-        backend.endtfan();
-        
-        backend.bgntfan();
-        OPT_OUTVERT(bot->pts[bot->npts-2], backend);
-        for(i=0; i<right->npts; i++){
-          OPT_OUTVERT(right->pts[i], backend);
-        }
-        backend.endtfan();
+        backend.bgntfan();
+        OPT_OUTVERT(top->pts[0], backend);//the root
+        for(i=0; i<left->npts; i++){
+          OPT_OUTVERT(left->pts[i], backend);
+        }
+        for(i=1; i<= bot->npts-2; i++){
+          OPT_OUTVERT(bot->pts[i], backend);
+        }
+        backend.endtfan();
+
+        backend.bgntfan();
+        OPT_OUTVERT(bot->pts[bot->npts-2], backend);
+        for(i=0; i<right->npts; i++){
+          OPT_OUTVERT(right->pts[i], backend);
+        }
+        backend.endtfan();
       }
       else if(bot->npts == 2) {
-        backend.bgntfan();
-        OPT_OUTVERT(bot->pts[0], backend);//the root
-        for(i=0; i<right->npts; i++){
-          OPT_OUTVERT(right->pts[i], backend);
-        }
-        for(i=1; i<= top->npts-2; i++){
-          OPT_OUTVERT(top->pts[i], backend);
-        }
-        backend.endtfan();
-        
-        backend.bgntfan();
-        OPT_OUTVERT(top->pts[top->npts-2], backend);
-        for(i=0; i<left->npts; i++){
-          OPT_OUTVERT(left->pts[i], backend);
-        }
-        backend.endtfan();
+        backend.bgntfan();
+        OPT_OUTVERT(bot->pts[0], backend);//the root
+        for(i=0; i<right->npts; i++){
+          OPT_OUTVERT(right->pts[i], backend);
+        }
+        for(i=1; i<= top->npts-2; i++){
+          OPT_OUTVERT(top->pts[i], backend);
+        }
+        backend.endtfan();
+
+        backend.bgntfan();
+        OPT_OUTVERT(top->pts[top->npts-2], backend);
+        for(i=0; i<left->npts; i++){
+          OPT_OUTVERT(left->pts[i], backend);
+        }
+        backend.endtfan();
       }
       else { //both top and bot have >=3 points
-        
-        backend.bgntfan();
-        
-        OPT_OUTVERT(top->pts[top->npts-2], backend);
-        
-        for(i=0; i<=d; i++)
-          {
-            OPT_OUTVERT(left->pts[i], backend); 
-          }
-        backend.endtfan();
-        
-        backend.bgntfan();
-        
-        OPT_OUTVERT(bot->pts[1], backend);
-        
-        OPT_OUTVERT(top->pts[top->npts-2], backend);
-        
-        for(i=d; i< left->npts; i++)
-          {
-            OPT_OUTVERT(left->pts[i], backend);
-          }
-        backend.endtfan();
-
-        d = right->npts/2;
-        //output only when d<right->npts-1 and
-        //
-        if(d<right->npts-1)
-          {     
-            backend.bgntfan();
-            //      backend.tmeshvert(& top->pts[1]);
-            OPT_OUTVERT(top->pts[1], backend);
-            for(i=d; i< right->npts; i++)
-              {
-                //        backend.tmeshvert(& right->pts[i]);
-                
-                OPT_OUTVERT(right->pts[i], backend);
-                
-              }
-            backend.endtfan();
-          }
-        
-        backend.bgntfan();
-        //      backend.tmeshvert(& bot->pts[bot->npts-2]);
-        OPT_OUTVERT( bot->pts[bot->npts-2], backend);
-        for(i=0; i<=d; i++)
-          {
-            //    backend.tmeshvert(& right->pts[i]);
-            OPT_OUTVERT(right->pts[i], backend);
-        
-          }
-        
-        //      backend.tmeshvert(& top->pts[1]);
-        OPT_OUTVERT(top->pts[1], backend);
-        
-        backend.endtfan();
-
-
-        topd_left = top->npts-2;
-        topd_right = 1; //topd_left>= topd_right
-
-        botd_left = 1;
-        botd_right = bot->npts-2; //botd_left<= bot_dright
-
-        
-        if(top->npts < bot->npts)
-          {
-            int delta=bot->npts - top->npts;
-            int u = delta/2;
-            botd_left = 1+ u;
-            botd_right = bot->npts-2-( delta-u);        
-        
-            if(botd_left >1)
-              {
-                backend.bgntfan();
-                //        backend.tmeshvert(& top->pts[top->npts-2]);
-                OPT_OUTVERT(top->pts[top->npts-2], backend);
-                for(i=1; i<= botd_left; i++)
-                  {
-                    //        backend.tmeshvert(& bot->pts[i]);
-                    OPT_OUTVERT(bot->pts[i] , backend);
-                  }
-                backend.endtfan();
-              }
-            if(botd_right < bot->npts-2)
-              {
-                backend.bgntfan();
-                OPT_OUTVERT(top->pts[1], backend);
-                for(i=botd_right; i<= bot->npts-2; i++)
-                  OPT_OUTVERT(bot->pts[i], backend);
-                backend.endtfan();
-              }
-          }
-        else if(top->npts> bot->npts)
-          {
-            int delta=top->npts-bot->npts;
-            int u = delta/2;
-            topd_left = top->npts-2 - u;
-            topd_right = 1+delta-u;
-        
-            if(topd_left < top->npts-2)
-              {
-                backend.bgntfan();
-                //        backend.tmeshvert(& bot->pts[1]);
-                OPT_OUTVERT(bot->pts[1], backend);
-                for(i=topd_left; i<= top->npts-2; i++)
-                  {
-                    //        backend.tmeshvert(& top->pts[i]);
-                    OPT_OUTVERT(top->pts[i], backend);
-                  }
-                backend.endtfan();
-              }
-            if(topd_right > 1)
-              {
-                backend.bgntfan();
-                OPT_OUTVERT(bot->pts[bot->npts-2], backend);
-                for(i=1; i<= topd_right; i++)
-                  OPT_OUTVERT(top->pts[i], backend);
-                backend.endtfan();
-              }
-          }
-        
-        if(topd_left <= topd_right)
-          return;
-
-        backend.bgnqstrip();
-        for(j=botd_left, i=topd_left; i>=topd_right; i--,j++)
-          {
-            //    backend.tmeshvert(& top->pts[i]);
-            //    backend.tmeshvert(& bot->pts[j]);
-            OPT_OUTVERT(top->pts[i], backend);
-            OPT_OUTVERT(bot->pts[j], backend);
-          }
-        backend.endqstrip();
-        
+
+        backend.bgntfan();
+
+        OPT_OUTVERT(top->pts[top->npts-2], backend);
+
+        for(i=0; i<=d; i++)
+          {
+            OPT_OUTVERT(left->pts[i], backend);
+          }
+        backend.endtfan();
+
+        backend.bgntfan();
+
+        OPT_OUTVERT(bot->pts[1], backend);
+
+        OPT_OUTVERT(top->pts[top->npts-2], backend);
+
+        for(i=d; i< left->npts; i++)
+          {
+            OPT_OUTVERT(left->pts[i], backend);
+          }
+        backend.endtfan();
+
+        d = right->npts/2;
+        //output only when d<right->npts-1 and
+        //
+        if(d<right->npts-1)
+          {
+            backend.bgntfan();
+            //      backend.tmeshvert(& top->pts[1]);
+            OPT_OUTVERT(top->pts[1], backend);
+            for(i=d; i< right->npts; i++)
+              {
+                //        backend.tmeshvert(& right->pts[i]);
+
+                OPT_OUTVERT(right->pts[i], backend);
+
+              }
+            backend.endtfan();
+          }
+
+        backend.bgntfan();
+        //      backend.tmeshvert(& bot->pts[bot->npts-2]);
+        OPT_OUTVERT( bot->pts[bot->npts-2], backend);
+        for(i=0; i<=d; i++)
+          {
+            //    backend.tmeshvert(& right->pts[i]);
+            OPT_OUTVERT(right->pts[i], backend);
+
+          }
+
+        //      backend.tmeshvert(& top->pts[1]);
+        OPT_OUTVERT(top->pts[1], backend);
+
+        backend.endtfan();
+
+
+        topd_left = top->npts-2;
+        topd_right = 1; //topd_left>= topd_right
+
+        botd_left = 1;
+        botd_right = bot->npts-2; //botd_left<= bot_dright
+
+
+        if(top->npts < bot->npts)
+          {
+            int delta=bot->npts - top->npts;
+            int u = delta/2;
+            botd_left = 1+ u;
+            botd_right = bot->npts-2-( delta-u);
+
+            if(botd_left >1)
+              {
+                backend.bgntfan();
+                //        backend.tmeshvert(& top->pts[top->npts-2]);
+                OPT_OUTVERT(top->pts[top->npts-2], backend);
+                for(i=1; i<= botd_left; i++)
+                  {
+                    //        backend.tmeshvert(& bot->pts[i]);
+                    OPT_OUTVERT(bot->pts[i] , backend);
+                  }
+                backend.endtfan();
+              }
+            if(botd_right < bot->npts-2)
+              {
+                backend.bgntfan();
+                OPT_OUTVERT(top->pts[1], backend);
+                for(i=botd_right; i<= bot->npts-2; i++)
+                  OPT_OUTVERT(bot->pts[i], backend);
+                backend.endtfan();
+              }
+          }
+        else if(top->npts> bot->npts)
+          {
+            int delta=top->npts-bot->npts;
+            int u = delta/2;
+            topd_left = top->npts-2 - u;
+            topd_right = 1+delta-u;
+
+            if(topd_left < top->npts-2)
+              {
+                backend.bgntfan();
+                //        backend.tmeshvert(& bot->pts[1]);
+                OPT_OUTVERT(bot->pts[1], backend);
+                for(i=topd_left; i<= top->npts-2; i++)
+                  {
+                    //        backend.tmeshvert(& top->pts[i]);
+                    OPT_OUTVERT(top->pts[i], backend);
+                  }
+                backend.endtfan();
+              }
+            if(topd_right > 1)
+              {
+                backend.bgntfan();
+                OPT_OUTVERT(bot->pts[bot->npts-2], backend);
+                for(i=1; i<= topd_right; i++)
+                  OPT_OUTVERT(top->pts[i], backend);
+                backend.endtfan();
+              }
+          }
+
+        if(topd_left <= topd_right)
+          return;
+
+        backend.bgnqstrip();
+        for(j=botd_left, i=topd_left; i>=topd_right; i--,j++)
+          {
+            //    backend.tmeshvert(& top->pts[i]);
+            //    backend.tmeshvert(& bot->pts[j]);
+            OPT_OUTVERT(top->pts[i], backend);
+            OPT_OUTVERT(bot->pts[j], backend);
+          }
+        backend.endqstrip();
+
       }
     }
@@ -573 +573 @@
 
 static void triangulateRectCenter(int n_ulines, REAL* u_val,
-                                  int n_vlines, REAL* v_val,
-                                  Backend& backend)
+                                  int n_vlines, REAL* v_val,
+                                  Backend& backend)
 {
   TrimVertex trimVert;
@@ -580 +580 @@
 
   backend.surfgrid(u_val[0], u_val[n_ulines-1], n_ulines-1,
-                   v_val[n_vlines-1], v_val[0], n_vlines-1);
+                   v_val[n_vlines-1], v_val[0], n_vlines-1);
 
   if(n_ulines>1 && n_vlines>1)
@@ -593 +593 @@
       backend.bgnqstrip();
       for(j=0; j<n_ulines; j++)
-        {
-          trimVert.param[0] = u_val[j];
-          trimVert.param[1] = v_val[i+1];
-          backend.tmeshvert(& trimVert);        
-
-          trimVert.param[1] = v_val[i];
-          backend.tmeshvert(& trimVert);        
-        }
+        {
+          trimVert.param[0] = u_val[j];
+          trimVert.param[1] = v_val[i+1];
+          backend.tmeshvert(& trimVert);
+
+          trimVert.param[1] = v_val[i];
+          backend.tmeshvert(& trimVert);
+        }
       backend.endqstrip();
 
@@ -617 +617 @@
       assert(upper_val);
       if(dir)
-        {
-          for(k=0,i=arc->pwlArc->npts-1; i>=0; i--,k++)
-            {
-              upper_val[k] = arc->pwlArc->pts[i].param[0];
-            }   
-          backend.evalUStrip(arc->pwlArc->npts, arc->pwlArc->pts[0].param[1],
-                             upper_val,
-                             n_ulines, v, u_val);
-        }
+        {
+          for(k=0,i=arc->pwlArc->npts-1; i>=0; i--,k++)
+            {
+              upper_val[k] = arc->pwlArc->pts[i].param[0];
+            }
+          backend.evalUStrip(arc->pwlArc->npts, arc->pwlArc->pts[0].param[1],
+                             upper_val,
+                             n_ulines, v, u_val);
+        }
       else
-        {
-          for(k=0,i=0;  i<arc->pwlArc->npts; i++,k++)
-            {
-              upper_val[k] = arc->pwlArc->pts[i].param[0];
-
-            }           
-
-          backend.evalUStrip(
-                             n_ulines, v, u_val,
-                             arc->pwlArc->npts, arc->pwlArc->pts[0].param[1], upper_val
-                             ); 
-        }
+        {
+          for(k=0,i=0;  i<arc->pwlArc->npts; i++,k++)
+            {
+              upper_val[k] = arc->pwlArc->pts[i].param[0];
+
+            }
+
+          backend.evalUStrip(
+                             n_ulines, v, u_val,
+                             arc->pwlArc->npts, arc->pwlArc->pts[0].param[1], upper_val
+                             );
+        }
 
       free(upper_val);
@@ -649 +649 @@
       assert(left_val);
       if(dir)
-        {
-          for(k=0,i=arc->pwlArc->npts-1; i>=0; i--,k++)
-            {
-              left_val[k] = arc->pwlArc->pts[i].param[1];
-            }
-          backend.evalVStrip(arc->pwlArc->npts, arc->pwlArc->pts[0].param[0],
-                             left_val,
-                             n_ulines, v, u_val);
-        }
+        {
+          for(k=0,i=arc->pwlArc->npts-1; i>=0; i--,k++)
+            {
+              left_val[k] = arc->pwlArc->pts[i].param[1];
+            }
+          backend.evalVStrip(arc->pwlArc->npts, arc->pwlArc->pts[0].param[0],
+                             left_val,
+                             n_ulines, v, u_val);
+        }
       else
-        {
-          for(k=0,i=0;  i<arc->pwlArc->npts; i++,k++)
-            {
-              left_val[k] = arc->pwlArc->pts[i].param[1];
-            }
-           backend.evalVStrip(
-                             n_ulines, v, u_val,
-                             arc->pwlArc->npts, arc->pwlArc->pts[0].param[0], left_val
-                             ); 
-        }
+        {
+          for(k=0,i=0;  i<arc->pwlArc->npts; i++,k++)
+            {
+              left_val[k] = arc->pwlArc->pts[i].param[1];
+            }
+           backend.evalVStrip(
+                             n_ulines, v, u_val,
+                             arc->pwlArc->npts, arc->pwlArc->pts[0].param[0], left_val
+                             );
+        }
       free(left_val);
       return;
     }
-        
+
   //the following is a different version of the above code. If you comment
   //the above code, the following code will still work. The reason to leave
@@ -689 +689 @@
       assert(temp_u_val);
       for(i=0; i<n_ulines; i++)
-        temp_u_val[i] = u_val[n_ulines-1-i];
+        temp_u_val[i] = u_val[n_ulines-1-i];
     }
   u_val = temp_u_val;
@@ -699 +699 @@
       backend.bgntfan();
       if(is_u){
-        trimVert.param[0] = u_val[0];
-        trimVert.param[1] = v;
+        trimVert.param[0] = u_val[0];
+        trimVert.param[1] = v;
       }
       else
-        {
-        trimVert.param[1] = u_val[0];
-        trimVert.param[0] = v;
+        {
+        trimVert.param[1] = u_val[0];
+        trimVert.param[0] = v;
       }
-        
+
       backend.tmeshvert(& trimVert);
       for(i=d1; i< parc->npts; i++)
-        backend.tmeshvert(& parc->pts[i]);
+        backend.tmeshvert(& parc->pts[i]);
       backend.endtfan();
 
@@ -723 +723 @@
       backend.tmeshvert(& parc->pts[parc->npts-1]);
       for(i=0; i<= d2; i++)
-        {
-          if(is_u){
-            trimVert.param[0] = u_val[i];
-            trimVert.param[1] = v;
-          }
-          else
-            {
-              trimVert.param[1] = u_val[i];
-              trimVert.param[0] = v;
-            }
-          backend.tmeshvert(&trimVert);
-        }
+        {
+          if(is_u){
+            trimVert.param[0] = u_val[i];
+            trimVert.param[1] = v;
+          }
+          else
+            {
+              trimVert.param[1] = u_val[i];
+              trimVert.param[0] = v;
+            }
+          backend.tmeshvert(&trimVert);
+        }
       backend.endtfan();
 
@@ -744 +744 @@
     for(i=d1, j=d2; i>=0; i--, j++)
       {
-        backend.tmeshvert(& parc->pts[i]);
-
-        if(is_u){
-          trimVert.param[0] = u_val[j];
-          trimVert.param[1] = v;
-        }
-        else{
-          trimVert.param[1] = u_val[j];
-          trimVert.param[0] = v;
-        }
-        backend.tmeshvert(&trimVert);
-
-
-        
+        backend.tmeshvert(& parc->pts[i]);
+
+        if(is_u){
+          trimVert.param[0] = u_val[j];
+          trimVert.param[1] = v;
+        }
+        else{
+          trimVert.param[1] = u_val[j];
+          trimVert.param[0] = v;
+        }
+        backend.tmeshvert(&trimVert);
+
+
+
       }
     backend.endqstrip();
@@ -781 +781 @@
 
       if(loop->tail()[1] > loop->prev->prev->tail()[1])
-        {
-
-        top = loop;
-        }
+        {
+
+        top = loop;
+        }
       else{
 
-        top = loop->prev->prev;
-        }
+        top = loop->prev->prev;
+        }
     }
   else
     {
       if(loop->tail()[0] > loop->prev->prev->tail()[0])
-        {
-          //loop is the right arc
-
-          top = loop->next;
-        }
+        {
+          //loop is the right arc
+
+          top = loop->next;
+        }
       else
-        {
-
-          top = loop->prev;
-        }
+        {
+
+          top = loop->prev;
+        }
     }
 
@@ -813 +813 @@
                  left->pwlArc->npts +
                  bot->pwlArc->npts +
-                  right->pwlArc->npts
-                      + 2*n_ulines + 2*n_vlines
-                        -8;
+                  right->pwlArc->npts
+                      + 2*n_ulines + 2*n_vlines
+                        -8;
   num_quads += (n_ulines-1)*(n_vlines-1);
 #endif
 /*
   backend.surfgrid(left->tail()[0], right->tail()[0], n_ulines+1,
-                   top->tail()[1], bot->tail()[1], n_vlines+1);
+                   top->tail()[1], bot->tail()[1], n_vlines+1);
 //  if(n_ulines>1 && n_vlines>1)
     backend.surfmesh(0,0,n_ulines+1,n_vlines+1);
@@ -911 +911 @@
       directedLine *dline = arcToDLine(arc);
       if(ret == NULL)
-        ret = dline;
+        ret = dline;
       else
-        ret->insert(dline);
+        ret->insert(dline);
       return ret;
     }
@@ -919 +919 @@
     {
       for(Int i=0; i<arc->pwlArc->npts-1; i++)
-        {
-          Real vert[2][2];
-          vert[0][0] = arc->pwlArc->pts[i].param[0];
-          vert[0][1] = arc->pwlArc->pts[i].param[1];
-          vert[1][0] = arc->pwlArc->pts[i+1].param[0];
-          vert[1][1] = arc->pwlArc->pts[i+1].param[1];
-        
-          sampledLine *sline = new sampledLine(2, vert);
-          directedLine *dline = new directedLine(INCREASING, sline);
-          if(ret == NULL)
-            ret = dline;
-          else
-            ret->insert(dline);
-        }
+        {
+          Real vert[2][2];
+          vert[0][0] = arc->pwlArc->pts[i].param[0];
+          vert[0][1] = arc->pwlArc->pts[i].param[1];
+          vert[1][0] = arc->pwlArc->pts[i+1].param[0];
+          vert[1][1] = arc->pwlArc->pts[i+1].param[1];
+
+          sampledLine *sline = new sampledLine(2, vert);
+          directedLine *dline = new directedLine(INCREASING, sline);
+          if(ret == NULL)
+            ret = dline;
+          else
+            ret->insert(dline);
+        }
       return ret;
     }
@@ -938 +938 @@
 
 
-        
+
 directedLine* arcLoopToDLineLoop(Arc_ptr loop)
 {
@@ -970 +970 @@
       rectBlock* block = rbArray->get_element(l);
       for(k=0, i=block->get_upGridLineIndex(); i>block->get_lowGridLineIndex(); i--, k++)
-        {
-
-          backend.bgnqstrip();
-          for(j=block->get_leftIndices()[k+1]; j<= block->get_rightIndices()[k+1]; j++)
-            {
-              trimVert->param[0] = u_values[j];
-              trimVert->param[1] = v_values[i];
-              backend.tmeshvert(trimVert);
-
-              trimVert->param[1] = v_values[i-1];
-              backend.tmeshvert(trimVert);
-
-            }
-          backend.endqstrip();
-
-        }
+        {
+
+          backend.bgnqstrip();
+          for(j=block->get_leftIndices()[k+1]; j<= block->get_rightIndices()[k+1]; j++)
+            {
+              trimVert->param[0] = u_values[j];
+              trimVert->param[1] = v_values[i];
+              backend.tmeshvert(trimVert);
+
+              trimVert->param[1] = v_values[i-1];
+              backend.tmeshvert(trimVert);
+
+            }
+          backend.endqstrip();
+
+        }
     }
 
@@ -1001 +1001 @@
   //we need counter-clockwise.
   backend.surfgrid(grid->get_u_min(), grid->get_u_max(), grid->get_n_ulines()-1,
-                   grid->get_v_max(), grid->get_v_min(), n_vlines-1);
+                   grid->get_v_max(), grid->get_v_min(), n_vlines-1);
 
 
@@ -1011 +1011 @@
 
       for(k=0, i=high; i>low; i--, k++)
-        {
-          backend.surfmesh(block->get_leftIndices()[k+1], n_vlines-1-i, block->get_rightIndices()[k+1]-block->get_leftIndices()[k+1], 1);
-        }
+        {
+          backend.surfmesh(block->get_leftIndices()[k+1], n_vlines-1-i, block->get_rightIndices()[k+1]-block->get_leftIndices()[k+1], 1);
+        }
     }
 }
@@ -1033 +1033 @@
       case PRIMITIVE_STREAM_FAN:
 
-        backend.bgntfan();
-
-        for(j=0; j<pStream->get_length(i); j++)
-          {     
-            trimVert->param[0] = vertices[k];
-            trimVert->param[1] = vertices[k+1];
-            backend.tmeshvert(trimVert);        
-        
-//          backend.tmeshvert(vertices[k], vertices[k+1]);
-            k += 2;
-          }
-        backend.endtfan();
-        break;
-        
+        backend.bgntfan();
+
+        for(j=0; j<pStream->get_length(i); j++)
+          {
+            trimVert->param[0] = vertices[k];
+            trimVert->param[1] = vertices[k+1];
+            backend.tmeshvert(trimVert);
+
+//          backend.tmeshvert(vertices[k], vertices[k+1]);
+            k += 2;
+          }
+        backend.endtfan();
+        break;
+
       default:
-        fprintf(stderr, "evalStream: not implemented yet\n");
-        exit(1);
+        fprintf(stderr, "evalStream: not implemented yet\n");
+        exit(1);
 
       }
@@ -1055 +1055 @@
   free(trimVert);
 }
-        
-        
-        
+
+
+
 
 void Slicer::slice_new(Arc_ptr loop)
@@ -1107 +1107 @@
     {
       if(vlinear)
-        triangulateRect(loop, backend, 1, ulinear, vlinear);
+        triangulateRect(loop, backend, 1, ulinear, vlinear);
       else if(ulinear)
-        triangulateRect(loop, backend, -1, ulinear, vlinear);   
+        triangulateRect(loop, backend, -1, ulinear, vlinear);
       else
-        triangulateRect(loop, backend, 0, ulinear, vlinear);            
+        triangulateRect(loop, backend, 0, ulinear, vlinear);
     }
 
@@ -1151 +1151 @@
   printf("num_quads = %i\n", num_quads);
 #endif
+
 }
 
@@ -1170 +1171 @@
 
 Slicer::Slicer( Backend &b )
-        : CoveAndTiler( b ), Mesher( b ), backend( b )
+        : CoveAndTiler( b ), Mesher( b ), backend( b )
 {
     ulinear = 0;
@@ -1219 +1220 @@
 
     for( long quad=0; quad<varray.numquads; quad++ ) {
-        backend.surfgrid( uarray.uarray[0],
-                       uarray.uarray[ulines-1],
-                       ulines-1,
-                       varray.vval[quad],
-                       varray.vval[quad+1],
-                       varray.voffset[quad+1] - varray.voffset[quad] );
-
-        for( long i=varray.voffset[quad]+1; i <= varray.voffset[quad+1]; i++ ) {
-            topv = botv++;
-            advance( topv - varray.voffset[quad],
-                     botv - varray.voffset[quad],
-                     varray.varray[botv] );
-            if( i == vlines )
-                getPts( extrema[2] );
-            else
-                getPts( backend );
-            getGridExtent();
+        backend.surfgrid( uarray.uarray[0],
+                       uarray.uarray[ulines-1],
+                       ulines-1,
+                       varray.vval[quad],
+                       varray.vval[quad+1],
+                       varray.voffset[quad+1] - varray.voffset[quad] );
+
+        for( long i=varray.voffset[quad]+1; i <= varray.voffset[quad+1]; i++ ) {
+            topv = botv++;
+            advance( topv - varray.voffset[quad],
+                     botv - varray.voffset[quad],
+                     varray.varray[botv] );
+            if( i == vlines )
+                getPts( extrema[2] );
+            else
+                getPts( backend );
+            getGridExtent();
             if( isolines ) {
-                outline();
-            } else {
-                if( canTile() )
-                    coveAndTile();
-                else
-                    mesh();
-            }
+                outline();
+            } else {
+                if( canTile() )
+                    coveAndTile();
+                else
+                    mesh();
+            }
         }
    }
@@ -1257 +1258 @@
     backend.bgnoutline();
     while( (nextupper( &upper )) ) {
-        if( upper.isGridVert() )
-            backend.linevert( upper.g );
-        else
-            backend.linevert( upper.t );
+        if( upper.isGridVert() )
+            backend.linevert( upper.g );
+        else
+            backend.linevert( upper.t );
     }
     backend.endoutline();
@@ -1266 +1267 @@
     backend.bgnoutline();
     while( (nextlower( &lower )) ) {
-        if( lower.isGridVert() )
-            backend.linevert( lower.g );
-        else
-            backend.linevert( lower.t );
+        if( lower.isGridVert() )
+            backend.linevert( lower.g );
+        else
+            backend.linevert( lower.t );
     }
     backend.endoutline();
@@ -1281 +1282 @@
 
     if( jarc->pwlArc->npts >= 2 ) {
-        backend.bgnoutline();
-        for( int j = jarc->pwlArc->npts-1; j >= 0; j--  )
-            backend.linevert( &(jarc->pwlArc->pts[j]) );
-        backend.endoutline();
-    }
-}
-
-
+        backend.bgnoutline();
+        for( int j = jarc->pwlArc->npts-1; j >= 0; j--  )
+            backend.linevert( &(jarc->pwlArc->pts[j]) );
+        backend.endoutline();
+    }
+}
+
+

trunk/src/opengl/glu/tess/tess.c

@@ -1 @@
-/* $Id: tess.c,v 1.1 2000-02-09 08:47:38 jeroen Exp $ */
+/* $Id: tess.c,v 1.2 2000-03-11 09:05:04 jeroen Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
@@ -37 +37 @@
 ** Author: Eric Veach, July 1994.
 **
-** $Date: 2000-02-09 08:47:38 $ $Revision: 1.1 $
-** $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/tess/tess.c,v 1.1 2000-02-09 08:47:38 jeroen Exp $
+** $Date: 2000-03-11 09:05:04 $ $Revision: 1.2 $
+** $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/tess/tess.c,v 1.2 2000-03-11 09:05:04 jeroen Exp $
 */
 
@@ -59 +59 @@
 #define FALSE 0
 
-/*ARGSUSED*/ static void GLAPI noBegin( GLenum type ) {}
-/*ARGSUSED*/ static void GLAPI noEdgeFlag( GLboolean boundaryEdge ) {}
-/*ARGSUSED*/ static void GLAPI noVertex( void *data ) {}
-/*ARGSUSED*/ static void GLAPI noEnd( void ) {}
-/*ARGSUSED*/ static void GLAPI noError( GLenum errnum ) {}
-/*ARGSUSED*/ static void GLAPI noCombine( GLdouble coords[3], void *data[4],
+/*ARGSUSED*/ static void GLCALLBACK noBegin( GLenum type ) {}
+/*ARGSUSED*/ static void GLCALLBACK noEdgeFlag( GLboolean boundaryEdge ) {}
+/*ARGSUSED*/ static void GLCALLBACK noVertex( void *data ) {}
+/*ARGSUSED*/ static void GLCALLBACK noEnd( void ) {}
+/*ARGSUSED*/ static void GLCALLBACK noError( GLenum errnum ) {}
+/*ARGSUSED*/ static void GLCALLBACK noCombine( GLdouble coords[3], void *data[4],
                                     GLfloat weight[4], void **dataOut ) {}
-/*ARGSUSED*/ static void GLAPI noMesh( GLUmesh *mesh ) {}
-
-
-/*ARGSUSED*/ void GLAPI __gl_noBeginData( GLenum type,
+/*ARGSUSED*/ static void GLCALLBACK noMesh( GLUmesh *mesh ) {}
+
+
+/*ARGSUSED*/ void __gl_noBeginData( GLenum type,
                                              void *polygonData ) {}
-/*ARGSUSED*/ void GLAPI __gl_noEdgeFlagData( GLboolean boundaryEdge,
+/*ARGSUSED*/ void __gl_noEdgeFlagData( GLboolean boundaryEdge,
                                        void *polygonData ) {}
-/*ARGSUSED*/ void GLAPI __gl_noVertexData( void *data,
+/*ARGSUSED*/ void __gl_noVertexData( void *data,
                                               void *polygonData ) {}
-/*ARGSUSED*/ void GLAPI __gl_noEndData( void *polygonData ) {}
-/*ARGSUSED*/ void GLAPI __gl_noErrorData( GLenum errnum,
+/*ARGSUSED*/ void __gl_noEndData( void *polygonData ) {}
+/*ARGSUSED*/ void __gl_noErrorData( GLenum errnum,
                                              void *polygonData ) {}
-/*ARGSUSED*/ void GLAPI __gl_noCombineData( GLdouble coords[3],
+/*ARGSUSED*/ void __gl_noCombineData( GLdouble coords[3],
                                                void *data[4],
                                                GLfloat weight[4],
@@ -105 +105 @@
 
   if (memInit( MAX_FAST_ALLOC ) == 0) {
-     return 0;                  /* out of memory */
+     return 0;                  /* out of memory */
   }
   tess = (GLUtesselator *)memAlloc( sizeof( GLUtesselator ));
   if (tess == NULL) {
-     return 0;                  /* out of memory */
+     return 0;                  /* out of memory */
   }
 
@@ -167 +167 @@
       switch( tess->state ) {
       case T_DORMANT:
-        CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_BEGIN_POLYGON );
-        gluTessBeginPolygon( tess, NULL );
-        break;
+        CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_BEGIN_POLYGON );
+        gluTessBeginPolygon( tess, NULL );
+        break;
       case T_IN_POLYGON:
-        CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_BEGIN_CONTOUR );
-        gluTessBeginContour( tess );
-        break;
+        CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_BEGIN_CONTOUR );
+        gluTessBeginContour( tess );
+        break;
       }
     } else {
       switch( tess->state ) {
       case T_IN_CONTOUR:
-        CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_END_CONTOUR );
-        gluTessEndContour( tess );
-        break;
+        CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_END_CONTOUR );
+        gluTessEndContour( tess );
+        break;
       case T_IN_POLYGON:
-        CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_END_POLYGON );
-        /* gluTessEndPolygon( tess ) is too much work! */
-        MakeDormant( tess );
-        break;
+        CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_END_POLYGON );
+        /* gluTessEndPolygon( tess ) is too much work! */
+        MakeDormant( tess );
+        break;
       }
     }
@@ -192 +192 @@
 
 
-void GLAPI
+GLUAPI void GLAPIENTRY
 gluDeleteTess( GLUtesselator *tess )
 {
@@ -200 +200 @@
 
 
-void GLAPI
+GLUAPI void GLAPIENTRY
 gluTessProperty( GLUtesselator *tess, GLenum which, GLdouble value )
 {
@@ -213 +213 @@
   case GLU_TESS_WINDING_RULE:
     windingRule = (GLenum) value;
-    if( windingRule != value ) break;   /* not an integer */
+    if( windingRule != value ) break;   /* not an integer */
 
     switch( windingRule ) {
@@ -239 +239 @@
 
 /* Returns tessellator property */
-void GLAPI
+GLUAPI void GLAPIENTRY
 gluGetTessProperty( GLUtesselator *tess, GLenum which, GLdouble *value )
 {
@@ -250 +250 @@
    case GLU_TESS_WINDING_RULE:
       assert(tess->windingRule == GLU_TESS_WINDING_ODD ||
-             tess->windingRule == GLU_TESS_WINDING_NONZERO ||
-             tess->windingRule == GLU_TESS_WINDING_POSITIVE ||
-             tess->windingRule == GLU_TESS_WINDING_NEGATIVE ||
-             tess->windingRule == GLU_TESS_WINDING_ABS_GEQ_TWO);
+             tess->windingRule == GLU_TESS_WINDING_NONZERO ||
+             tess->windingRule == GLU_TESS_WINDING_POSITIVE ||
+             tess->windingRule == GLU_TESS_WINDING_NEGATIVE ||
+             tess->windingRule == GLU_TESS_WINDING_ABS_GEQ_TWO);
       *value= tess->windingRule;
       break;
@@ -267 +267 @@
 } /* gluGetTessProperty() */
 
-void GLAPI
+GLUAPI void GLAPIENTRY
 gluTessNormal( GLUtesselator *tess, GLdouble x, GLdouble y, GLdouble z )
 {
@@ -275 +275 @@
 }
 
-void GLAPI
-gluTessCallback( GLUtesselator *tess, GLenum which, void (GLAPI *fn)())
+GLUAPI void GLAPIENTRY
+gluTessCallback( GLUtesselator *tess, GLenum which, void (GLCALLBACK *fn)())
 {
   switch( which ) {
   case GLU_TESS_BEGIN:
-    tess->callBegin = (fn == NULL) ? &noBegin : (void (GLAPI *)(GLenum)) fn;
+    tess->callBegin = (fn == NULL) ? &noBegin : (void (GLCALLBACK *)(GLenum)) fn;
     return;
   case GLU_TESS_BEGIN_DATA:
     tess->callBeginData = (fn == NULL) ?
-        &__gl_noBeginData : (void (GLAPI *)(GLenum, void *)) fn;
+        &__gl_noBeginData : (void (GLCALLBACK *)(GLenum, void *)) fn;
     return;
   case GLU_TESS_EDGE_FLAG:
     tess->callEdgeFlag = (fn == NULL) ? &noEdgeFlag :
-                                        (void (GLAPI *)(GLboolean)) fn;
+                                        (void (GLCALLBACK *)(GLboolean)) fn;
     /* If the client wants boundary edges to be flagged,
      * we render everything as separate triangles (no strips or fans).
@@ -296 +296 @@
   case GLU_TESS_EDGE_FLAG_DATA:
     tess->callEdgeFlagData= (fn == NULL) ?
-        &__gl_noEdgeFlagData : (void (GLAPI *)(GLboolean, void *)) fn;
+        &__gl_noEdgeFlagData : (void (GLCALLBACK *)(GLboolean, void *)) fn;
     /* If the client wants boundary edges to be flagged,
      * we render everything as separate triangles (no strips or fans).
@@ -304 +304 @@
   case GLU_TESS_VERTEX:
     tess->callVertex = (fn == NULL) ? &noVertex :
-                                      (void (GLAPI *)(void *)) fn;
+                                      (void (GLCALLBACK *)(void *)) fn;
     return;
   case GLU_TESS_VERTEX_DATA:
     tess->callVertexData = (fn == NULL) ?
-        &__gl_noVertexData : (void (GLAPI *)(void *, void *)) fn;
+        &__gl_noVertexData : (void (GLCALLBACK *)(void *, void *)) fn;
     return;
   case GLU_TESS_END:
-    tess->callEnd = (fn == NULL) ? &noEnd : (void (GLAPI *)(void)) fn;
+    tess->callEnd = (fn == NULL) ? &noEnd : (void (GLCALLBACK *)(void)) fn;
     return;
   case GLU_TESS_END_DATA:
     tess->callEndData = (fn == NULL) ? &__gl_noEndData :
-                                       (void (GLAPI *)(void *)) fn;
+                                       (void (GLCALLBACK *)(void *)) fn;
     return;
   case GLU_TESS_ERROR:
-    tess->callError = (fn == NULL) ? &noError : (void (GLAPI *)(GLenum)) fn;
+    tess->callError = (fn == NULL) ? &noError : (void (GLCALLBACK *)(GLenum)) fn;
     return;
   case GLU_TESS_ERROR_DATA:
     tess->callErrorData = (fn == NULL) ?
-        &__gl_noErrorData : (void (GLAPI *)(GLenum, void *)) fn;
+        &__gl_noErrorData : (void (GLCALLBACK *)(GLenum, void *)) fn;
     return;
   case GLU_TESS_COMBINE:
     tess->callCombine = (fn == NULL) ? &noCombine :
-        (void (GLAPI *)(GLdouble [3],void *[4], GLfloat [4], void ** )) fn;
+        (void (GLCALLBACK *)(GLdouble [3],void *[4], GLfloat [4], void ** )) fn;
     return;
   case GLU_TESS_COMBINE_DATA:
     tess->callCombineData = (fn == NULL) ? &__gl_noCombineData :
-                                           (void (GLAPI *)(GLdouble [3],
-                                                     void *[4],
-                                                     GLfloat [4],
-                                                     void **,
-                                                     void *)) fn;
+                                           (void (GLCALLBACK *)(GLdouble [3],
+                                                     void *[4],
+                                                     GLfloat [4],
+                                                     void **,
+                                                     void *)) fn;
     return;
   case GLU_TESS_MESH:
-    tess->callMesh = (fn == NULL) ? &noMesh : (void (GLAPI *)(GLUmesh *)) fn;
+    tess->callMesh = (fn == NULL) ? &noMesh : (void (GLCALLBACK *)(GLUmesh *)) fn;
     return;
   default:
@@ -414 +414 @@
 
 
-void GLAPI
+GLUAPI void GLAPIENTRY
 gluTessVertex( GLUtesselator *tess, GLdouble coords[3], void *data )
 {
@@ -461 +461 @@
 
 
-void GLAPI
+GLUAPI void GLAPIENTRY
 gluTessBeginPolygon( GLUtesselator *tess, void *data )
 {
@@ -475 +475 @@
 
 
-void GLAPI
+GLUAPI void GLAPIENTRY
 gluTessBeginContour( GLUtesselator *tess )
 {
@@ -492 +492 @@
 
 
-void GLAPI
+GLUAPI void GLAPIENTRY
 gluTessEndContour( GLUtesselator *tess )
 {
@@ -499 +499 @@
 }
 
-void GLAPI
+GLUAPI void GLAPIENTRY
 gluTessEndPolygon( GLUtesselator *tess )
 {
   GLUmesh *mesh;
 
-  if (setjmp(tess->env) != 0) { 
+  if (setjmp(tess->env) != 0) {
      /* come back here if out of memory */
      CALL_ERROR_OR_ERROR_DATA( GLU_OUT_OF_MEMORY );
@@ -522 +522 @@
        */
       if( __gl_renderCache( tess )) {
-        tess->polygonData= NULL;
-        return;
+        tess->polygonData= NULL;
+        return;
       }
     }
@@ -541 +541 @@
    */
   if ( !__gl_computeInterior( tess ) ) {
-     longjmp(tess->env,1);      /* could've used a label */
+     longjmp(tess->env,1);      /* could've used a label */
   }
 
@@ -557 +557 @@
       rc = __gl_meshTessellateInterior( mesh );
     }
-    if (rc == 0) longjmp(tess->env,1);  /* could've used a label */
+    if (rc == 0) longjmp(tess->env,1);  /* could've used a label */
 
     __gl_meshCheckMesh( mesh );
@@ -569 +569 @@
     {
       if( tess->boundaryOnly ) {
-        __gl_renderBoundary( tess, mesh );  /* output boundary contours */
+        __gl_renderBoundary( tess, mesh );  /* output boundary contours */
       } else {
-        __gl_renderMesh( tess, mesh );     /* output strips and fans */
+        __gl_renderMesh( tess, mesh );     /* output strips and fans */
       }
     }
@@ -583 +583 @@
        */
       __gl_meshDiscardExterior( mesh );
-      (*tess->callMesh)( mesh );                /* user wants the mesh itself */
+      (*tess->callMesh)( mesh );                /* user wants the mesh itself */
       tess->mesh = NULL;
       tess->polygonData= NULL;
@@ -595 +595 @@
 
 
-void GLAPI
+GLUAPI void GLAPIENTRY
 gluDeleteMesh( GLUmesh *mesh )
 {
@@ -607 +607 @@
 /* Obsolete calls -- for backward compatibility */
 
-void GLAPI
+GLUAPI void GLAPIENTRY
 gluBeginPolygon( GLUtesselator *tess )
 {
@@ -616 +616 @@
 
 /*ARGSUSED*/
-void GLAPI
+GLUAPI void GLAPIENTRY
 gluNextContour( GLUtesselator *tess, GLenum type )
 {
@@ -624 +624 @@
 
 
-void GLAPI
+GLUAPI void GLAPIENTRY
 gluEndPolygon( GLUtesselator *tess )
 {

trunk/src/opengl/glu/tess/tess.h

@@ -1 @@
-/* $Id: tess.h,v 1.1 2000-02-09 08:47:38 jeroen Exp $ */
+/* $Id: tess.h,v 1.2 2000-03-11 09:05:04 jeroen Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
@@ -37 +37 @@
 ** Author: Eric Veach, July 1994.
 **
-** $Date: 2000-02-09 08:47:38 $ $Revision: 1.1 $
-** $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/tess/tess.h,v 1.1 2000-02-09 08:47:38 jeroen Exp $
+** $Date: 2000-03-11 09:05:04 $ $Revision: 1.2 $
+** $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/tess/tess.h,v 1.2 2000-03-11 09:05:04 jeroen Exp $
 */
 
@@ -58 +58 @@
  * try a quick-and-dirty decomposition first.
  */
-#define TESS_MAX_CACHE  100
+#define TESS_MAX_CACHE  100
 
 typedef struct CachedVertex {
-  GLdouble      coords[3];
-  void          *data;
+  GLdouble      coords[3];
+  void          *data;
 } CachedVertex;
 
@@ -69 +69 @@
   /*** state needed for collecting the input data ***/
 
-  enum TessState state;         /* what begin/end calls have we seen? */
+  enum TessState state;         /* what begin/end calls have we seen? */
 
-  GLUhalfEdge   *lastEdge;      /* lastEdge->Org is the most recent vertex */
-  GLUmesh       *mesh;          /* stores the input contours, and eventually
+  GLUhalfEdge   *lastEdge;      /* lastEdge->Org is the most recent vertex */
+  GLUmesh       *mesh;          /* stores the input contours, and eventually
                                    the tessellation itself */
 
-  void          (GLAPI *callError)( GLenum errnum );
+  void          (GLCALLBACK *callError)( GLenum errnum );
 
   /*** state needed for projecting onto the sweep plane ***/
 
-  GLdouble      normal[3];      /* user-specified normal (if provided) */
-  GLdouble      sUnit[3];       /* unit vector in s-direction (debugging) */
-  GLdouble      tUnit[3];       /* unit vector in t-direction (debugging) */
+  GLdouble      normal[3];      /* user-specified normal (if provided) */
+  GLdouble      sUnit[3];       /* unit vector in s-direction (debugging) */
+  GLdouble      tUnit[3];       /* unit vector in t-direction (debugging) */
 
   /*** state needed for the line sweep ***/
 
-  GLdouble      relTolerance;   /* tolerance for merging features */
-  GLenum        windingRule;    /* rule for determining polygon interior */
-  GLboolean     fatalError;     /* fatal error: needed combine callback */
+  GLdouble      relTolerance;   /* tolerance for merging features */
+  GLenum        windingRule;    /* rule for determining polygon interior */
+  GLboolean     fatalError;     /* fatal error: needed combine callback */
 
-  Dict          *dict;          /* edge dictionary for sweep line */
-  PriorityQ     *pq;            /* priority queue of vertex events */
-  GLUvertex     *event;         /* current sweep event being processed */
+  Dict          *dict;          /* edge dictionary for sweep line */
+  PriorityQ     *pq;            /* priority queue of vertex events */
+  GLUvertex     *event;         /* current sweep event being processed */
 
-  void          (GLAPI *callCombine)( GLdouble coords[3], void *data[4],
-                                GLfloat weight[4], void **outData );
+  void          (GLCALLBACK *callCombine)( GLdouble coords[3], void *data[4],
+                                GLfloat weight[4], void **outData );
 
   /*** state needed for rendering callbacks (see render.c) ***/
 
-  GLboolean     flagBoundary;   /* mark boundary edges (use EdgeFlag) */
-  GLboolean     boundaryOnly;   /* Extract contours, not triangles */
-  GLUface       *lonelyTriList;
+  GLboolean     flagBoundary;         /* mark boundary edges (use EdgeFlag)*/
+  GLboolean     boundaryOnly;          /* Extract contours, not triangles  */
+  GLUface       *lonelyTriList;
     /* list of triangles which could not be rendered as strips or fans */
 
-  void          (GLAPI *callBegin)( GLenum type );
-  void          (GLAPI *callEdgeFlag)( GLboolean boundaryEdge );
-  void          (GLAPI *callVertex)( void *data );
-  void          (GLAPI *callEnd)( void );
-  void          (GLAPI *callMesh)( GLUmesh *mesh );
+  void          (GLCALLBACK *callBegin)( GLenum type );
+  void          (GLCALLBACK *callEdgeFlag)( GLboolean boundaryEdge );
+  void          (GLCALLBACK *callVertex)( void *data );
+  void          (GLCALLBACK *callEnd)( void );
+  void          (GLCALLBACK *callMesh)( GLUmesh *mesh );
 
 
   /*** state needed to cache single-contour polygons for renderCache() */
 
-  GLboolean     emptyCache;             /* empty cache on next vertex() call */
-  int           cacheCount;             /* number of cached vertices */
-  CachedVertex  cache[TESS_MAX_CACHE];  /* the vertex data */
+  GLboolean     emptyCache;            /* empty cache on next vertex() call*/
+  int           cacheCount;            /* number of cached vertices        */
+  CachedVertex  cache[TESS_MAX_CACHE]; /* the vertex data                  */
 
   /*** rendering callbacks that also pass polygon data  ***/
-  void          (GLAPI *callBeginData)( GLenum type, void *polygonData );
-  void          (GLAPI *callEdgeFlagData)( GLboolean boundaryEdge,
-                                     void *polygonData );
-  void          (GLAPI *callVertexData)( void *data, void *polygonData );
-  void          (GLAPI *callEndData)( void *polygonData );
-  void          (GLAPI *callErrorData)( GLenum errnum, void *polygonData );
-  void          (GLAPI *callCombineData)( GLdouble coords[3], void *data[4],
-                                    GLfloat weight[4], void **outData,
-                                    void *polygonData );
+  void          (GLCALLBACK *callBeginData)( GLenum type, void *polygonData );
+  void          (GLCALLBACK *callEdgeFlagData)( GLboolean boundaryEdge,
+                                     void *polygonData );
+  void          (GLCALLBACK *callVertexData)( void *data, void *polygonData );
+  void          (GLCALLBACK *callEndData)( void *polygonData );
+  void          (GLCALLBACK *callErrorData)( GLenum errnum, void *polygonData );
+  void          (GLCALLBACK *callCombineData)( GLdouble coords[3], void *data[4],
+                                    GLfloat weight[4], void **outData,
+                                    void *polygonData );
 
-  jmp_buf env;                  /* place to jump to when memAllocs fail */
+  jmp_buf env;                      /* place to jump to when memAllocs fail*/
 
-  void *polygonData;            /* client data for current polygon */
+  void *polygonData;                     /* client data for current polygon*/
 };
 
-void GLAPI __gl_noBeginData( GLenum type, void *polygonData );
-void GLAPI __gl_noEdgeFlagData( GLboolean boundaryEdge, void *polygonData );
-void GLAPI __gl_noVertexData( void *data, void *polygonData );
-void GLAPI __gl_noEndData( void *polygonData );
-void GLAPI __gl_noErrorData( GLenum errnum, void *polygonData );
-void GLAPI __gl_noCombineData( GLdouble coords[3], void *data[4],
-                         GLfloat weight[4], void **outData,
-                         void *polygonData );
+void GLCALLBACK __gl_noBeginData( GLenum type, void *polygonData );
+void GLCALLBACK __gl_noEdgeFlagData( GLboolean boundaryEdge, void *polygonData );
+void GLCALLBACK __gl_noVertexData( void *data, void *polygonData );
+void GLCALLBACK __gl_noEndData( void *polygonData );
+void GLCALLBACK __gl_noErrorData( GLenum errnum, void *polygonData );
+void GLCALLBACK __gl_noCombineData( GLdouble coords[3], void *data[4],
+                         GLfloat weight[4], void **outData,
+                         void *polygonData );
 
 #define CALL_BEGIN_OR_BEGIN_DATA(a) \

trunk/src/opengl/glu/util/quad.c

@@ -1 @@
-/* $Id: quad.c,v 1.1 2000-02-09 08:47:14 jeroen Exp $ */
+/* $Id: quad.c,v 1.2 2000-03-11 09:05:04 jeroen Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
@@ -33 +33 @@
 ** compliant with the OpenGL(R) version 1.2.1 Specification.
 **
-** $Date: 2000-02-09 08:47:14 $ $Revision: 1.1 $
-** $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/util/quad.c,v 1.1 2000-02-09 08:47:14 jeroen Exp $
+** $Date: 2000-03-11 09:05:04 $ $Revision: 1.2 $
+** $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/util/quad.c,v 1.2 2000-03-11 09:05:04 jeroen Exp $
 */
 
@@ -55 +55 @@
     GLint       orientation;
     GLint       drawStyle;
-    void        (GLAPI *errorCallback)( GLint );
+    void        (GLCALLBACK *errorCallback)( GLint );
 };
 
@@ -65 +65 @@
     newstate = (GLUquadric *) malloc(sizeof(GLUquadric));
     if (newstate == NULL) {
-        /* Can't report an error at this point... */
-        return NULL;
+        /* Can't report an error at this point... */
+        return NULL;
     }
     newstate->normals = GLU_SMOOTH;
@@ -86 +86 @@
 {
     if (qobj->errorCallback) {
-        qobj->errorCallback(which);
+        qobj->errorCallback(which);
     }
 }
 
 void GLAPI
-gluQuadricCallback(GLUquadric *qobj, GLenum which, void (GLAPI *fn)())
+gluQuadricCallback(GLUquadric *qobj, GLenum which, void (GLCALLBACK *fn)())
 {
     switch (which) {
       case GLU_ERROR:
-        qobj->errorCallback = (void (GLAPI *)(GLint)) fn;
-        break;
+        qobj->errorCallback = (void (GLCALLBACK *)(GLint)) fn;
+        break;
       default:
-        gluQuadricError(qobj, GLU_INVALID_ENUM);
-        return;
+        gluQuadricError(qobj, GLU_INVALID_ENUM);
+        return;
     }
 }
@@ -110 +110 @@
       case GLU_FLAT:
       case GLU_NONE:
-        break;
+        break;
       default:
-        gluQuadricError(qobj, GLU_INVALID_ENUM);
-        return;
+        gluQuadricError(qobj, GLU_INVALID_ENUM);
+        return;
     }
     qobj->normals = normals;
@@ -130 +130 @@
       case GLU_OUTSIDE:
       case GLU_INSIDE:
-        break;
+        break;
       default:
-        gluQuadricError(qobj, GLU_INVALID_ENUM);
-        return;
+        gluQuadricError(qobj, GLU_INVALID_ENUM);
+        return;
     }
     qobj->orientation = orientation;
@@ -146 +146 @@
       case GLU_FILL:
       case GLU_SILHOUETTE:
-        break;
+        break;
       default:
-        gluQuadricError(qobj, GLU_INVALID_ENUM);
-        return;
+        gluQuadricError(qobj, GLU_INVALID_ENUM);
+        return;
     }
     qobj->drawStyle = drawStyle;
@@ -156 +156 @@
 void GLAPI
 gluCylinder(GLUquadric *qobj, GLdouble baseRadius, GLdouble topRadius,
-                GLdouble height, GLint slices, GLint stacks)
+                GLdouble height, GLint slices, GLint stacks)
 {
     GLint i,j,max;
@@ -178 +178 @@
 
     if (slices < 2 || stacks < 1 || baseRadius < 0.0 || topRadius < 0.0 ||
-            height < 0.0) {
-        gluQuadricError(qobj, GLU_INVALID_VALUE);
-        return;
+            height < 0.0) {
+        gluQuadricError(qobj, GLU_INVALID_VALUE);
+        return;
     }
 
@@ -187 +187 @@
     length = SQRT(deltaRadius*deltaRadius + height*height);
     if (length == 0.0) {
-        gluQuadricError(qobj, GLU_INVALID_VALUE);
-        return;
+        gluQuadricError(qobj, GLU_INVALID_VALUE);
+        return;
     }
 
@@ -196 +196 @@
     needCache2 = needCache3 = 0;
     if (qobj->normals == GLU_SMOOTH) {
-        needCache2 = 1;
+        needCache2 = 1;
     }
 
     if (qobj->normals == GLU_FLAT) {
-        if (qobj->drawStyle != GLU_POINT) {
-            needCache3 = 1;
-        }
-        if (qobj->drawStyle == GLU_LINE) {
-            needCache2 = 1;
-        }
+        if (qobj->drawStyle != GLU_POINT) {
+            needCache3 = 1;
+        }
+        if (qobj->drawStyle == GLU_LINE) {
+            needCache2 = 1;
+        }
     }
 
@@ -212 +212 @@
 
     for (i = 0; i < slices; i++) {
-        angle = 2 * PI * i / slices;
-        if (needCache2) {
-            if (qobj->orientation == GLU_OUTSIDE) {
-                sinCache2[i] = xyNormalRatio * SIN(angle);
-                cosCache2[i] = xyNormalRatio * COS(angle);
-            } else {
-                sinCache2[i] = -xyNormalRatio * SIN(angle);
-                cosCache2[i] = -xyNormalRatio * COS(angle);
-            }
-        }
-        sinCache[i] = SIN(angle);
-        cosCache[i] = COS(angle);
+        angle = 2 * PI * i / slices;
+        if (needCache2) {
+            if (qobj->orientation == GLU_OUTSIDE) {
+                sinCache2[i] = xyNormalRatio * SIN(angle);
+                cosCache2[i] = xyNormalRatio * COS(angle);
+            } else {
+                sinCache2[i] = -xyNormalRatio * SIN(angle);
+                cosCache2[i] = -xyNormalRatio * COS(angle);
+            }
+        }
+        sinCache[i] = SIN(angle);
+        cosCache[i] = COS(angle);
     }
 
     if (needCache3) {
-        for (i = 0; i < slices; i++) {
-            angle = 2 * PI * (i-0.5) / slices;
-            if (qobj->orientation == GLU_OUTSIDE) {
-                sinCache3[i] = xyNormalRatio * SIN(angle);
-                cosCache3[i] = xyNormalRatio * COS(angle);
-            } else {
-                sinCache3[i] = -xyNormalRatio * SIN(angle);
-                cosCache3[i] = -xyNormalRatio * COS(angle);
-            }
-        }
+        for (i = 0; i < slices; i++) {
+            angle = 2 * PI * (i-0.5) / slices;
+            if (qobj->orientation == GLU_OUTSIDE) {
+                sinCache3[i] = xyNormalRatio * SIN(angle);
+                cosCache3[i] = xyNormalRatio * COS(angle);
+            } else {
+                sinCache3[i] = -xyNormalRatio * SIN(angle);
+                cosCache3[i] = -xyNormalRatio * COS(angle);
+            }
+        }
     }
 
@@ -242 +242 @@
     cosCache[slices] = cosCache[0];
     if (needCache2) {
-        sinCache2[slices] = sinCache2[0];
-        cosCache2[slices] = cosCache2[0];
+        sinCache2[slices] = sinCache2[0];
+        cosCache2[slices] = cosCache2[0];
     }
     if (needCache3) {
-        sinCache3[slices] = sinCache3[0];
-        cosCache3[slices] = cosCache3[0];
+        sinCache3[slices] = sinCache3[0];
+        cosCache3[slices] = cosCache3[0];
     }
 
     switch (qobj->drawStyle) {
       case GLU_FILL:
-        /* Note:
-        ** An argument could be made for using a TRIANGLE_FAN for the end
-        ** of the cylinder of either radii is 0.0 (a cone).  However, a
-        ** TRIANGLE_FAN would not work in smooth shading mode (the common
-        ** case) because the normal for the apex is different for every
-        ** triangle (and TRIANGLE_FAN doesn't let me respecify that normal).
-        ** Now, my choice is GL_TRIANGLES, or leave the GL_QUAD_STRIP and
-        ** just let the GL trivially reject one of the two triangles of the
-        ** QUAD.  GL_QUAD_STRIP is probably faster, so I will leave this code
-        ** alone.
-        */
-        for (j = 0; j < stacks; j++) {
-            zLow = j * height / stacks;
-            zHigh = (j + 1) * height / stacks;
-            radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
-            radiusHigh = baseRadius - deltaRadius * ((float) (j + 1) / stacks);
-
-            glBegin(GL_QUAD_STRIP);
-            for (i = 0; i <= slices; i++) {
-                switch(qobj->normals) {
-                  case GLU_FLAT:
-                    glNormal3f(sinCache3[i], cosCache3[i], zNormal);
-                    break;
-                  case GLU_SMOOTH:
-                    glNormal3f(sinCache2[i], cosCache2[i], zNormal);
-                    break;
-                  case GLU_NONE:
-                  default:
-                    break;
-                }
-                if (qobj->orientation == GLU_OUTSIDE) {
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(1 - (float) i / slices,
-                                (float) j / stacks);
-                    }
-                    glVertex3f(radiusLow * sinCache[i],
-                            radiusLow * cosCache[i], zLow);
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(1 - (float) i / slices,
-                                (float) (j+1) / stacks);
-                    }
-                    glVertex3f(radiusHigh * sinCache[i],
-                            radiusHigh * cosCache[i], zHigh);
-                } else {
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(1 - (float) i / slices,
-                                (float) (j+1) / stacks);
-                    }
-                    glVertex3f(radiusHigh * sinCache[i],
-                            radiusHigh * cosCache[i], zHigh);
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(1 - (float) i / slices,
-                                (float) j / stacks);
-                    }
-                    glVertex3f(radiusLow * sinCache[i],
-                            radiusLow * cosCache[i], zLow);
-                }
-            }
-            glEnd();
-        }
-        break;
+        /* Note:
+        ** An argument could be made for using a TRIANGLE_FAN for the end
+        ** of the cylinder of either radii is 0.0 (a cone).  However, a
+        ** TRIANGLE_FAN would not work in smooth shading mode (the common
+        ** case) because the normal for the apex is different for every
+        ** triangle (and TRIANGLE_FAN doesn't let me respecify that normal).
+        ** Now, my choice is GL_TRIANGLES, or leave the GL_QUAD_STRIP and
+        ** just let the GL trivially reject one of the two triangles of the
+        ** QUAD.  GL_QUAD_STRIP is probably faster, so I will leave this code
+        ** alone.
+        */
+        for (j = 0; j < stacks; j++) {
+            zLow = j * height / stacks;
+            zHigh = (j + 1) * height / stacks;
+            radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
+            radiusHigh = baseRadius - deltaRadius * ((float) (j + 1) / stacks);
+
+            glBegin(GL_QUAD_STRIP);
+            for (i = 0; i <= slices; i++) {
+                switch(qobj->normals) {
+                  case GLU_FLAT:
+                    glNormal3f(sinCache3[i], cosCache3[i], zNormal);
+                    break;
+                  case GLU_SMOOTH:
+                    glNormal3f(sinCache2[i], cosCache2[i], zNormal);
+                    break;
+                  case GLU_NONE:
+                  default:
+                    break;
+                }
+                if (qobj->orientation == GLU_OUTSIDE) {
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(1 - (float) i / slices,
+                                (float) j / stacks);
+                    }
+                    glVertex3f(radiusLow * sinCache[i],
+                            radiusLow * cosCache[i], zLow);
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(1 - (float) i / slices,
+                                (float) (j+1) / stacks);
+                    }
+                    glVertex3f(radiusHigh * sinCache[i],
+                            radiusHigh * cosCache[i], zHigh);
+                } else {
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(1 - (float) i / slices,
+                                (float) (j+1) / stacks);
+                    }
+                    glVertex3f(radiusHigh * sinCache[i],
+                            radiusHigh * cosCache[i], zHigh);
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(1 - (float) i / slices,
+                                (float) j / stacks);
+                    }
+                    glVertex3f(radiusLow * sinCache[i],
+                            radiusLow * cosCache[i], zLow);
+                }
+            }
+            glEnd();
+        }
+        break;
       case GLU_POINT:
-        glBegin(GL_POINTS);
-        for (i = 0; i < slices; i++) {
-            switch(qobj->normals) {
-              case GLU_FLAT:
-              case GLU_SMOOTH:
-                glNormal3f(sinCache2[i], cosCache2[i], zNormal);
-                break;
-              case GLU_NONE:
-              default:
-                break;
-            }
-            sintemp = sinCache[i];
-            costemp = cosCache[i];
-            for (j = 0; j <= stacks; j++) {
-                zLow = j * height / stacks;
-                radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
-
-                if (qobj->textureCoords) {
-                    glTexCoord2f(1 - (float) i / slices,
-                            (float) j / stacks);
-                }
-                glVertex3f(radiusLow * sintemp,
-                        radiusLow * costemp, zLow);
-            }
-        }
-        glEnd();
-        break;
+        glBegin(GL_POINTS);
+        for (i = 0; i < slices; i++) {
+            switch(qobj->normals) {
+              case GLU_FLAT:
+              case GLU_SMOOTH:
+                glNormal3f(sinCache2[i], cosCache2[i], zNormal);
+                break;
+              case GLU_NONE:
+              default:
+                break;
+            }
+            sintemp = sinCache[i];
+            costemp = cosCache[i];
+            for (j = 0; j <= stacks; j++) {
+                zLow = j * height / stacks;
+                radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
+
+                if (qobj->textureCoords) {
+                    glTexCoord2f(1 - (float) i / slices,
+                            (float) j / stacks);
+                }
+                glVertex3f(radiusLow * sintemp,
+                        radiusLow * costemp, zLow);
+            }
+        }
+        glEnd();
+        break;
       case GLU_LINE:
-        for (j = 1; j < stacks; j++) {
-            zLow = j * height / stacks;
-            radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
-
-            glBegin(GL_LINE_STRIP);
-            for (i = 0; i <= slices; i++) {
-                switch(qobj->normals) {
-                  case GLU_FLAT:
-                    glNormal3f(sinCache3[i], cosCache3[i], zNormal);
-                    break;
-                  case GLU_SMOOTH:
-                    glNormal3f(sinCache2[i], cosCache2[i], zNormal);
-                    break;
-                  case GLU_NONE:
-                  default:
-                    break;
-                }
-                if (qobj->textureCoords) {
-                    glTexCoord2f(1 - (float) i / slices,
-                            (float) j / stacks);
-                }
-                glVertex3f(radiusLow * sinCache[i],
-                        radiusLow * cosCache[i], zLow);
-            }
-            glEnd();
-        }
-        /* Intentionally fall through here... */
+        for (j = 1; j < stacks; j++) {
+            zLow = j * height / stacks;
+            radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
+
+            glBegin(GL_LINE_STRIP);
+            for (i = 0; i <= slices; i++) {
+                switch(qobj->normals) {
+                  case GLU_FLAT:
+                    glNormal3f(sinCache3[i], cosCache3[i], zNormal);
+                    break;
+                  case GLU_SMOOTH:
+                    glNormal3f(sinCache2[i], cosCache2[i], zNormal);
+                    break;
+                  case GLU_NONE:
+                  default:
+                    break;
+                }
+                if (qobj->textureCoords) {
+                    glTexCoord2f(1 - (float) i / slices,
+                            (float) j / stacks);
+                }
+                glVertex3f(radiusLow * sinCache[i],
+                        radiusLow * cosCache[i], zLow);
+            }
+            glEnd();
+        }
+        /* Intentionally fall through here... */
       case GLU_SILHOUETTE:
-        for (j = 0; j <= stacks; j += stacks) {
-            zLow = j * height / stacks;
-            radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
-
-            glBegin(GL_LINE_STRIP);
-            for (i = 0; i <= slices; i++) {
-                switch(qobj->normals) {
-                  case GLU_FLAT:
-                    glNormal3f(sinCache3[i], cosCache3[i], zNormal);
-                    break;
-                  case GLU_SMOOTH:
-                    glNormal3f(sinCache2[i], cosCache2[i], zNormal);
-                    break;
-                  case GLU_NONE:
-                  default:
-                    break;
-                }
-                if (qobj->textureCoords) {
-                    glTexCoord2f(1 - (float) i / slices,
-                            (float) j / stacks);
-                }
-                glVertex3f(radiusLow * sinCache[i], radiusLow * cosCache[i],
-                        zLow);
-            }
-            glEnd();
-        }
-        for (i = 0; i < slices; i++) {
-            switch(qobj->normals) {
-              case GLU_FLAT:
-              case GLU_SMOOTH:
-                glNormal3f(sinCache2[i], cosCache2[i], 0.0);
-                break;
-              case GLU_NONE:
-              default:
-                break;
-            }
-            sintemp = sinCache[i];
-            costemp = cosCache[i];
-            glBegin(GL_LINE_STRIP);
-            for (j = 0; j <= stacks; j++) {
-                zLow = j * height / stacks;
-                radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
-
-                if (qobj->textureCoords) {
-                    glTexCoord2f(1 - (float) i / slices,
-                            (float) j / stacks);
-                }
-                glVertex3f(radiusLow * sintemp,
-                        radiusLow * costemp, zLow);
-            }
-            glEnd();
-        }
-        break;
+        for (j = 0; j <= stacks; j += stacks) {
+            zLow = j * height / stacks;
+            radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
+
+            glBegin(GL_LINE_STRIP);
+            for (i = 0; i <= slices; i++) {
+                switch(qobj->normals) {
+                  case GLU_FLAT:
+                    glNormal3f(sinCache3[i], cosCache3[i], zNormal);
+                    break;
+                  case GLU_SMOOTH:
+                    glNormal3f(sinCache2[i], cosCache2[i], zNormal);
+                    break;
+                  case GLU_NONE:
+                  default:
+                    break;
+                }
+                if (qobj->textureCoords) {
+                    glTexCoord2f(1 - (float) i / slices,
+                            (float) j / stacks);
+                }
+                glVertex3f(radiusLow * sinCache[i], radiusLow * cosCache[i],
+                        zLow);
+            }
+            glEnd();
+        }
+        for (i = 0; i < slices; i++) {
+            switch(qobj->normals) {
+              case GLU_FLAT:
+              case GLU_SMOOTH:
+                glNormal3f(sinCache2[i], cosCache2[i], 0.0);
+                break;
+              case GLU_NONE:
+              default:
+                break;
+            }
+            sintemp = sinCache[i];
+            costemp = cosCache[i];
+            glBegin(GL_LINE_STRIP);
+            for (j = 0; j <= stacks; j++) {
+                zLow = j * height / stacks;
+                radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
+
+                if (qobj->textureCoords) {
+                    glTexCoord2f(1 - (float) i / slices,
+                            (float) j / stacks);
+                }
+                glVertex3f(radiusLow * sintemp,
+                        radiusLow * costemp, zLow);
+            }
+            glEnd();
+        }
+        break;
       default:
-        break;
+        break;
     }
 }
@@ -430 +430 @@
 void GLAPI
 gluDisk(GLUquadric *qobj, GLdouble innerRadius, GLdouble outerRadius,
-            GLint slices, GLint loops)
+            GLint slices, GLint loops)
 {
     gluPartialDisk(qobj, innerRadius, outerRadius, slices, loops, 0.0, 360.0);
@@ -437 +437 @@
 void GLAPI
 gluPartialDisk(GLUquadric *qobj, GLdouble innerRadius,
-                   GLdouble outerRadius, GLint slices, GLint loops,
-                   GLdouble startAngle, GLdouble sweepAngle)
+                   GLdouble outerRadius, GLint slices, GLint loops,
+                   GLdouble startAngle, GLdouble sweepAngle)
 {
     GLint i,j,max;
@@ -455 +455 @@
     if (slices >= CACHE_SIZE) slices = CACHE_SIZE-1;
     if (slices < 2 || loops < 1 || outerRadius <= 0.0 || innerRadius < 0.0 ||
-            innerRadius > outerRadius) {
-        gluQuadricError(qobj, GLU_INVALID_VALUE);
-        return;
+            innerRadius > outerRadius) {
+        gluQuadricError(qobj, GLU_INVALID_VALUE);
+        return;
     }
 
@@ -463 +463 @@
     if (sweepAngle > 360.0) sweepAngle = 360.0;
     if (sweepAngle < 0) {
-        startAngle += sweepAngle;
-        sweepAngle = -sweepAngle;
+        startAngle += sweepAngle;
+        sweepAngle = -sweepAngle;
     }
 
     if (sweepAngle == 360.0) {
-        slices2 = slices;
+        slices2 = slices;
     } else {
-        slices2 = slices + 1;
+        slices2 = slices + 1;
     }
 
@@ -480 +480 @@
     angleOffset = startAngle / 180.0 * PI;
     for (i = 0; i <= slices; i++) {
-        angle = angleOffset + ((PI * sweepAngle) / 180.0) * i / slices;
-        sinCache[i] = SIN(angle);
-        cosCache[i] = COS(angle);
+        angle = angleOffset + ((PI * sweepAngle) / 180.0) * i / slices;
+        sinCache[i] = SIN(angle);
+        cosCache[i] = COS(angle);
     }
 
     if (sweepAngle == 360.0) {
-        sinCache[slices] = sinCache[0];
-        cosCache[slices] = cosCache[0];
+        sinCache[slices] = sinCache[0];
+        cosCache[slices] = cosCache[0];
     }
 
@@ -493 +493 @@
       case GLU_FLAT:
       case GLU_SMOOTH:
-        if (qobj->orientation == GLU_OUTSIDE) {
-            glNormal3f(0.0, 0.0, 1.0);
-        } else {
-            glNormal3f(0.0, 0.0, -1.0);
-        }
-        break;
+        if (qobj->orientation == GLU_OUTSIDE) {
+            glNormal3f(0.0, 0.0, 1.0);
+        } else {
+            glNormal3f(0.0, 0.0, -1.0);
+        }
+        break;
       default:
       case GLU_NONE:
-        break;
+        break;
     }
 
     switch (qobj->drawStyle) {
       case GLU_FILL:
-        if (innerRadius == 0.0) {
-            finish = loops - 1;
-            /* Triangle strip for inner polygons */
-            glBegin(GL_TRIANGLE_FAN);
-            if (qobj->textureCoords) {
-                glTexCoord2f(0.5, 0.5);
-            }
-            glVertex3f(0.0, 0.0, 0.0);
-            radiusLow = outerRadius -
-                    deltaRadius * ((float) (loops-1) / loops);
-            if (qobj->textureCoords) {
-                texLow = radiusLow / outerRadius / 2;
-            }
-
-            if (qobj->orientation == GLU_OUTSIDE) {
-                for (i = slices; i >= 0; i--) {
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(texLow * sinCache[i] + 0.5,
-                                texLow * cosCache[i] + 0.5);
-                    }
-                    glVertex3f(radiusLow * sinCache[i],
-                            radiusLow * cosCache[i], 0.0);
-                }
-            } else {
-                for (i = 0; i <= slices; i++) {
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(texLow * sinCache[i] + 0.5,
-                                texLow * cosCache[i] + 0.5);
-                    }
-                    glVertex3f(radiusLow * sinCache[i],
-                            radiusLow * cosCache[i], 0.0);
-                }
-            }
-            glEnd();
-        } else {
-            finish = loops;
-        }
-        for (j = 0; j < finish; j++) {
-            radiusLow = outerRadius - deltaRadius * ((float) j / loops);
-            radiusHigh = outerRadius - deltaRadius * ((float) (j + 1) / loops);
-            if (qobj->textureCoords) {
-                texLow = radiusLow / outerRadius / 2;
-                texHigh = radiusHigh / outerRadius / 2;
-            }
-
-            glBegin(GL_QUAD_STRIP);
-            for (i = 0; i <= slices; i++) {
-                if (qobj->orientation == GLU_OUTSIDE) {
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(texLow * sinCache[i] + 0.5,
-                                texLow * cosCache[i] + 0.5);
-                    }
-                    glVertex3f(radiusLow * sinCache[i],
-                            radiusLow * cosCache[i], 0.0);
-
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(texHigh * sinCache[i] + 0.5,
-                                texHigh * cosCache[i] + 0.5);
-                    }
-                    glVertex3f(radiusHigh * sinCache[i],
-                            radiusHigh * cosCache[i], 0.0);
-                } else {
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(texHigh * sinCache[i] + 0.5,
-                                texHigh * cosCache[i] + 0.5);
-                    }
-                    glVertex3f(radiusHigh * sinCache[i],
-                            radiusHigh * cosCache[i], 0.0);
-
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(texLow * sinCache[i] + 0.5,
-                                texLow * cosCache[i] + 0.5);
-                    }
-                    glVertex3f(radiusLow * sinCache[i],
-                            radiusLow * cosCache[i], 0.0);
-                }
-            }
-            glEnd();
-        }
-        break;
+        if (innerRadius == 0.0) {
+            finish = loops - 1;
+            /* Triangle strip for inner polygons */
+            glBegin(GL_TRIANGLE_FAN);
+            if (qobj->textureCoords) {
+                glTexCoord2f(0.5, 0.5);
+            }
+            glVertex3f(0.0, 0.0, 0.0);
+            radiusLow = outerRadius -
+                    deltaRadius * ((float) (loops-1) / loops);
+            if (qobj->textureCoords) {
+                texLow = radiusLow / outerRadius / 2;
+            }
+
+            if (qobj->orientation == GLU_OUTSIDE) {
+                for (i = slices; i >= 0; i--) {
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(texLow * sinCache[i] + 0.5,
+                                texLow * cosCache[i] + 0.5);
+                    }
+                    glVertex3f(radiusLow * sinCache[i],
+                            radiusLow * cosCache[i], 0.0);
+                }
+            } else {
+                for (i = 0; i <= slices; i++) {
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(texLow * sinCache[i] + 0.5,
+                                texLow * cosCache[i] + 0.5);
+                    }
+                    glVertex3f(radiusLow * sinCache[i],
+                            radiusLow * cosCache[i], 0.0);
+                }
+            }
+            glEnd();
+        } else {
+            finish = loops;
+        }
+        for (j = 0; j < finish; j++) {
+            radiusLow = outerRadius - deltaRadius * ((float) j / loops);
+            radiusHigh = outerRadius - deltaRadius * ((float) (j + 1) / loops);
+            if (qobj->textureCoords) {
+                texLow = radiusLow / outerRadius / 2;
+                texHigh = radiusHigh / outerRadius / 2;
+            }
+
+            glBegin(GL_QUAD_STRIP);
+            for (i = 0; i <= slices; i++) {
+                if (qobj->orientation == GLU_OUTSIDE) {
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(texLow * sinCache[i] + 0.5,
+                                texLow * cosCache[i] + 0.5);
+                    }
+                    glVertex3f(radiusLow * sinCache[i],
+                            radiusLow * cosCache[i], 0.0);
+
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(texHigh * sinCache[i] + 0.5,
+                                texHigh * cosCache[i] + 0.5);
+                    }
+                    glVertex3f(radiusHigh * sinCache[i],
+                            radiusHigh * cosCache[i], 0.0);
+                } else {
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(texHigh * sinCache[i] + 0.5,
+                                texHigh * cosCache[i] + 0.5);
+                    }
+                    glVertex3f(radiusHigh * sinCache[i],
+                            radiusHigh * cosCache[i], 0.0);
+
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(texLow * sinCache[i] + 0.5,
+                                texLow * cosCache[i] + 0.5);
+                    }
+                    glVertex3f(radiusLow * sinCache[i],
+                            radiusLow * cosCache[i], 0.0);
+                }
+            }
+            glEnd();
+        }
+        break;
       case GLU_POINT:
-        glBegin(GL_POINTS);
-        for (i = 0; i < slices2; i++) {
-            sintemp = sinCache[i];
-            costemp = cosCache[i];
-            for (j = 0; j <= loops; j++) {
-                radiusLow = outerRadius - deltaRadius * ((float) j / loops);
-
-                if (qobj->textureCoords) {
-                    texLow = radiusLow / outerRadius / 2;
-
-                    glTexCoord2f(texLow * sinCache[i] + 0.5,
-                            texLow * cosCache[i] + 0.5);
-                }
-                glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0);
-            }
-        }
-        glEnd();
-        break;
+        glBegin(GL_POINTS);
+        for (i = 0; i < slices2; i++) {
+            sintemp = sinCache[i];
+            costemp = cosCache[i];
+            for (j = 0; j <= loops; j++) {
+                radiusLow = outerRadius - deltaRadius * ((float) j / loops);
+
+                if (qobj->textureCoords) {
+                    texLow = radiusLow / outerRadius / 2;
+
+                    glTexCoord2f(texLow * sinCache[i] + 0.5,
+                            texLow * cosCache[i] + 0.5);
+                }
+                glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0);
+            }
+        }
+        glEnd();
+        break;
       case GLU_LINE:
-        if (innerRadius == outerRadius) {
-            glBegin(GL_LINE_STRIP);
-
-            for (i = 0; i <= slices; i++) {
-                if (qobj->textureCoords) {
-                    glTexCoord2f(sinCache[i] / 2 + 0.5,
-                            cosCache[i] / 2 + 0.5);
-                }
-                glVertex3f(innerRadius * sinCache[i],
-                        innerRadius * cosCache[i], 0.0);
-            }
-            glEnd();
-            break;
-        }
-        for (j = 0; j <= loops; j++) {
-            radiusLow = outerRadius - deltaRadius * ((float) j / loops);
-            if (qobj->textureCoords) {
-                texLow = radiusLow / outerRadius / 2;
-            }
-
-            glBegin(GL_LINE_STRIP);
-            for (i = 0; i <= slices; i++) {
-                if (qobj->textureCoords) {
-                    glTexCoord2f(texLow * sinCache[i] + 0.5,
-                            texLow * cosCache[i] + 0.5);
-                }
-                glVertex3f(radiusLow * sinCache[i],
-                        radiusLow * cosCache[i], 0.0);
-            }
-            glEnd();
-        }
-        for (i=0; i < slices2; i++) {
-            sintemp = sinCache[i];
-            costemp = cosCache[i];
-            glBegin(GL_LINE_STRIP);
-            for (j = 0; j <= loops; j++) {
-                radiusLow = outerRadius - deltaRadius * ((float) j / loops);
-                if (qobj->textureCoords) {
-                    texLow = radiusLow / outerRadius / 2;
-                }
-
-                if (qobj->textureCoords) {
-                    glTexCoord2f(texLow * sinCache[i] + 0.5,
-                            texLow * cosCache[i] + 0.5);
-                }
-                glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0);
-            }
-            glEnd();
-        }
-        break;
+        if (innerRadius == outerRadius) {
+            glBegin(GL_LINE_STRIP);
+
+            for (i = 0; i <= slices; i++) {
+                if (qobj->textureCoords) {
+                    glTexCoord2f(sinCache[i] / 2 + 0.5,
+                            cosCache[i] / 2 + 0.5);
+                }
+                glVertex3f(innerRadius * sinCache[i],
+                        innerRadius * cosCache[i], 0.0);
+            }
+            glEnd();
+            break;
+        }
+        for (j = 0; j <= loops; j++) {
+            radiusLow = outerRadius - deltaRadius * ((float) j / loops);
+            if (qobj->textureCoords) {
+                texLow = radiusLow / outerRadius / 2;
+            }
+
+            glBegin(GL_LINE_STRIP);
+            for (i = 0; i <= slices; i++) {
+                if (qobj->textureCoords) {
+                    glTexCoord2f(texLow * sinCache[i] + 0.5,
+                            texLow * cosCache[i] + 0.5);
+                }
+                glVertex3f(radiusLow * sinCache[i],
+                        radiusLow * cosCache[i], 0.0);
+            }
+            glEnd();
+        }
+        for (i=0; i < slices2; i++) {
+            sintemp = sinCache[i];
+            costemp = cosCache[i];
+            glBegin(GL_LINE_STRIP);
+            for (j = 0; j <= loops; j++) {
+                radiusLow = outerRadius - deltaRadius * ((float) j / loops);
+                if (qobj->textureCoords) {
+                    texLow = radiusLow / outerRadius / 2;
+                }
+
+                if (qobj->textureCoords) {
+                    glTexCoord2f(texLow * sinCache[i] + 0.5,
+                            texLow * cosCache[i] + 0.5);
+                }
+                glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0);
+            }
+            glEnd();
+        }
+        break;
       case GLU_SILHOUETTE:
-        if (sweepAngle < 360.0) {
-            for (i = 0; i <= slices; i+= slices) {
-                sintemp = sinCache[i];
-                costemp = cosCache[i];
-                glBegin(GL_LINE_STRIP);
-                for (j = 0; j <= loops; j++) {
-                    radiusLow = outerRadius - deltaRadius * ((float) j / loops);
-
-                    if (qobj->textureCoords) {
-                        texLow = radiusLow / outerRadius / 2;
-                        glTexCoord2f(texLow * sinCache[i] + 0.5,
-                                texLow * cosCache[i] + 0.5);
-                    }
-                    glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0);
-                }
-                glEnd();
-            }
-        }
-        for (j = 0; j <= loops; j += loops) {
-            radiusLow = outerRadius - deltaRadius * ((float) j / loops);
-            if (qobj->textureCoords) {
-                texLow = radiusLow / outerRadius / 2;
-            }
-
-            glBegin(GL_LINE_STRIP);
-            for (i = 0; i <= slices; i++) {
-                if (qobj->textureCoords) {
-                    glTexCoord2f(texLow * sinCache[i] + 0.5,
-                            texLow * cosCache[i] + 0.5);
-                }
-                glVertex3f(radiusLow * sinCache[i],
-                        radiusLow * cosCache[i], 0.0);
-            }
-            glEnd();
-            if (innerRadius == outerRadius) break;
-        }
-        break;
+        if (sweepAngle < 360.0) {
+            for (i = 0; i <= slices; i+= slices) {
+                sintemp = sinCache[i];
+                costemp = cosCache[i];
+                glBegin(GL_LINE_STRIP);
+                for (j = 0; j <= loops; j++) {
+                    radiusLow = outerRadius - deltaRadius * ((float) j / loops);
+
+                    if (qobj->textureCoords) {
+                        texLow = radiusLow / outerRadius / 2;
+                        glTexCoord2f(texLow * sinCache[i] + 0.5,
+                                texLow * cosCache[i] + 0.5);
+                    }
+                    glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0);
+                }
+                glEnd();
+            }
+        }
+        for (j = 0; j <= loops; j += loops) {
+            radiusLow = outerRadius - deltaRadius * ((float) j / loops);
+            if (qobj->textureCoords) {
+                texLow = radiusLow / outerRadius / 2;
+            }
+
+            glBegin(GL_LINE_STRIP);
+            for (i = 0; i <= slices; i++) {
+                if (qobj->textureCoords) {
+                    glTexCoord2f(texLow * sinCache[i] + 0.5,
+                            texLow * cosCache[i] + 0.5);
+                }
+                glVertex3f(radiusLow * sinCache[i],
+                        radiusLow * cosCache[i], 0.0);
+            }
+            glEnd();
+            if (innerRadius == outerRadius) break;
+        }
+        break;
       default:
-        break;
+        break;
     }
 }
@@ -727 +727 @@
     if (stacks >= CACHE_SIZE) stacks = CACHE_SIZE-1;
     if (slices < 2 || stacks < 1 || radius < 0.0) {
-        gluQuadricError(qobj, GLU_INVALID_VALUE);
-        return;
+        gluQuadricError(qobj, GLU_INVALID_VALUE);
+        return;
     }
 
@@ -737 +737 @@
 
     if (qobj->normals == GLU_SMOOTH) {
-        needCache2 = GL_TRUE;
+        needCache2 = GL_TRUE;
     }
 
     if (qobj->normals == GLU_FLAT) {
-        if (qobj->drawStyle != GLU_POINT) {
-            needCache3 = GL_TRUE;
-        }
-        if (qobj->drawStyle == GLU_LINE) {
-            needCache2 = GL_TRUE;
-        }
+        if (qobj->drawStyle != GLU_POINT) {
+            needCache3 = GL_TRUE;
+        }
+        if (qobj->drawStyle == GLU_LINE) {
+            needCache2 = GL_TRUE;
+        }
     }
 
     for (i = 0; i < slices; i++) {
-        angle = 2 * PI * i / slices;
-        sinCache1a[i] = SIN(angle);
-        cosCache1a[i] = COS(angle);
-        if (needCache2) {
-            sinCache2a[i] = sinCache1a[i];
-            cosCache2a[i] = cosCache1a[i];
-        }
+        angle = 2 * PI * i / slices;
+        sinCache1a[i] = SIN(angle);
+        cosCache1a[i] = COS(angle);
+        if (needCache2) {
+            sinCache2a[i] = sinCache1a[i];
+            cosCache2a[i] = cosCache1a[i];
+        }
     }
 
     for (j = 0; j <= stacks; j++) {
-        angle = PI * j / stacks;
-        if (needCache2) {
-            if (qobj->orientation == GLU_OUTSIDE) {
-                sinCache2b[j] = SIN(angle);
-                cosCache2b[j] = COS(angle);
-            } else {
-                sinCache2b[j] = -SIN(angle);
-                cosCache2b[j] = -COS(angle);
-            }
-        }
-        sinCache1b[j] = radius * SIN(angle);
-        cosCache1b[j] = radius * COS(angle);
+        angle = PI * j / stacks;
+        if (needCache2) {
+            if (qobj->orientation == GLU_OUTSIDE) {
+                sinCache2b[j] = SIN(angle);
+                cosCache2b[j] = COS(angle);
+            } else {
+                sinCache2b[j] = -SIN(angle);
+                cosCache2b[j] = -COS(angle);
+            }
+        }
+        sinCache1b[j] = radius * SIN(angle);
+        cosCache1b[j] = radius * COS(angle);
     }
     /* Make sure it comes to a point */
@@ -778 +778 @@
 
     if (needCache3) {
-        for (i = 0; i < slices; i++) {
-            angle = 2 * PI * (i-0.5) / slices;
-            sinCache3a[i] = SIN(angle);
-            cosCache3a[i] = COS(angle);
-        }
-        for (j = 0; j <= stacks; j++) {
-            angle = PI * (j - 0.5) / stacks;
-            if (qobj->orientation == GLU_OUTSIDE) {
-                sinCache3b[j] = SIN(angle);
-                cosCache3b[j] = COS(angle);
-            } else {
-                sinCache3b[j] = -SIN(angle);
-                cosCache3b[j] = -COS(angle);
-            }
-        }
+        for (i = 0; i < slices; i++) {
+            angle = 2 * PI * (i-0.5) / slices;
+            sinCache3a[i] = SIN(angle);
+            cosCache3a[i] = COS(angle);
+        }
+        for (j = 0; j <= stacks; j++) {
+            angle = PI * (j - 0.5) / stacks;
+            if (qobj->orientation == GLU_OUTSIDE) {
+                sinCache3b[j] = SIN(angle);
+                cosCache3b[j] = COS(angle);
+            } else {
+                sinCache3b[j] = -SIN(angle);
+                cosCache3b[j] = -COS(angle);
+            }
+        }
     }
 
@@ -798 +798 @@
     cosCache1a[slices] = cosCache1a[0];
     if (needCache2) {
-        sinCache2a[slices] = sinCache2a[0];
-        cosCache2a[slices] = cosCache2a[0];
+        sinCache2a[slices] = sinCache2a[0];
+        cosCache2a[slices] = cosCache2a[0];
     }
     if (needCache3) {
-        sinCache3a[slices] = sinCache3a[0];
-        cosCache3a[slices] = cosCache3a[0];
+        sinCache3a[slices] = sinCache3a[0];
+        cosCache3a[slices] = cosCache3a[0];
     }
 
     switch (qobj->drawStyle) {
       case GLU_FILL:
-        /* Do ends of sphere as TRIANGLE_FAN's (if not texturing)
-        ** We don't do it when texturing because we need to respecify the
-        ** texture coordinates of the apex for every adjacent vertex (because
-        ** it isn't a constant for that point)
-        */
-        if (!(qobj->textureCoords)) {
-            start = 1;
-            finish = stacks - 1;
-
-            /* Low end first (j == 0 iteration) */
-            sintemp2 = sinCache1b[1];
-            zHigh = cosCache1b[1];
-            switch(qobj->normals) {
-              case GLU_FLAT:
-                sintemp3 = sinCache3b[1];
-                costemp3 = cosCache3b[1];
-                break;
-              case GLU_SMOOTH:
-                sintemp3 = sinCache2b[1];
-                costemp3 = cosCache2b[1];
-                glNormal3f(sinCache2a[0] * sinCache2b[0],
-                        cosCache2a[0] * sinCache2b[0],
-                        cosCache2b[0]);
-                break;
-              default:
-                break;
-            }
-            glBegin(GL_TRIANGLE_FAN);
-            glVertex3f(0.0, 0.0, radius);
-            if (qobj->orientation == GLU_OUTSIDE) {
-                for (i = slices; i >= 0; i--) {
-                    switch(qobj->normals) {
-                      case GLU_SMOOTH:
-                        glNormal3f(sinCache2a[i] * sintemp3,
-                                cosCache2a[i] * sintemp3,
-                                costemp3);
-                        break;
-                      case GLU_FLAT:
-                        if (i != slices) {
-                            glNormal3f(sinCache3a[i+1] * sintemp3,
-                                    cosCache3a[i+1] * sintemp3,
-                                    costemp3);
-                        }
-                        break;
-                      case GLU_NONE:
-                      default:
-                        break;
-                    }
-                    glVertex3f(sintemp2 * sinCache1a[i],
-                            sintemp2 * cosCache1a[i], zHigh);
-                }
-            } else {
-                for (i = 0; i <= slices; i++) {
-                    switch(qobj->normals) {
-                      case GLU_SMOOTH:
-                        glNormal3f(sinCache2a[i] * sintemp3,
-                                cosCache2a[i] * sintemp3,
-                                costemp3);
-                        break;
-                      case GLU_FLAT:
-                        glNormal3f(sinCache3a[i] * sintemp3,
-                                cosCache3a[i] * sintemp3,
-                                costemp3);
-                        break;
-                      case GLU_NONE:
-                      default:
-                        break;
-                    }
-                    glVertex3f(sintemp2 * sinCache1a[i],
-                            sintemp2 * cosCache1a[i], zHigh);
-                }
-            }
-            glEnd();
-
-            /* High end next (j == stacks-1 iteration) */
-            sintemp2 = sinCache1b[stacks-1];
-            zHigh = cosCache1b[stacks-1];
-            switch(qobj->normals) {
-              case GLU_FLAT:
-                sintemp3 = sinCache3b[stacks];
-                costemp3 = cosCache3b[stacks];
-                break;
-              case GLU_SMOOTH:
-                sintemp3 = sinCache2b[stacks-1];
-                costemp3 = cosCache2b[stacks-1];
-                glNormal3f(sinCache2a[stacks] * sinCache2b[stacks],
-                        cosCache2a[stacks] * sinCache2b[stacks],
-                        cosCache2b[stacks]);
-                break;
-              default:
-                break;
-            }
-            glBegin(GL_TRIANGLE_FAN);
-            glVertex3f(0.0, 0.0, -radius);
-            if (qobj->orientation == GLU_OUTSIDE) {
-                for (i = 0; i <= slices; i++) {
-                    switch(qobj->normals) {
-                      case GLU_SMOOTH:
-                        glNormal3f(sinCache2a[i] * sintemp3,
-                                cosCache2a[i] * sintemp3,
-                                costemp3);
-                        break;
-                      case GLU_FLAT:
-                        glNormal3f(sinCache3a[i] * sintemp3,
-                                cosCache3a[i] * sintemp3,
-                                costemp3);
-                        break;
-                      case GLU_NONE:
-                      default:
-                        break;
-                    }
-                    glVertex3f(sintemp2 * sinCache1a[i],
-                            sintemp2 * cosCache1a[i], zHigh);
-                }
-            } else {
-                for (i = slices; i >= 0; i--) {
-                    switch(qobj->normals) {
-                      case GLU_SMOOTH:
-                        glNormal3f(sinCache2a[i] * sintemp3,
-                                cosCache2a[i] * sintemp3,
-                                costemp3);
-                        break;
-                      case GLU_FLAT:
-                        if (i != slices) {
-                            glNormal3f(sinCache3a[i+1] * sintemp3,
-                                    cosCache3a[i+1] * sintemp3,
-                                    costemp3);
-                        }
-                        break;
-                      case GLU_NONE:
-                      default:
-                        break;
-                    }
-                    glVertex3f(sintemp2 * sinCache1a[i],
-                            sintemp2 * cosCache1a[i], zHigh);
-                }
-            }
-            glEnd();
-        } else {
-            start = 0;
-            finish = stacks;
-        }
-        for (j = start; j < finish; j++) {
-            zLow = cosCache1b[j];
-            zHigh = cosCache1b[j+1];
-            sintemp1 = sinCache1b[j];
-            sintemp2 = sinCache1b[j+1];
-            switch(qobj->normals) {
-              case GLU_FLAT:
-                sintemp4 = sinCache3b[j+1];
-                costemp4 = cosCache3b[j+1];
-                break;
-              case GLU_SMOOTH:
-                if (qobj->orientation == GLU_OUTSIDE) {
-                    sintemp3 = sinCache2b[j+1];
-                    costemp3 = cosCache2b[j+1];
-                    sintemp4 = sinCache2b[j];
-                    costemp4 = cosCache2b[j];
-                } else {
-                    sintemp3 = sinCache2b[j];
-                    costemp3 = cosCache2b[j];
-                    sintemp4 = sinCache2b[j+1];
-                    costemp4 = cosCache2b[j+1];
-                }
-                break;
-              default:
-                break;
-            }
-
-            glBegin(GL_QUAD_STRIP);
-            for (i = 0; i <= slices; i++) {
-                switch(qobj->normals) {
-                  case GLU_SMOOTH:
-                    glNormal3f(sinCache2a[i] * sintemp3,
-                            cosCache2a[i] * sintemp3,
-                            costemp3);
-                    break;
-                  case GLU_FLAT:
-                  case GLU_NONE:
-                  default:
-                    break;
-                }
-                if (qobj->orientation == GLU_OUTSIDE) {
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(1 - (float) i / slices,
-                                1 - (float) (j+1) / stacks);
-                    }
-                    glVertex3f(sintemp2 * sinCache1a[i],
-                            sintemp2 * cosCache1a[i], zHigh);
-                } else {
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(1 - (float) i / slices,
-                                1 - (float) j / stacks);
-                    }
-                    glVertex3f(sintemp1 * sinCache1a[i],
-                            sintemp1 * cosCache1a[i], zLow);
-                }
-                switch(qobj->normals) {
-                  case GLU_SMOOTH:
-                    glNormal3f(sinCache2a[i] * sintemp4,
-                            cosCache2a[i] * sintemp4,
-                            costemp4);
-                    break;
-                  case GLU_FLAT:
-                    glNormal3f(sinCache3a[i] * sintemp4,
-                            cosCache3a[i] * sintemp4,
-                            costemp4);
-                    break;
-                  case GLU_NONE:
-                  default:
-                    break;
-                }
-                if (qobj->orientation == GLU_OUTSIDE) {
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(1 - (float) i / slices,
-                                1 - (float) j / stacks);
-                    }
-                    glVertex3f(sintemp1 * sinCache1a[i],
-                            sintemp1 * cosCache1a[i], zLow);
-                } else {
-                    if (qobj->textureCoords) {
-                        glTexCoord2f(1 - (float) i / slices,
-                                1 - (float) (j+1) / stacks);
-                    }
-                    glVertex3f(sintemp2 * sinCache1a[i],
-                            sintemp2 * cosCache1a[i], zHigh);
-                }
-            }
-            glEnd();
-        }
-        break;
+        /* Do ends of sphere as TRIANGLE_FAN's (if not texturing)
+        ** We don't do it when texturing because we need to respecify the
+        ** texture coordinates of the apex for every adjacent vertex (because
+        ** it isn't a constant for that point)
+        */
+        if (!(qobj->textureCoords)) {
+            start = 1;
+            finish = stacks - 1;
+
+            /* Low end first (j == 0 iteration) */
+            sintemp2 = sinCache1b[1];
+            zHigh = cosCache1b[1];
+            switch(qobj->normals) {
+              case GLU_FLAT:
+                sintemp3 = sinCache3b[1];
+                costemp3 = cosCache3b[1];
+                break;
+              case GLU_SMOOTH:
+                sintemp3 = sinCache2b[1];
+                costemp3 = cosCache2b[1];
+                glNormal3f(sinCache2a[0] * sinCache2b[0],
+                        cosCache2a[0] * sinCache2b[0],
+                        cosCache2b[0]);
+                break;
+              default:
+                break;
+            }
+            glBegin(GL_TRIANGLE_FAN);
+            glVertex3f(0.0, 0.0, radius);
+            if (qobj->orientation == GLU_OUTSIDE) {
+                for (i = slices; i >= 0; i--) {
+                    switch(qobj->normals) {
+                      case GLU_SMOOTH:
+                        glNormal3f(sinCache2a[i] * sintemp3,
+                                cosCache2a[i] * sintemp3,
+                                costemp3);
+                        break;
+                      case GLU_FLAT:
+                        if (i != slices) {
+                            glNormal3f(sinCache3a[i+1] * sintemp3,
+                                    cosCache3a[i+1] * sintemp3,
+                                    costemp3);
+                        }
+                        break;
+                      case GLU_NONE:
+                      default:
+                        break;
+                    }
+                    glVertex3f(sintemp2 * sinCache1a[i],
+                            sintemp2 * cosCache1a[i], zHigh);
+                }
+            } else {
+                for (i = 0; i <= slices; i++) {
+                    switch(qobj->normals) {
+                      case GLU_SMOOTH:
+                        glNormal3f(sinCache2a[i] * sintemp3,
+                                cosCache2a[i] * sintemp3,
+                                costemp3);
+                        break;
+                      case GLU_FLAT:
+                        glNormal3f(sinCache3a[i] * sintemp3,
+                                cosCache3a[i] * sintemp3,
+                                costemp3);
+                        break;
+                      case GLU_NONE:
+                      default:
+                        break;
+                    }
+                    glVertex3f(sintemp2 * sinCache1a[i],
+                            sintemp2 * cosCache1a[i], zHigh);
+                }
+            }
+            glEnd();
+
+            /* High end next (j == stacks-1 iteration) */
+            sintemp2 = sinCache1b[stacks-1];
+            zHigh = cosCache1b[stacks-1];
+            switch(qobj->normals) {
+              case GLU_FLAT:
+                sintemp3 = sinCache3b[stacks];
+                costemp3 = cosCache3b[stacks];
+                break;
+              case GLU_SMOOTH:
+                sintemp3 = sinCache2b[stacks-1];
+                costemp3 = cosCache2b[stacks-1];
+                glNormal3f(sinCache2a[stacks] * sinCache2b[stacks],
+                        cosCache2a[stacks] * sinCache2b[stacks],
+                        cosCache2b[stacks]);
+                break;
+              default:
+                break;
+            }
+            glBegin(GL_TRIANGLE_FAN);
+            glVertex3f(0.0, 0.0, -radius);
+            if (qobj->orientation == GLU_OUTSIDE) {
+                for (i = 0; i <= slices; i++) {
+                    switch(qobj->normals) {
+                      case GLU_SMOOTH:
+                        glNormal3f(sinCache2a[i] * sintemp3,
+                                cosCache2a[i] * sintemp3,
+                                costemp3);
+                        break;
+                      case GLU_FLAT:
+                        glNormal3f(sinCache3a[i] * sintemp3,
+                                cosCache3a[i] * sintemp3,
+                                costemp3);
+                        break;
+                      case GLU_NONE:
+                      default:
+                        break;
+                    }
+                    glVertex3f(sintemp2 * sinCache1a[i],
+                            sintemp2 * cosCache1a[i], zHigh);
+                }
+            } else {
+                for (i = slices; i >= 0; i--) {
+                    switch(qobj->normals) {
+                      case GLU_SMOOTH:
+                        glNormal3f(sinCache2a[i] * sintemp3,
+                                cosCache2a[i] * sintemp3,
+                                costemp3);
+                        break;
+                      case GLU_FLAT:
+                        if (i != slices) {
+                            glNormal3f(sinCache3a[i+1] * sintemp3,
+                                    cosCache3a[i+1] * sintemp3,
+                                    costemp3);
+                        }
+                        break;
+                      case GLU_NONE:
+                      default:
+                        break;
+                    }
+                    glVertex3f(sintemp2 * sinCache1a[i],
+                            sintemp2 * cosCache1a[i], zHigh);
+                }
+            }
+            glEnd();
+        } else {
+            start = 0;
+            finish = stacks;
+        }
+        for (j = start; j < finish; j++) {
+            zLow = cosCache1b[j];
+            zHigh = cosCache1b[j+1];
+            sintemp1 = sinCache1b[j];
+            sintemp2 = sinCache1b[j+1];
+            switch(qobj->normals) {
+              case GLU_FLAT:
+                sintemp4 = sinCache3b[j+1];
+                costemp4 = cosCache3b[j+1];
+                break;
+              case GLU_SMOOTH:
+                if (qobj->orientation == GLU_OUTSIDE) {
+                    sintemp3 = sinCache2b[j+1];
+                    costemp3 = cosCache2b[j+1];
+                    sintemp4 = sinCache2b[j];
+                    costemp4 = cosCache2b[j];
+                } else {
+                    sintemp3 = sinCache2b[j];
+                    costemp3 = cosCache2b[j];
+                    sintemp4 = sinCache2b[j+1];
+                    costemp4 = cosCache2b[j+1];
+                }
+                break;
+              default:
+                break;
+            }
+
+            glBegin(GL_QUAD_STRIP);
+            for (i = 0; i <= slices; i++) {
+                switch(qobj->normals) {
+                  case GLU_SMOOTH:
+                    glNormal3f(sinCache2a[i] * sintemp3,
+                            cosCache2a[i] * sintemp3,
+                            costemp3);
+                    break;
+                  case GLU_FLAT:
+                  case GLU_NONE:
+                  default:
+                    break;
+                }
+                if (qobj->orientation == GLU_OUTSIDE) {
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(1 - (float) i / slices,
+                                1 - (float) (j+1) / stacks);
+                    }
+                    glVertex3f(sintemp2 * sinCache1a[i],
+                            sintemp2 * cosCache1a[i], zHigh);
+                } else {
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(1 - (float) i / slices,
+                                1 - (float) j / stacks);
+                    }
+                    glVertex3f(sintemp1 * sinCache1a[i],
+                            sintemp1 * cosCache1a[i], zLow);
+                }
+                switch(qobj->normals) {
+                  case GLU_SMOOTH:
+                    glNormal3f(sinCache2a[i] * sintemp4,
+                            cosCache2a[i] * sintemp4,
+                            costemp4);
+                    break;
+                  case GLU_FLAT:
+                    glNormal3f(sinCache3a[i] * sintemp4,
+                            cosCache3a[i] * sintemp4,
+                            costemp4);
+                    break;
+                  case GLU_NONE:
+                  default:
+                    break;
+                }
+                if (qobj->orientation == GLU_OUTSIDE) {
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(1 - (float) i / slices,
+                                1 - (float) j / stacks);
+                    }
+                    glVertex3f(sintemp1 * sinCache1a[i],
+                            sintemp1 * cosCache1a[i], zLow);
+                } else {
+                    if (qobj->textureCoords) {
+                        glTexCoord2f(1 - (float) i / slices,
+                                1 - (float) (j+1) / stacks);
+                    }
+                    glVertex3f(sintemp2 * sinCache1a[i],
+                            sintemp2 * cosCache1a[i], zHigh);
+                }
+            }
+            glEnd();
+        }
+        break;
       case GLU_POINT:
-        glBegin(GL_POINTS);
-        for (j = 0; j <= stacks; j++) {
-            sintemp1 = sinCache1b[j];
-            costemp1 = cosCache1b[j];
-            switch(qobj->normals) {
-              case GLU_FLAT:
-              case GLU_SMOOTH:
-                sintemp2 = sinCache2b[j];
-                costemp2 = cosCache2b[j];
-                break;
-              default:
-                break;
-            }
-            for (i = 0; i < slices; i++) {
-                switch(qobj->normals) {
-                  case GLU_FLAT:
-                  case GLU_SMOOTH:
-                    glNormal3f(sinCache2a[i] * sintemp2,
-                            cosCache2a[i] * sintemp2,
-                            costemp2);
-                    break;
-                  case GLU_NONE:
-                  default:
-                    break;
-                }
-
-                zLow = j * radius / stacks;
-
-                if (qobj->textureCoords) {
-                    glTexCoord2f(1 - (float) i / slices,
-                            1 - (float) j / stacks);
-                }
-                glVertex3f(sintemp1 * sinCache1a[i],
-                        sintemp1 * cosCache1a[i], costemp1);
-            }
-        }
-        glEnd();
-        break;
+        glBegin(GL_POINTS);
+        for (j = 0; j <= stacks; j++) {
+            sintemp1 = sinCache1b[j];
+            costemp1 = cosCache1b[j];
+            switch(qobj->normals) {
+              case GLU_FLAT:
+              case GLU_SMOOTH:
+                sintemp2 = sinCache2b[j];
+                costemp2 = cosCache2b[j];
+                break;
+              default:
+                break;
+            }
+            for (i = 0; i < slices; i++) {
+                switch(qobj->normals) {
+                  case GLU_FLAT:
+                  case GLU_SMOOTH:
+                    glNormal3f(sinCache2a[i] * sintemp2,
+                            cosCache2a[i] * sintemp2,
+                            costemp2);
+                    break;
+                  case GLU_NONE:
+                  default:
+                    break;
+                }
+
+                zLow = j * radius / stacks;
+
+                if (qobj->textureCoords) {
+                    glTexCoord2f(1 - (float) i / slices,
+                            1 - (float) j / stacks);
+                }
+                glVertex3f(sintemp1 * sinCache1a[i],
+                        sintemp1 * cosCache1a[i], costemp1);
+            }
+        }
+        glEnd();
+        break;
       case GLU_LINE:
       case GLU_SILHOUETTE:
-        for (j = 1; j < stacks; j++) {
-            sintemp1 = sinCache1b[j];
-            costemp1 = cosCache1b[j];
-            switch(qobj->normals) {
-              case GLU_FLAT:
-              case GLU_SMOOTH:
-                sintemp2 = sinCache2b[j];
-                costemp2 = cosCache2b[j];
-                break;
-              default:
-                break;
-            }
-
-            glBegin(GL_LINE_STRIP);
-            for (i = 0; i <= slices; i++) {
-                switch(qobj->normals) {
-                  case GLU_FLAT:
-                    glNormal3f(sinCache3a[i] * sintemp2,
-                            cosCache3a[i] * sintemp2,
-                            costemp2);
-                    break;
-                  case GLU_SMOOTH:
-                    glNormal3f(sinCache2a[i] * sintemp2,
-                            cosCache2a[i] * sintemp2,
-                            costemp2);
-                    break;
-                  case GLU_NONE:
-                  default:
-                    break;
-                }
-                if (qobj->textureCoords) {
-                    glTexCoord2f(1 - (float) i / slices,
-                            1 - (float) j / stacks);
-                }
-                glVertex3f(sintemp1 * sinCache1a[i],
-                        sintemp1 * cosCache1a[i], costemp1);
-            }
-            glEnd();
-        }
-        for (i = 0; i < slices; i++) {
-            sintemp1 = sinCache1a[i];
-            costemp1 = cosCache1a[i];
-            switch(qobj->normals) {
-              case GLU_FLAT:
-              case GLU_SMOOTH:
-                sintemp2 = sinCache2a[i];
-                costemp2 = cosCache2a[i];
-                break;
-              default:
-                break;
-            }
-
-            glBegin(GL_LINE_STRIP);
-            for (j = 0; j <= stacks; j++) {
-                switch(qobj->normals) {
-                  case GLU_FLAT:
-                    glNormal3f(sintemp2 * sinCache3b[j],
-                            costemp2 * sinCache3b[j],
-                            cosCache3b[j]);
-                    break;
-                  case GLU_SMOOTH:
-                    glNormal3f(sintemp2 * sinCache2b[j],
-                            costemp2 * sinCache2b[j],
-                            cosCache2b[j]);
-                    break;
-                  case GLU_NONE:
-                  default:
-                    break;
-                }
-
-                if (qobj->textureCoords) {
-                    glTexCoord2f(1 - (float) i / slices,
-                            1 - (float) j / stacks);
-                }
-                glVertex3f(sintemp1 * sinCache1b[j],
-                        costemp1 * sinCache1b[j], cosCache1b[j]);
-            }
-            glEnd();
-        }
-        break;
+        for (j = 1; j < stacks; j++) {
+            sintemp1 = sinCache1b[j];
+            costemp1 = cosCache1b[j];
+            switch(qobj->normals) {
+              case GLU_FLAT:
+              case GLU_SMOOTH:
+                sintemp2 = sinCache2b[j];
+                costemp2 = cosCache2b[j];
+                break;
+              default:
+                break;
+            }
+
+            glBegin(GL_LINE_STRIP);
+            for (i = 0; i <= slices; i++) {
+                switch(qobj->normals) {
+                  case GLU_FLAT:
+                    glNormal3f(sinCache3a[i] * sintemp2,
+                            cosCache3a[i] * sintemp2,
+                            costemp2);
+                    break;
+                  case GLU_SMOOTH:
+                    glNormal3f(sinCache2a[i] * sintemp2,
+                            cosCache2a[i] * sintemp2,
+                            costemp2);
+                    break;
+                  case GLU_NONE:
+                  default:
+                    break;
+                }
+                if (qobj->textureCoords) {
+                    glTexCoord2f(1 - (float) i / slices,
+                            1 - (float) j / stacks);
+                }
+                glVertex3f(sintemp1 * sinCache1a[i],
+                        sintemp1 * cosCache1a[i], costemp1);
+            }
+            glEnd();
+        }
+        for (i = 0; i < slices; i++) {
+            sintemp1 = sinCache1a[i];
+            costemp1 = cosCache1a[i];
+            switch(qobj->normals) {
+              case GLU_FLAT:
+              case GLU_SMOOTH:
+                sintemp2 = sinCache2a[i];
+                costemp2 = cosCache2a[i];
+                break;
+              default:
+                break;
+            }
+
+            glBegin(GL_LINE_STRIP);
+            for (j = 0; j <= stacks; j++) {
+                switch(qobj->normals) {
+                  case GLU_FLAT:
+                    glNormal3f(sintemp2 * sinCache3b[j],
+                            costemp2 * sinCache3b[j],
+                            cosCache3b[j]);
+                    break;
+                  case GLU_SMOOTH:
+                    glNormal3f(sintemp2 * sinCache2b[j],
+                            costemp2 * sinCache2b[j],
+                            cosCache2b[j]);
+                    break;
+                  case GLU_NONE:
+                  default:
+                    break;
+                }
+
+                if (qobj->textureCoords) {
+                    glTexCoord2f(1 - (float) i / slices,
+                            1 - (float) j / stacks);
+                }
+                glVertex3f(sintemp1 * sinCache1b[j],
+                        costemp1 * sinCache1b[j], cosCache1b[j]);
+            }
+            glEnd();
+        }
+        break;
       default:
-        break;
+        break;
     }
 }

trunk/src/opengl/glut/glut_event.c

@@ -1 @@
-/* $Id: glut_event.c,v 1.5 2000-03-05 10:19:38 jeroen Exp $ */
+/* $Id: glut_event.c,v 1.6 2000-03-11 09:05:04 jeroen Exp $ */
 /* Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1997, 1998. */
 
@@ -321 +321 @@
 processEventsAndTimeouts(void)
 {
+  WriteLog("processEventsAndTimeouts() entry\n");
   do {
 #if defined(_WIN32) || defined(__WIN32OS2__)
@@ -826 +827 @@
 #endif /* _WIN32 */
     if (__glutTimerList) {
+  WriteLog("processEventsAndTimeouts -> Calling handleTimeouts\n");
       handleTimeouts();
+  WriteLog("processEventsAndTimeouts -> Call handleTimeouts returned\n");
     }
   }
@@ -931 +934 @@
   if (XPending(__glutDisplay)) {
   immediatelyHandleXinput:
+    WriteLog("waitForSmoething: Calling processEventsAndTimeouts\n");
     processEventsAndTimeouts();
+    WriteLog("waitForSmoething: Call processEventsAndTimeouts returned\n");
   } else {
     if (__glutTimerList)
@@ -942 +947 @@
 {
   if (XPending(__glutDisplay)) {
+    WriteLog("idleWait: Calling processEventsAndTimeouts\n");
     processEventsAndTimeouts();
+    WriteLog("idleWait: Call processEventsAndTimeouts returned\n");
   } else {
     if (__glutTimerList) {
@@ -1371 +1378 @@
         waitForSomething();
       } else {
+    WriteLog("glutMainLoop: Calling processEventsAndTimeouts\n");
         processEventsAndTimeouts();
+    WriteLog("glutMainLoop: Call processEventsAndTimeouts returned\n");
       }
     }

trunk/src/opengl/glut/glut_term.c

@@ -1 @@
-/* $Id: glut_term.c,v 1.2 2000-03-04 19:10:15 jeroen Exp $ */
+/* $Id: glut_term.c,v 1.3 2000-03-11 09:05:05 jeroen Exp $ */
 /*
  * GLUT Termination - on exit cleanup any open windows
@@ -6 +6 @@
 
 #include <odinwrap.h>
+#include "glut.h"
 #include "glu.h"
-#include "glut.h"
 #include "glutint.h"
 

trunk/src/opengl/glut/glut_win.c

@@ -1 @@
-/* $Id: glut_win.c,v 1.5 2000-03-05 10:19:38 jeroen Exp $ */
+/* $Id: glut_win.c,v 1.6 2000-03-11 09:05:05 jeroen Exp $ */
 /* Copyright (c) Mark J. Kilgard, 1994, 1997.  */
 
@@ -403 +403 @@
 }
 
-void CDECL
+void GLCALLBACK
 __glutDefaultDisplay(void)
 {
@@ -413 +413 @@
 }
 
-void CDECL
+void GLCALLBACK
 __glutDefaultReshape(int width, int height)
 {
@@ -1003 +1003 @@
 }
 
-static void GLAPIENTRY
+static void GLCALLBACK
 visibilityHelper(int status)
 {

trunk/src/opengl/glut/glutint.h

@@ -1 @@
-/* $Id: glutint.h,v 1.4 2000-03-05 10:19:38 jeroen Exp $ */
+/* $Id: glutint.h,v 1.5 2000-03-11 09:05:05 jeroen Exp $ */
 #ifndef __glutint_h__
 #define __glutint_h__
@@ -253 +253 @@
 
 /* GLUT  function types */
-typedef void (* CDECL GLUTdisplayCB) (void);
-typedef void (* CDECL GLUTreshapeCB) (int, int);
-typedef void (* CDECL GLUTkeyboardCB) (unsigned char, int, int);
-typedef void (* CDECL GLUTmouseCB) (int, int, int, int);
-typedef void (* CDECL GLUTmotionCB) (int, int);
-typedef void (* CDECL GLUTpassiveCB) (int, int);
-typedef void (* CDECL GLUTentryCB) (int);
-typedef void (* CDECL GLUTvisibilityCB) (int);
-typedef void (* CDECL GLUTwindowStatusCB) (int);
-typedef void (* CDECL GLUTidleCB) (void);
-typedef void (* CDECL GLUTtimerCB) (int);
-typedef void (* CDECL GLUTmenuStateCB) (int);  /* DEPRICATED.              */
-typedef void (* CDECL GLUTmenuStatusCB) (int, int, int);
-typedef void (* CDECL GLUTselectCB) (int);
-typedef void (* CDECL GLUTspecialCB) (int, int, int);
-typedef void (* CDECL GLUTspaceMotionCB) (int, int, int);
-typedef void (* CDECL GLUTspaceRotateCB) (int, int, int);
-typedef void (* CDECL GLUTspaceButtonCB) (int, int);
-typedef void (* CDECL GLUTdialsCB) (int, int);
-typedef void (* CDECL GLUTbuttonBoxCB) (int, int);
-typedef void (* CDECL GLUTtabletMotionCB) (int, int);
-typedef void (* CDECL GLUTtabletButtonCB) (int, int, int, int);
-typedef void (* CDECL GLUTjoystickCB) (unsigned int buttonMask, int x, int y, int z);
+typedef void (* GLCALLBACK GLUTdisplayCB) (void);
+typedef void (* GLCALLBACK GLUTreshapeCB) (int, int);
+typedef void (* GLCALLBACK GLUTkeyboardCB) (unsigned char, int, int);
+typedef void (* GLCALLBACK GLUTmouseCB) (int, int, int, int);
+typedef void (* GLCALLBACK GLUTmotionCB) (int, int);
+typedef void (* GLCALLBACK GLUTpassiveCB) (int, int);
+typedef void (* GLCALLBACK GLUTentryCB) (int);
+typedef void (* GLCALLBACK GLUTvisibilityCB) (int);
+typedef void (* GLCALLBACK GLUTwindowStatusCB) (int);
+typedef void (* GLCALLBACK GLUTidleCB) (void);
+typedef void (* GLCALLBACK GLUTtimerCB) (int);
+typedef void (* GLCALLBACK GLUTmenuStateCB) (int);  /* DEPRICATED.              */
+typedef void (* GLCALLBACK GLUTmenuStatusCB) (int, int, int);
+typedef void (* GLCALLBACK GLUTselectCB) (int);
+typedef void (* GLCALLBACK GLUTspecialCB) (int, int, int);
+typedef void (* GLCALLBACK GLUTspaceMotionCB) (int, int, int);
+typedef void (* GLCALLBACK GLUTspaceRotateCB) (int, int, int);
+typedef void (* GLCALLBACK GLUTspaceButtonCB) (int, int);
+typedef void (* GLCALLBACK GLUTdialsCB) (int, int);
+typedef void (* GLCALLBACK GLUTbuttonBoxCB) (int, int);
+typedef void (* GLCALLBACK GLUTtabletMotionCB) (int, int);
+typedef void (* GLCALLBACK GLUTtabletButtonCB) (int, int, int, int);
+typedef void (* GLCALLBACK GLUTjoystickCB) (unsigned int buttonMask, int x, int y, int z);
 #ifdef SUPPORT_FORTRAN
 typedef void (*GLUTdisplayFCB) (void);
@@ -664 +664 @@
 extern GLUTmenuItem *__glutItemSelected;
 extern GLUTmenu **__glutMenuList;
-extern void (* CDECL __glutMenuStatusFunc) (int, int, int);
+extern void (* GLCALLBACK __glutMenuStatusFunc) (int, int, int);
 extern void __glutMenuModificationError(void);
 extern void __glutSetMenuItem(GLUTmenuItem * item,
@@ -746 +746 @@
 extern void __glutReshapeFunc(GLUTreshapeCB reshapeFunc,
   int callingConvention);
-extern void  CDECL __glutDefaultReshape(int, int);
+extern void  GLCALLBACK __glutDefaultReshape(int, int);
 extern GLUTwindow *__glutCreateWindow(
   GLUTwindow * parent,

trunk/src/opengl/glut/win32_menu.c

@@ -1 @@
-/* $Id: win32_menu.c,v 1.3 2000-03-05 10:19:39 jeroen Exp $ */
+/* $Id: win32_menu.c,v 1.4 2000-03-11 09:05:05 jeroen Exp $ */
 /* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
 /* Copyright (c) Nate Robins, 1997. */
@@ -19 +19 @@
 #include "glutint.h"
 
-void (* CDECL __glutMenuStatusFunc) (int, int, int);
+void (* GLCALLBACK __glutMenuStatusFunc) (int, int, int);
 extern GLUTmenu *__glutMappedMenu;
 extern GLUTwindow *__glutMenuWindow;

trunk/src/opengl/mesa/GL/glu.h

@@ -1 @@
-/* $Id: glu.h,v 1.2 2000-02-29 13:56:52 sandervl Exp $ */
+/* $Id: glu.h,v 1.3 2000-03-11 09:05:07 jeroen Exp $ */
 
 /*
@@ -38 +38 @@
 #include "GL/gl.h"
 
-        /* to facilitate clean DLL building ... */
+        /* to facilitate clean DLL building ... */
 #if !defined(OPENSTEP) && (defined(__WIN32__) || defined(__CYGWIN32__))
-#       if defined(_MSC_VER) && defined(BUILD_GLU32) /* tag specify we're building mesa as a DLL */
-#               define GLUAPI __declspec(dllexport)
-#       elif defined(_MSC_VER) && defined(_DLL) /* tag specifying we're building for DLL runtime support */
-#               define GLUAPI __declspec(dllimport)
-#       else /* for use with static link lib build of Win32 edition only */
-#               define GLUAPI extern
-#       endif /* _STATIC_MESA support */
+#       if defined(_MSC_VER) && defined(BUILD_GLU32) /* tag specify we're building mesa as a DLL */
+#               define GLUAPI __declspec(dllexport)
+#       elif defined(_MSC_VER) && defined(_DLL) /* tag specifying we're building for DLL runtime support */
+#               define GLUAPI __declspec(dllimport)
+#       else /* for use with static link lib build of Win32 edition only */
+#               define GLUAPI extern
+#       endif /* _STATIC_MESA support */
 #else
-#       define GLUAPI extern
+#       define GLUAPI extern
 #endif /* WIN32 / CYGWIN32 bracket */
 
 #ifdef macintosh
-        #pragma enumsalwaysint on
-        #if PRAGMA_IMPORT_SUPPORTED
-        #pragma import on
-        #endif
+        #pragma enumsalwaysint on
+        #if PRAGMA_IMPORT_SUPPORTED
+        #pragma import on
+        #endif
 #endif
 
@@ -71 +71 @@
 
 
-#define GLU_VERSION_1_1         1
-#define GLU_VERSION_1_2         1
+#define GLU_VERSION_1_1         1
+#define GLU_VERSION_1_2         1
 
 
@@ -82 +82 @@
 
 enum {
-        /* Normal vectors */
-        GLU_SMOOTH      = 100000,
-        GLU_FLAT        = 100001,
-        GLU_NONE        = 100002,
-
-        /* Quadric draw styles */
-        GLU_POINT       = 100010,
-        GLU_LINE        = 100011,
-        GLU_FILL        = 100012,
-        GLU_SILHOUETTE  = 100013,
-
-        /* Quadric orientation */
-        GLU_OUTSIDE     = 100020,
-        GLU_INSIDE      = 100021,
-
-        /* Tessellator */
-        GLU_TESS_BEGIN          = 100100,
-        GLU_TESS_VERTEX         = 100101,
-        GLU_TESS_END            = 100102,
-        GLU_TESS_ERROR          = 100103,
-        GLU_TESS_EDGE_FLAG      = 100104,
-        GLU_TESS_COMBINE        = 100105,
-
-        GLU_TESS_BEGIN_DATA     = 100106,
-        GLU_TESS_VERTEX_DATA    = 100107,
-        GLU_TESS_END_DATA       = 100108,
-        GLU_TESS_ERROR_DATA     = 100109,
-        GLU_TESS_EDGE_FLAG_DATA = 100110,
-        GLU_TESS_COMBINE_DATA   = 100111,
-
-        /* Winding rules */
-        GLU_TESS_WINDING_ODD            = 100130,
-        GLU_TESS_WINDING_NONZERO        = 100131,
-        GLU_TESS_WINDING_POSITIVE       = 100132,
-        GLU_TESS_WINDING_NEGATIVE       = 100133,
-        GLU_TESS_WINDING_ABS_GEQ_TWO    = 100134,
-
-        /* Tessellation properties */
-        GLU_TESS_WINDING_RULE   = 100140,
-        GLU_TESS_BOUNDARY_ONLY  = 100141,
-        GLU_TESS_TOLERANCE      = 100142,
-
-        /* Tessellation errors */
-        GLU_TESS_ERROR1 = 100151,  /* Missing gluBeginPolygon */
-        GLU_TESS_ERROR2 = 100152,  /* Missing gluBeginContour */
-        GLU_TESS_ERROR3 = 100153,  /* Missing gluEndPolygon */
-        GLU_TESS_ERROR4 = 100154,  /* Missing gluEndContour */
-        GLU_TESS_ERROR5 = 100155,  /* */
-        GLU_TESS_ERROR6 = 100156,  /* */
-        GLU_TESS_ERROR7 = 100157,  /* */
-        GLU_TESS_ERROR8 = 100158,  /* */
+        /* Normal vectors */
+        GLU_SMOOTH      = 100000,
+        GLU_FLAT        = 100001,
+        GLU_NONE        = 100002,
+
+        /* Quadric draw styles */
+        GLU_POINT       = 100010,
+        GLU_LINE        = 100011,
+        GLU_FILL        = 100012,
+        GLU_SILHOUETTE  = 100013,
+
+        /* Quadric orientation */
+        GLU_OUTSIDE     = 100020,
+        GLU_INSIDE      = 100021,
+
+        /* Tessellator */
+        GLU_TESS_BEGIN          = 100100,
+        GLU_TESS_VERTEX         = 100101,
+        GLU_TESS_END            = 100102,
+        GLU_TESS_ERROR          = 100103,
+        GLU_TESS_EDGE_FLAG      = 100104,
+        GLU_TESS_COMBINE        = 100105,
+
+        GLU_TESS_BEGIN_DATA     = 100106,
+        GLU_TESS_VERTEX_DATA    = 100107,
+        GLU_TESS_END_DATA       = 100108,
+        GLU_TESS_ERROR_DATA     = 100109,
+        GLU_TESS_EDGE_FLAG_DATA = 100110,
+        GLU_TESS_COMBINE_DATA   = 100111,
+
+        /* Winding rules */
+        GLU_TESS_WINDING_ODD            = 100130,
+        GLU_TESS_WINDING_NONZERO        = 100131,
+        GLU_TESS_WINDING_POSITIVE       = 100132,
+        GLU_TESS_WINDING_NEGATIVE       = 100133,
+        GLU_TESS_WINDING_ABS_GEQ_TWO    = 100134,
+
+        /* Tessellation properties */
+        GLU_TESS_WINDING_RULE   = 100140,
+        GLU_TESS_BOUNDARY_ONLY  = 100141,
+        GLU_TESS_TOLERANCE      = 100142,
+
+        /* Tessellation errors */
+        GLU_TESS_ERROR1 = 100151,  /* Missing gluBeginPolygon */
+        GLU_TESS_ERROR2 = 100152,  /* Missing gluBeginContour */
+        GLU_TESS_ERROR3 = 100153,  /* Missing gluEndPolygon */
+        GLU_TESS_ERROR4 = 100154,  /* Missing gluEndContour */
+        GLU_TESS_ERROR5 = 100155,  /* */
+        GLU_TESS_ERROR6 = 100156,  /* */
+        GLU_TESS_ERROR7 = 100157,  /* */
+        GLU_TESS_ERROR8 = 100158,  /* */
 
         GLU_TESS_MISSING_BEGIN_POLYGON = GLU_TESS_ERROR1,
@@ -141 +141 @@
         GLU_TESS_NEED_COMBINE_CALLBACK = GLU_TESS_ERROR6,
 
-        /* NURBS */
-        GLU_NURBS_MODE          = 100160,
-        GLU_NURBS_TESSELLATOR   = 100161,
-        GLU_NURBS_RENDERER      = 100162,
-        GLU_NURBS_BEGIN         = 100164,
-        GLU_NURBS_VERTEX        = 100165,
-        GLU_NURBS_NORMAL        = 100166,
-        GLU_NURBS_COLOR         = 100167,
-        GLU_NURBS_TEXTURE_COORD = 100168,
-        GLU_NURBS_END           = 100169,
-        GLU_NURBS_BEGIN_DATA    = 100170,
-        GLU_NURBS_VERTEX_DATA   = 100171,
-        GLU_NURBS_NORMAL_DATA   = 100172,
-        GLU_NURBS_COLOR_DATA    = 100173,
-        GLU_NURBS_TEXTURE_COORD_DATA = 100174,
-        GLU_NURBS_END_DATA      = 100175,
-
-        GLU_AUTO_LOAD_MATRIX    = 100200,
-        GLU_CULLING             = 100201,
-        GLU_PARAMETRIC_TOLERANCE= 100202,
-        GLU_SAMPLING_TOLERANCE  = 100203,
-        GLU_DISPLAY_MODE        = 100204,
-        GLU_SAMPLING_METHOD     = 100205,
-        GLU_U_STEP              = 100206,
-        GLU_V_STEP              = 100207,
-        GLU_OBJECT_PARAMETRIC_ERROR = 100208,
-        GLU_OBJECT_PATH_LENGTH  = 100209,
-
-        GLU_MAP1_TRIM_2         = 100210,
-        GLU_MAP1_TRIM_3         = 100211,
-
-        GLU_PATH_LENGTH         = 100215,
-        GLU_PARAMETRIC_ERROR    = 100216,
-        GLU_DOMAIN_DISTANCE     = 100217,
-
-        GLU_OUTLINE_POLYGON     = 100240,
-        GLU_OUTLINE_PATCH       = 100241,
-
-        GLU_ERROR               = GLU_TESS_ERROR,
+        /* NURBS */
+        GLU_NURBS_MODE          = 100160,
+        GLU_NURBS_TESSELLATOR   = 100161,
+        GLU_NURBS_RENDERER      = 100162,
+        GLU_NURBS_BEGIN         = 100164,
+        GLU_NURBS_VERTEX        = 100165,
+        GLU_NURBS_NORMAL        = 100166,
+        GLU_NURBS_COLOR         = 100167,
+        GLU_NURBS_TEXTURE_COORD = 100168,
+        GLU_NURBS_END           = 100169,
+        GLU_NURBS_BEGIN_DATA    = 100170,
+        GLU_NURBS_VERTEX_DATA   = 100171,
+        GLU_NURBS_NORMAL_DATA   = 100172,
+        GLU_NURBS_COLOR_DATA    = 100173,
+        GLU_NURBS_TEXTURE_COORD_DATA = 100174,
+        GLU_NURBS_END_DATA      = 100175,
+
+        GLU_AUTO_LOAD_MATRIX    = 100200,
+        GLU_CULLING             = 100201,
+        GLU_PARAMETRIC_TOLERANCE= 100202,
+        GLU_SAMPLING_TOLERANCE  = 100203,
+        GLU_DISPLAY_MODE        = 100204,
+        GLU_SAMPLING_METHOD     = 100205,
+        GLU_U_STEP              = 100206,
+        GLU_V_STEP              = 100207,
+        GLU_OBJECT_PARAMETRIC_ERROR = 100208,
+        GLU_OBJECT_PATH_LENGTH  = 100209,
+
+        GLU_MAP1_TRIM_2         = 100210,
+        GLU_MAP1_TRIM_3         = 100211,
+
+        GLU_PATH_LENGTH         = 100215,
+        GLU_PARAMETRIC_ERROR    = 100216,
+        GLU_DOMAIN_DISTANCE     = 100217,
+
+        GLU_OUTLINE_POLYGON     = 100240,
+        GLU_OUTLINE_PATCH       = 100241,
+
+        GLU_ERROR               = GLU_TESS_ERROR,
         GLU_NURBS_ERROR         = GLU_ERROR, /* FIXME: is this correct?? */
 
-        GLU_NURBS_ERROR1  = 100251,   /* spline order un-supported */
-        GLU_NURBS_ERROR2  = 100252,   /* too few knots */
-        GLU_NURBS_ERROR3  = 100253,   /* valid knot range is empty */
-        GLU_NURBS_ERROR4  = 100254,   /* decreasing knot sequence */
-        GLU_NURBS_ERROR5  = 100255,   /* knot multiplicity > spline order */
-        GLU_NURBS_ERROR6  = 100256,   /* endcurve() must follow bgncurve() */
-        GLU_NURBS_ERROR7  = 100257,   /* bgncurve() must precede endcurve() */
-        GLU_NURBS_ERROR8  = 100258,   /* ctrlarray or knot vector is NULL */
-        GLU_NURBS_ERROR9  = 100259,   /* can't draw pwlcurves */
-        GLU_NURBS_ERROR10 = 100260,   /* missing gluNurbsCurve() */
-        GLU_NURBS_ERROR11 = 100261,   /* missing gluNurbsSurface() */
-        GLU_NURBS_ERROR12 = 100262,   /* endtrim() must precede endsurface() */
-        GLU_NURBS_ERROR13 = 100263,   /* bgnsurface() must precede endsurface() */
-        GLU_NURBS_ERROR14 = 100264,   /* curve of improper type passed as trim curve */
-        GLU_NURBS_ERROR15 = 100265,   /* bgnsurface() must precede bgntrim() */
-        GLU_NURBS_ERROR16 = 100266,   /* endtrim() must follow bgntrim() */
-        GLU_NURBS_ERROR17 = 100267,   /* bgntrim() must precede endtrim()*/
-        GLU_NURBS_ERROR18 = 100268,   /* invalid or missing trim curve*/
-        GLU_NURBS_ERROR19 = 100269,   /* bgntrim() must precede pwlcurve() */
-        GLU_NURBS_ERROR20 = 100270,   /* pwlcurve referenced twice*/
-        GLU_NURBS_ERROR21 = 100271,   /* pwlcurve and nurbscurve mixed */
-        GLU_NURBS_ERROR22 = 100272,   /* improper usage of trim data type */
-        GLU_NURBS_ERROR23 = 100273,   /* nurbscurve referenced twice */
-        GLU_NURBS_ERROR24 = 100274,   /* nurbscurve and pwlcurve mixed */
-        GLU_NURBS_ERROR25 = 100275,   /* nurbssurface referenced twice */
-        GLU_NURBS_ERROR26 = 100276,   /* invalid property */
-        GLU_NURBS_ERROR27 = 100277,   /* endsurface() must follow bgnsurface() */
-        GLU_NURBS_ERROR28 = 100278,   /* intersecting or misoriented trim curves */
-        GLU_NURBS_ERROR29 = 100279,   /* intersecting trim curves */
-        GLU_NURBS_ERROR30 = 100280,   /* UNUSED */
-        GLU_NURBS_ERROR31 = 100281,   /* unconnected trim curves */
-        GLU_NURBS_ERROR32 = 100282,   /* unknown knot error */
-        GLU_NURBS_ERROR33 = 100283,   /* negative vertex count encountered */
-        GLU_NURBS_ERROR34 = 100284,   /* negative byte-stride */
-        GLU_NURBS_ERROR35 = 100285,   /* unknown type descriptor */
-        GLU_NURBS_ERROR36 = 100286,   /* null control point reference */
-        GLU_NURBS_ERROR37 = 100287,   /* duplicate point on pwlcurve */
-
-        /* Errors */
-        GLU_INVALID_ENUM                = 100900,
-        GLU_INVALID_VALUE               = 100901,
-        GLU_OUT_OF_MEMORY               = 100902,
-        GLU_INCOMPATIBLE_GL_VERSION     = 100903,
+        GLU_NURBS_ERROR1  = 100251,   /* spline order un-supported */
+        GLU_NURBS_ERROR2  = 100252,   /* too few knots */
+        GLU_NURBS_ERROR3  = 100253,   /* valid knot range is empty */
+        GLU_NURBS_ERROR4  = 100254,   /* decreasing knot sequence */
+        GLU_NURBS_ERROR5  = 100255,   /* knot multiplicity > spline order */
+        GLU_NURBS_ERROR6  = 100256,   /* endcurve() must follow bgncurve() */
+        GLU_NURBS_ERROR7  = 100257,   /* bgncurve() must precede endcurve() */
+        GLU_NURBS_ERROR8  = 100258,   /* ctrlarray or knot vector is NULL */
+        GLU_NURBS_ERROR9  = 100259,   /* can't draw pwlcurves */
+        GLU_NURBS_ERROR10 = 100260,   /* missing gluNurbsCurve() */
+        GLU_NURBS_ERROR11 = 100261,   /* missing gluNurbsSurface() */
+        GLU_NURBS_ERROR12 = 100262,   /* endtrim() must precede endsurface() */
+        GLU_NURBS_ERROR13 = 100263,   /* bgnsurface() must precede endsurface() */
+        GLU_NURBS_ERROR14 = 100264,   /* curve of improper type passed as trim curve */
+        GLU_NURBS_ERROR15 = 100265,   /* bgnsurface() must precede bgntrim() */
+        GLU_NURBS_ERROR16 = 100266,   /* endtrim() must follow bgntrim() */
+        GLU_NURBS_ERROR17 = 100267,   /* bgntrim() must precede endtrim()*/
+        GLU_NURBS_ERROR18 = 100268,   /* invalid or missing trim curve*/
+        GLU_NURBS_ERROR19 = 100269,   /* bgntrim() must precede pwlcurve() */
+        GLU_NURBS_ERROR20 = 100270,   /* pwlcurve referenced twice*/
+        GLU_NURBS_ERROR21 = 100271,   /* pwlcurve and nurbscurve mixed */
+        GLU_NURBS_ERROR22 = 100272,   /* improper usage of trim data type */
+        GLU_NURBS_ERROR23 = 100273,   /* nurbscurve referenced twice */
+        GLU_NURBS_ERROR24 = 100274,   /* nurbscurve and pwlcurve mixed */
+        GLU_NURBS_ERROR25 = 100275,   /* nurbssurface referenced twice */
+        GLU_NURBS_ERROR26 = 100276,   /* invalid property */
+        GLU_NURBS_ERROR27 = 100277,   /* endsurface() must follow bgnsurface() */
+        GLU_NURBS_ERROR28 = 100278,   /* intersecting or misoriented trim curves */
+        GLU_NURBS_ERROR29 = 100279,   /* intersecting trim curves */
+        GLU_NURBS_ERROR30 = 100280,   /* UNUSED */
+        GLU_NURBS_ERROR31 = 100281,   /* unconnected trim curves */
+        GLU_NURBS_ERROR32 = 100282,   /* unknown knot error */
+        GLU_NURBS_ERROR33 = 100283,   /* negative vertex count encountered */
+        GLU_NURBS_ERROR34 = 100284,   /* negative byte-stride */
+        GLU_NURBS_ERROR35 = 100285,   /* unknown type descriptor */
+        GLU_NURBS_ERROR36 = 100286,   /* null control point reference */
+        GLU_NURBS_ERROR37 = 100287,   /* duplicate point on pwlcurve */
+
+        /* Errors */
+        GLU_INVALID_ENUM                = 100900,
+        GLU_INVALID_VALUE               = 100901,
+        GLU_OUT_OF_MEMORY               = 100902,
+        GLU_INCOMPATIBLE_GL_VERSION     = 100903,
         GLU_INVALID_OPERATION           = 100904,
 
-        /* New in GLU 1.1 */
-        GLU_VERSION     = 100800,
-        GLU_EXTENSIONS  = 100801,
-
-        /*** GLU 1.0 tessellation - obsolete! ***/
-
-        /* Contour types */
-        GLU_CW          = 100120,
-        GLU_CCW         = 100121,
-        GLU_INTERIOR    = 100122,
-        GLU_EXTERIOR    = 100123,
-        GLU_UNKNOWN     = 100124,
-
-        /* Tessellator */
-        GLU_BEGIN       = GLU_TESS_BEGIN,
-        GLU_VERTEX      = GLU_TESS_VERTEX,
-        GLU_END         = GLU_TESS_END,
-        GLU_EDGE_FLAG   = GLU_TESS_EDGE_FLAG
+        /* New in GLU 1.1 */
+        GLU_VERSION     = 100800,
+        GLU_EXTENSIONS  = 100801,
+
+        /*** GLU 1.0 tessellation - obsolete! ***/
+
+        /* Contour types */
+        GLU_CW          = 100120,
+        GLU_CCW         = 100121,
+        GLU_INTERIOR    = 100122,
+        GLU_EXTERIOR    = 100123,
+        GLU_UNKNOWN     = 100124,
+
+        /* Tessellator */
+        GLU_BEGIN       = GLU_TESS_BEGIN,
+        GLU_VERTEX      = GLU_TESS_VERTEX,
+        GLU_END         = GLU_TESS_END,
+        GLU_EDGE_FLAG   = GLU_TESS_EDGE_FLAG
 };
 
@@ -360 +360 @@
 
 GLUAPI void GLAPIENTRY gluQuadricCallback( GLUquadricObj *qobj,
-                                         GLenum which, void (GLCALLBACK *fn)() );
+                                           GLenum which,
+                                           void (GLCALLBACK *fn)() );
 
 GLUAPI void GLAPIENTRY gluCylinder( GLUquadricObj *qobj,
@@ -449 +450 @@
 
 GLUAPI void GLAPIENTRY gluTessBeginPolygon( GLUtesselator *tobj,
-                                            void *polygon_data );
+                                            void *polygon_data );
 
 GLUAPI void GLAPIENTRY gluTessBeginContour( GLUtesselator *tobj );
 
 GLUAPI void GLAPIENTRY gluTessVertex( GLUtesselator *tobj, GLdouble coords[3],
-                                      void *vertex_data );
+                                      void *vertex_data );
 
 GLUAPI void GLAPIENTRY gluTessEndContour( GLUtesselator *tobj );
@@ -461 +462 @@
 
 GLUAPI void GLAPIENTRY gluTessProperty( GLUtesselator *tobj, GLenum which,
-                                        GLdouble value );
+                                        GLdouble value );
 
 GLUAPI void GLAPIENTRY gluTessNormal( GLUtesselator *tobj, GLdouble x,
-                                      GLdouble y, GLdouble z );
+                                      GLdouble y, GLdouble z );
 
 GLUAPI void GLAPIENTRY gluTessCallback( GLUtesselator *tobj, GLenum which,
-                                        void (GLCALLBACK *fn)() );
+                                        void (GLCALLBACK *fn)() );
 
 GLUAPI void GLAPIENTRY gluGetTessProperty( GLUtesselator *tobj, GLenum which,
-                                           GLdouble *value );
+                                           GLdouble *value );
 
 /*
@@ -502 +503 @@
 
 #ifdef macintosh
-        #pragma enumsalwaysint reset
-        #if PRAGMA_IMPORT_SUPPORTED
-        #pragma import off
-        #endif
+        #pragma enumsalwaysint reset
+        #if PRAGMA_IMPORT_SUPPORTED
+        #pragma import off
+        #endif
 #endif
 

trunk/src/opengl/mesa/api1.c

@@ -1 @@
-/* $Id: api1.c,v 1.1 2000-02-29 00:49:57 sandervl Exp $ */
+/* $Id: api1.c,v 1.2 2000-03-11 09:05:06 jeroen Exp $ */
 
 /*
@@ -54 +54 @@
 #endif
 
+#include <misc.h>
+
 /*
  * Part 1 of API functions
@@ -85 +87 @@
  * function pointer.
  */
-#define ARRAY_ELT( IM, i )                                      \
-{                                                               \
-   GLuint count = IM->Count;                                    \
-   IM->Elt[count] = i;                                          \
-   IM->Flag[count] = ((IM->Flag[count] & IM->ArrayAndFlags) |   \
-                      VERT_ELT);                                \
-   IM->FlushElt |= IM->ArrayEltFlush;                           \
-   IM->Count = count += IM->ArrayIncr;                          \
-   if (count == VB_MAX)                                         \
-      IM->maybe_transform_vb( IM );                             \
+#define ARRAY_ELT( IM, i )                                      \
+{                                                               \
+   GLuint count = IM->Count;                                    \
+   IM->Elt[count] = i;                                          \
+   IM->Flag[count] = ((IM->Flag[count] & IM->ArrayAndFlags) |   \
+                      VERT_ELT);                                \
+   IM->FlushElt |= IM->ArrayEltFlush;                           \
+   IM->Count = count += IM->ArrayIncr;                          \
+   if (count == VB_MAX)                                         \
+      IM->maybe_transform_vb( IM );                             \
 }
 
@@ -125 +127 @@
    if (mode < GL_POINTS || mode > GL_POLYGON) {
       gl_compile_error( CC, GL_INVALID_ENUM, "glBegin" );
-      return;           
+      return;
    }
 
@@ -251 +253 @@
  * color-material and vertex arrays.
  */
-#define COLOR( IM, r,g,b,a )                    \
-{                                               \
-   GLuint count = IM->Count;                    \
-   IM->Flag[count] |= VERT_RGBA;                \
-   IM->Color[count][0] = r;                     \
-   IM->Color[count][1] = g;                     \
-   IM->Color[count][2] = b;                     \
-   IM->Color[count][3] = a;                     \
+#define COLOR( IM, r,g,b,a )                    \
+{                                               \
+   GLuint count = IM->Count;                    \
+   IM->Flag[count] |= VERT_RGBA;                \
+   IM->Color[count][0] = r;                     \
+   IM->Color[count][1] = g;                     \
+   IM->Color[count][2] = b;                     \
+   IM->Color[count][3] = a;                     \
 }
 
 #if 0
-#define COLOR4F( IM, r,g,b,a )                          \
-{                                                       \
-   GLuint count = IM->Count;                            \
-   IM->Flag[count] |= VERT_RGBA | VERT_FLOAT_RGBA;      \
-   IM->FloatColor[count][0] = r;                        \
-   IM->FloatColor[count][1] = g;                        \
-   IM->FloatColor[count][2] = b;                        \
-   IM->FloatColor[count][3] = a;                        \
+#define COLOR4F( IM, r,g,b,a )                          \
+{                                                       \
+   GLuint count = IM->Count;                            \
+   IM->Flag[count] |= VERT_RGBA | VERT_FLOAT_RGBA;      \
+   IM->FloatColor[count][0] = r;                        \
+   IM->FloatColor[count][1] = g;                        \
+   IM->FloatColor[count][2] = b;                        \
+   IM->FloatColor[count][3] = a;                        \
 }
 #else
-#define COLOR4F(IM, r, g, b, a)                 \
-{                                               \
-   GLubyte col[4];                              \
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);       \
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);       \
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);       \
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[3], a);       \
-   COLORV( IM, col );                           \
+#define COLOR4F(IM, r, g, b, a)                 \
+{                                               \
+   GLubyte col[4];                              \
+   FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);       \
+   FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);       \
+   FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);       \
+   FLOAT_COLOR_TO_UBYTE_COLOR(col[3], a);       \
+   COLORV( IM, col );                           \
 }
 #endif
@@ -285 +287 @@
 
 
-#define COLORV( IM, v )                         \
-{                                               \
-   GLuint count = IM->Count;                    \
-   IM->Flag[count] |= VERT_RGBA;                \
-   COPY_4UBV(IM->Color[count], v);              \
+#define COLORV( IM, v )                         \
+{                                               \
+   GLuint count = IM->Count;                    \
+   IM->Flag[count] |= VERT_RGBA;                \
+   COPY_4UBV(IM->Color[count], v);              \
 }
 
@@ -297 +299 @@
    GET_IMMEDIATE;
    COLOR( IM,
-          BYTE_TO_UBYTE(red),
-          BYTE_TO_UBYTE(green),
-          BYTE_TO_UBYTE(blue),
-          255 );
+          BYTE_TO_UBYTE(red),
+          BYTE_TO_UBYTE(green),
+          BYTE_TO_UBYTE(blue),
+          255 );
 }
 
@@ -339 +341 @@
    GET_IMMEDIATE;
    COLOR( IM, INT_TO_UBYTE(red),
-          INT_TO_UBYTE(green),
-          INT_TO_UBYTE(blue),
-          255);
+          INT_TO_UBYTE(green),
+          INT_TO_UBYTE(blue),
+          255);
 }
 
@@ -349 +351 @@
    GET_IMMEDIATE;
    COLOR( IM, SHORT_TO_UBYTE(red),
-          SHORT_TO_UBYTE(green),
-          SHORT_TO_UBYTE(blue),
-          255);
+          SHORT_TO_UBYTE(green),
+          SHORT_TO_UBYTE(blue),
+          255);
 }
 
@@ -366 +368 @@
    GET_IMMEDIATE;
    COLOR( IM, UINT_TO_UBYTE(red),
-          UINT_TO_UBYTE(green),
-          UINT_TO_UBYTE(blue),
-          255 );
+          UINT_TO_UBYTE(green),
+          UINT_TO_UBYTE(blue),
+          255 );
 }
 
@@ -376 +378 @@
    GET_IMMEDIATE;
    COLOR( IM, USHORT_TO_UBYTE(red), USHORT_TO_UBYTE(green),
-          USHORT_TO_UBYTE(blue),
-          255 );
+          USHORT_TO_UBYTE(blue),
+          255 );
 }
 
@@ -385 +387 @@
    GET_IMMEDIATE;
    COLOR( IM, BYTE_TO_UBYTE(red), BYTE_TO_UBYTE(green),
-          BYTE_TO_UBYTE(blue), BYTE_TO_UBYTE(alpha) );
+          BYTE_TO_UBYTE(blue), BYTE_TO_UBYTE(alpha) );
 }
 
 
 void GLAPIENTRY glColor4d(CTX_ARG GLdouble red, GLdouble green, GLdouble blue,
-                           GLdouble alpha )
+                           GLdouble alpha )
 {
    GLubyte col[4];
@@ -426 +428 @@
    GET_IMMEDIATE;
    COLOR( IM, INT_TO_UBYTE(red), INT_TO_UBYTE(green),
-          INT_TO_UBYTE(blue), INT_TO_UBYTE(alpha) );
+          INT_TO_UBYTE(blue), INT_TO_UBYTE(alpha) );
 }
 
@@ -435 +437 @@
    GET_IMMEDIATE;
    COLOR( IM, SHORT_TO_UBYTE(red), SHORT_TO_UBYTE(green),
-          SHORT_TO_UBYTE(blue), SHORT_TO_UBYTE(alpha) );
+          SHORT_TO_UBYTE(blue), SHORT_TO_UBYTE(alpha) );
 }
 
@@ -450 +452 @@
    GET_IMMEDIATE;
    COLOR( IM, UINT_TO_UBYTE(red), UINT_TO_UBYTE(green),
-          UINT_TO_UBYTE(blue), UINT_TO_UBYTE(alpha) );
+          UINT_TO_UBYTE(blue), UINT_TO_UBYTE(alpha) );
 }
 
@@ -458 +460 @@
    GET_IMMEDIATE;
    COLOR( IM, USHORT_TO_UBYTE(red), USHORT_TO_UBYTE(green),
-          USHORT_TO_UBYTE(blue), USHORT_TO_UBYTE(alpha) );
+          USHORT_TO_UBYTE(blue), USHORT_TO_UBYTE(alpha) );
 }
 
@@ -466 +468 @@
    GET_IMMEDIATE;
    COLOR( IM, BYTE_TO_UBYTE(v[0]), BYTE_TO_UBYTE(v[1]),
-          BYTE_TO_UBYTE(v[2]), 255 );
+          BYTE_TO_UBYTE(v[2]), 255 );
 }
 
@@ -505 +507 @@
    GET_IMMEDIATE;
    COLOR( IM, INT_TO_UBYTE(v[0]), INT_TO_UBYTE(v[1]),
-          INT_TO_UBYTE(v[2]), 255 );
+          INT_TO_UBYTE(v[2]), 255 );
 }
 
@@ -513 +515 @@
    GET_IMMEDIATE;
    COLOR( IM, SHORT_TO_UBYTE(v[0]), SHORT_TO_UBYTE(v[1]),
-          SHORT_TO_UBYTE(v[2]), 255 );
+          SHORT_TO_UBYTE(v[2]), 255 );
 }
 
@@ -528 +530 @@
    GET_IMMEDIATE;
    COLOR( IM, UINT_TO_UBYTE(v[0]), UINT_TO_UBYTE(v[1]),
-          UINT_TO_UBYTE(v[2]), 255 );
+          UINT_TO_UBYTE(v[2]), 255 );
 }
 
@@ -536 +538 @@
    GET_IMMEDIATE;
    COLOR( IM, USHORT_TO_UBYTE(v[0]), USHORT_TO_UBYTE(v[1]),
-          USHORT_TO_UBYTE(v[2]), 255 );
+          USHORT_TO_UBYTE(v[2]), 255 );
 
 }
@@ -545 +547 @@
    GET_IMMEDIATE;
    COLOR( IM, BYTE_TO_UBYTE(v[0]), BYTE_TO_UBYTE(v[1]),
-          BYTE_TO_UBYTE(v[2]), BYTE_TO_UBYTE(v[3]) );
+          BYTE_TO_UBYTE(v[2]), BYTE_TO_UBYTE(v[3]) );
 }
 
@@ -585 +587 @@
    GET_IMMEDIATE;
    COLOR( IM, INT_TO_UBYTE(v[0]), INT_TO_UBYTE(v[1]),
-          INT_TO_UBYTE(v[2]), INT_TO_UBYTE(v[3]) );
+          INT_TO_UBYTE(v[2]), INT_TO_UBYTE(v[3]) );
 }
 
@@ -593 +595 @@
    GET_IMMEDIATE;
    COLOR( IM, SHORT_TO_UBYTE(v[0]), SHORT_TO_UBYTE(v[1]),
-          SHORT_TO_UBYTE(v[2]), SHORT_TO_UBYTE(v[3]) );
+          SHORT_TO_UBYTE(v[2]), SHORT_TO_UBYTE(v[3]) );
 }
 
@@ -608 +610 @@
    GET_IMMEDIATE;
    COLOR( IM, UINT_TO_UBYTE(v[0]), UINT_TO_UBYTE(v[1]),
-          UINT_TO_UBYTE(v[2]), UINT_TO_UBYTE(v[3]) );
+          UINT_TO_UBYTE(v[2]), UINT_TO_UBYTE(v[3]) );
 }
 
@@ -616 +618 @@
    GET_IMMEDIATE;
    COLOR( IM, USHORT_TO_UBYTE(v[0]), USHORT_TO_UBYTE(v[1]),
-          USHORT_TO_UBYTE(v[2]), USHORT_TO_UBYTE(v[3]) );
+          USHORT_TO_UBYTE(v[2]), USHORT_TO_UBYTE(v[3]) );
 }
 
@@ -833 +835 @@
    state = IM->BeginState;
    inflags = (~state) & (VERT_BEGIN_0|VERT_BEGIN_1);
-   state |= inflags << 2;       /* errors */
+   state |= inflags << 2;       /* errors */
 
    if (MESA_VERBOSE&VERBOSE_API) {
       if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-         fprintf(stderr, "glEnd(IM %d), BeginState is %x, errors %x\n",
-                 IM->id, state,
-                 inflags<<2);
+         fprintf(stderr, "glEnd(IM %d), BeginState is %x, errors %x\n",
+                 IM->id, state,
+                 inflags<<2);
       else
-         fprintf(stderr, ">");
+         fprintf(stderr, ">");
    }
 
@@ -857 +859 @@
 
       if (IM->FlushElt) {
-         gl_exec_array_elements( IM->backref, IM, last, count );
-         IM->FlushElt = 0;
+         gl_exec_array_elements( IM->backref, IM, last, count );
+         IM->FlushElt = 0;
       }
    }
@@ -881 +883 @@
    if (MESA_VERBOSE&VERBOSE_API) {
       if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-         fprintf(stderr, "gl_End(IM %d), BeginState is %x, errors %x\n",
-                 IM->id, state,
-                 inflags<<2);
+         fprintf(stderr, "gl_End(IM %d), BeginState is %x, errors %x\n",
+                 IM->id, state,
+                 inflags<<2);
       else
-         fprintf(stderr, ">");
+         fprintf(stderr, ">");
    }
 
-   state |= inflags << 2;       /* errors */
+   state |= inflags << 2;       /* errors */
 
    if (inflags != (VERT_BEGIN_0|VERT_BEGIN_1))
@@ -902 +904 @@
 
       if (IM->FlushElt) {
-         gl_exec_array_elements( ctx, IM, last, count );
-         IM->FlushElt = 0;
+         gl_exec_array_elements( ctx, IM, last, count );
+         IM->FlushElt = 0;
       }
    }
@@ -950 +952 @@
 
 
-#define EVALCOORD1(IM, x)                               \
-{                                                       \
-   GLuint count = IM->Count++;                          \
-   IM->Flag[count] |= VERT_EVAL_C1;                     \
-   ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);               \
-   if (count == VB_MAX-1)                               \
-      IM->maybe_transform_vb( IM );                     \
-}
-
-#define EVALCOORD2(IM, x, y)                            \
-{                                                       \
-   GLuint count = IM->Count++;                          \
-   IM->Flag[count] |= VERT_EVAL_C2;                     \
-   ASSIGN_4V(IM->Obj[count], x, y, 0, 1);               \
-   if (count == VB_MAX-1)                               \
-      IM->maybe_transform_vb( IM );                     \
-}
-
-#define EVALPOINT1(IM, x)                               \
-{                                                       \
-   GLuint count = IM->Count++;                          \
-   IM->Flag[count] |= VERT_EVAL_P1;                     \
-   ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);               \
-   if (count == VB_MAX-1)                               \
-      IM->maybe_transform_vb( IM );                     \
-}
-
-#define EVALPOINT2(IM, x, y)                            \
-{                                                       \
-   GLuint count = IM->Count++;                          \
-   IM->Flag[count] |= VERT_EVAL_P2;                     \
-   ASSIGN_4V(IM->Obj[count], x, y, 0, 1);               \
-   if (count == VB_MAX-1)                               \
-      IM->maybe_transform_vb( IM );                     \
+#define EVALCOORD1(IM, x)                               \
+{                                                       \
+   GLuint count = IM->Count++;                          \
+   IM->Flag[count] |= VERT_EVAL_C1;                     \
+   ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);               \
+   if (count == VB_MAX-1)                               \
+      IM->maybe_transform_vb( IM );                     \
+}
+
+#define EVALCOORD2(IM, x, y)                            \
+{                                                       \
+   GLuint count = IM->Count++;                          \
+   IM->Flag[count] |= VERT_EVAL_C2;                     \
+   ASSIGN_4V(IM->Obj[count], x, y, 0, 1);               \
+   WriteLog("OPENGL32: EVALCOORD2 (%f,%f) IM: %08X - cnt %d\n",x,y,IM,count); \
+   if (count == VB_MAX-1)                               \
+   {WriteLog("OPENGL32: EVALCOORD2 is calling maybe_transform\n"); \
+      IM->maybe_transform_vb( IM );                     }\
+}
+
+#define EVALPOINT1(IM, x)                               \
+{                                                       \
+   GLuint count = IM->Count++;                          \
+   IM->Flag[count] |= VERT_EVAL_P1;                     \
+   ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);               \
+   if (count == VB_MAX-1)                               \
+      IM->maybe_transform_vb( IM );                     \
+}
+
+#define EVALPOINT2(IM, x, y)                            \
+{                                                       \
+   GLuint count = IM->Count++;                          \
+   IM->Flag[count] |= VERT_EVAL_P2;                     \
+   ASSIGN_4V(IM->Obj[count], x, y, 0, 1);               \
+   if (count == VB_MAX-1)                               \
+      IM->maybe_transform_vb( IM );                     \
 }
 
@@ -1173 +1177 @@
       case GL_FOG_END:
       case GL_FOG_INDEX:
-         p[0] = (GLfloat) *params;
-         break;
+         p[0] = (GLfloat) *params;
+         break;
       case GL_FOG_COLOR:
-         p[0] = INT_TO_FLOAT( params[0] );
-         p[1] = INT_TO_FLOAT( params[1] );
-         p[2] = INT_TO_FLOAT( params[2] );
-         p[3] = INT_TO_FLOAT( params[3] );
-         break;
+         p[0] = INT_TO_FLOAT( params[0] );
+         p[1] = INT_TO_FLOAT( params[1] );
+         p[2] = INT_TO_FLOAT( params[2] );
+         p[3] = INT_TO_FLOAT( params[3] );
+         break;
       default:
          /* Error will be caught later in gl_Fogfv */
@@ -1477 +1481 @@
 
 
-#define INDEX( c )                              \
-{                                               \
-   GLuint count;                                \
-   GET_IMMEDIATE;                               \
-   count = IM->Count;                           \
-   IM->Index[count] = c;                        \
-   IM->Flag[count] |= VERT_INDEX;               \
+#define INDEX( c )                              \
+{                                               \
+   GLuint count;                                \
+   GET_IMMEDIATE;                               \
+   count = IM->Count;                           \
+   IM->Index[count] = c;                        \
+   IM->Flag[count] |= VERT_INDEX;               \
 }
 
@@ -1740 +1744 @@
 
    for (i=0;i<16;i++) {
-          fm[i] = (GLfloat) m[i];
+          fm[i] = (GLfloat) m[i];
    }
 
@@ -1946 +1950 @@
 
    for (i=0;i<16;i++) {
-          fm[i] = (GLfloat) m[i];
+          fm[i] = (GLfloat) m[i];
    }
 
@@ -1974 +1978 @@
  *     (ie shared) normals.
  */
-#define NORMAL( x,y,z )                         \
-{                                               \
-   GLuint count;                                \
-   GLfloat *normal;                             \
-   GET_IMMEDIATE;                               \
-   count = IM->Count;                           \
-   IM->Flag[count] |= VERT_NORM;                \
-   normal = IM->Normal[count];                  \
-   ASSIGN_3V(normal, x,y,z);                    \
+#define NORMAL( x,y,z )                         \
+{                                               \
+   GLuint count;                                \
+   GLfloat *normal;                             \
+   GET_IMMEDIATE;                               \
+   count = IM->Count;                           \
+   IM->Flag[count] |= VERT_NORM;                \
+   normal = IM->Normal[count];                  \
+   ASSIGN_3V(normal, x,y,z);                    \
 }
 
@@ -1989 +1993 @@
 {
    NORMAL( BYTE_TO_FLOAT(nx),
-           BYTE_TO_FLOAT(ny),
-           BYTE_TO_FLOAT(nz) );
+           BYTE_TO_FLOAT(ny),
+           BYTE_TO_FLOAT(nz) );
 }
 
@@ -2009 +2013 @@
 {
    NORMAL( INT_TO_FLOAT(nx),
-           INT_TO_FLOAT(ny),
-           INT_TO_FLOAT(nz) );
+           INT_TO_FLOAT(ny),
+           INT_TO_FLOAT(nz) );
 }
 
@@ -2017 +2021 @@
 {
    NORMAL( SHORT_TO_FLOAT(nx),
-           SHORT_TO_FLOAT(ny),
-           SHORT_TO_FLOAT(nz) );
+           SHORT_TO_FLOAT(ny),
+           SHORT_TO_FLOAT(nz) );
 }
 
@@ -2025 +2029 @@
 {
    NORMAL( BYTE_TO_FLOAT(v[0]),
-           BYTE_TO_FLOAT(v[1]),
-           BYTE_TO_FLOAT(v[2]) );
+           BYTE_TO_FLOAT(v[1]),
+           BYTE_TO_FLOAT(v[2]) );
 }
 
@@ -2045 +2049 @@
 {
    NORMAL( INT_TO_FLOAT(v[0]),
-           INT_TO_FLOAT(v[1]),
-           INT_TO_FLOAT(v[2]) );
+           INT_TO_FLOAT(v[1]),
+           INT_TO_FLOAT(v[2]) );
 }
 
@@ -2053 +2057 @@
 {
    NORMAL( SHORT_TO_FLOAT(v[0]),
-           SHORT_TO_FLOAT(v[1]),
-           SHORT_TO_FLOAT(v[2]) );
-}
-
+           SHORT_TO_FLOAT(v[1]),
+           SHORT_TO_FLOAT(v[2]) );
+}
+