Changeset 3079 for trunk/src/opengl/glu/nurbs

Timestamp:

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

Author:

jeroen

Message:

* empty log message *

Location:

trunk/src/opengl/glu/nurbs

Files:

• interface/glcurveval.cpp (modified) (9 diffs)
• interface/glcurveval.h (modified) (5 diffs)
• interface/glinterface.cpp (modified) (12 diffs)
• interface/glrenderer.h (modified) (5 diffs)
• interface/glsurfeval.cpp (modified) (5 diffs)
• interface/glsurfeval.h (modified) (14 diffs)
• interface/insurfeval.cpp (modified) (21 diffs)
• internals/slicer.cpp (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();
+    }
+}
+
+