Updated demo for new GLU 1.3 tessellation. Added optimized rendering
authorGareth Hughes <gareth@valinux.com>
Thu, 4 Nov 1999 04:00:42 +0000 (04:00 +0000)
committerGareth Hughes <gareth@valinux.com>
Thu, 4 Nov 1999 04:00:42 +0000 (04:00 +0000)
by saving the output of the tessellation into display lists.

progs/demos/tessdemo.c

index c0d0242b2e8f0329d313f310b0333d30b0580d05..7b3cf9e7025bc5aa535e97e92e0e66f744fe5e7d 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: tessdemo.c,v 1.2 1999/09/19 20:09:00 tanner Exp $ */
+/* $Id: tessdemo.c,v 1.3 1999/11/04 04:00:42 gareth Exp $ */
 
 /*
  * A demo of the GLU polygon tesselation functions written by Bogdan Sikorski.
@@ -8,9 +8,16 @@
    cc -g -ansi -prototypes -fullwarn -float -I../include -DSHM tess_demo.c -L../lib -lglut -lMesaGLU -lMesaGL -lm -lX11 -lXext -lXmu -lfpe -lXext -o tess_demo
  */
 
+/*
+ * Updated for GLU 1.3 tessellation by Gareth Hughes <garethh@bell-labs.com>
+ */
 
 /*
  * $Log: tessdemo.c,v $
+ * Revision 1.3  1999/11/04 04:00:42  gareth
+ * Updated demo for new GLU 1.3 tessellation.  Added optimized rendering
+ * by saving the output of the tessellation into display lists.
+ *
  * Revision 1.2  1999/09/19 20:09:00  tanner
  *
  * lots of autoconf updates
 #include <stdlib.h>
 #include <string.h>
 
-#define MAX_POINTS 200
-#define MAX_CONTOURS 50
-
-int menu;
-typedef enum{ QUIT, TESSELATE, CLEAR } menu_entries;
-typedef enum{ DEFINE, TESSELATED } mode_type;
-struct
-{
-       GLint p[MAX_POINTS][2];
-       GLuint point_cnt;
-} contours[MAX_CONTOURS];
-GLuint contour_cnt;
-GLsizei width,height;
-mode_type mode;
-
-struct
-{
-       GLsizei no;
-       GLfloat color[3];
-       GLint p[3][2];
-       GLclampf p_color[3][3];
-} triangle;
-
+#define MAX_POINTS     256
+#define MAX_CONTOURS   32
+#define MAX_TRIANGLES  256
 
 #ifndef GLCALLBACK
 #ifdef CALLBACK
@@ -76,368 +63,496 @@ struct
 #endif
 #endif
 
+typedef enum{ QUIT, TESSELATE, CLEAR } menu_entries;
+typedef enum{ DEFINE, TESSELATED } mode_type;
+
+static GLsizei         width, height;
+static GLuint          contour_cnt;
+static GLuint          triangle_cnt;
 
-void GLCALLBACK my_error(GLenum err)
+static mode_type       mode;
+static int             menu;
+
+static GLuint          list_start;
+
+static GLfloat         edge_color[3];
+
+static struct
 {
-       int len,i;
-       char const *str;
-
-       glColor3f(0.9,0.9,0.9);
-       glRasterPos2i(5,5);
-       str=(const char *)gluErrorString(err);
-       len=strlen(str);
-       for(i=0;i<len;i++)
-               glutBitmapCharacter(GLUT_BITMAP_9_BY_15,str[i]);
+   GLint       p[MAX_POINTS][2];
+   GLuint      point_cnt;
+} contours[MAX_CONTOURS];
+
+static struct
+{
+   GLsizei     no;
+   GLint       p[3][2];
+   GLclampf    color[3][3];
+} triangles[MAX_TRIANGLES];
+
+
+
+void GLCALLBACK my_error( GLenum err )
+{
+   int         len, i;
+   char const  *str;
+
+   glColor3f( 0.9, 0.9, 0.9 );
+   glRasterPos2i( 5, 5 );
+
+   str = (const char *) gluErrorString( err );
+   len = strlen( str );
+
+   for ( i = 0 ; i < len ; i++ ) {
+      glutBitmapCharacter( GLUT_BITMAP_9_BY_15, str[i] );
+   }
 }
 
-void GLCALLBACK begin_callback(GLenum mode)
+void GLCALLBACK begin_callback( GLenum mode )
 {
-       triangle.no=0;
+   /* Allow multiple triangles to be output inside the begin/end pair. */
+   triangle_cnt = 0;
+   triangles[triangle_cnt].no = 0;
 }
 
-void GLCALLBACK edge_callback(GLenum flag)
+void GLCALLBACK edge_callback( GLenum flag )
 {
-       if(flag==GL_TRUE)
-       {
-               triangle.color[0]=1.0;
-               triangle.color[1]=1.0;
-               triangle.color[2]=0.5;
-       }
-       else
-       {
-               triangle.color[0]=1.0;
-               triangle.color[1]=0.0;
-               triangle.color[2]=0.0;
-       }
+   /* Persist the edge flag across triangles. */
+   if ( flag == GL_TRUE )
+   {
+      edge_color[0] = 1.0;
+      edge_color[1] = 1.0;
+      edge_color[2] = 0.5;
+   }
+   else
+   {
+      edge_color[0] = 1.0;
+      edge_color[1] = 0.0;
+      edge_color[2] = 0.0;
+   }
 }
 
 void GLCALLBACK end_callback()
 {
-       glBegin(GL_LINES);
-       glColor3f(triangle.p_color[0][0],triangle.p_color[0][1],
-               triangle.p_color[0][2]);
-       glVertex2i(triangle.p[0][0],triangle.p[0][1]);
-       glVertex2i(triangle.p[1][0],triangle.p[1][1]);
-       glColor3f(triangle.p_color[1][0],triangle.p_color[1][1],
-               triangle.p_color[1][2]);
-       glVertex2i(triangle.p[1][0],triangle.p[1][1]);
-       glVertex2i(triangle.p[2][0],triangle.p[2][1]);
-       glColor3f(triangle.p_color[2][0],triangle.p_color[2][1],
-               triangle.p_color[2][2]);
-       glVertex2i(triangle.p[2][0],triangle.p[2][1]);
-       glVertex2i(triangle.p[0][0],triangle.p[0][1]);
-       glEnd();
+   GLint       i;
+
+   glBegin( GL_LINES );
+
+   /* Output the three edges of each triangle as lines colored
+      according to their edge flag. */
+   for ( i = 0 ; i < triangle_cnt ; i++ )
+   {
+      glColor3f( triangles[i].color[0][0],
+                triangles[i].color[0][1],
+                triangles[i].color[0][2] );
+
+      glVertex2i( triangles[i].p[0][0], triangles[i].p[0][1] );
+      glVertex2i( triangles[i].p[1][0], triangles[i].p[1][1] );
+
+      glColor3f( triangles[i].color[1][0],
+                triangles[i].color[1][1],
+                triangles[i].color[1][2] );
+
+      glVertex2i( triangles[i].p[1][0], triangles[i].p[1][1] );
+      glVertex2i( triangles[i].p[2][0], triangles[i].p[2][1] );
+
+      glColor3f( triangles[i].color[2][0],
+                triangles[i].color[2][1],
+                triangles[i].color[2][2] );
+
+      glVertex2i( triangles[i].p[2][0], triangles[i].p[2][1] );
+      glVertex2i( triangles[i].p[0][0], triangles[i].p[0][1] );
+   }
+
+   glEnd();
 }
 
-void GLCALLBACK vertex_callback(void *data)
+void GLCALLBACK vertex_callback( void *data )
 {
-       GLsizei no;
-       GLint *p;
-
-       p=(GLint *)data;
-       no=triangle.no;
-       triangle.p[no][0]=p[0];
-       triangle.p[no][1]=p[1];
-       triangle.p_color[no][0]=triangle.color[0];
-       triangle.p_color[no][1]=triangle.color[1];
-       triangle.p_color[no][2]=triangle.color[2];
-       ++(triangle.no);
+   GLsizei     no;
+   GLint       *p;
+
+   p = (GLint *) data;
+   no = triangles[triangle_cnt].no;
+
+   triangles[triangle_cnt].p[no][0] = p[0];
+   triangles[triangle_cnt].p[no][1] = p[1];
+
+   triangles[triangle_cnt].color[no][0] = edge_color[0];
+   triangles[triangle_cnt].color[no][1] = edge_color[1];
+   triangles[triangle_cnt].color[no][2] = edge_color[2];
+
+   /* After every three vertices, initialize the next triangle. */
+   if ( ++(triangles[triangle_cnt].no) == 3 )
+   {
+      triangle_cnt++;
+      triangles[triangle_cnt].no = 0;
+   }
 }
 
-void set_screen_wh(GLsizei w, GLsizei h)
+void set_screen_wh( GLsizei w, GLsizei h )
 {
-       width=w;
-       height=h;
+   width = w;
+   height = h;
 }
 
-void tesse(void)
+void tesse( void )
 {
-       GLUtesselator *tobj;
-       GLdouble data[3];
-       GLuint i,j,point_cnt;
-
-       tobj=gluNewTess();
-       if(tobj!=NULL)
-       {
-               glClear(GL_COLOR_BUFFER_BIT);
-               glColor3f (0.7, 0.7, 0.0);
-               gluTessCallback(tobj,GLU_BEGIN,glBegin);
-               gluTessCallback(tobj,GLU_END,glEnd);
-               gluTessCallback(tobj,GLU_ERROR,my_error);
-               gluTessCallback(tobj,GLU_VERTEX,glVertex2iv);
-               gluBeginPolygon(tobj);
-               for(j=0;j<=contour_cnt;j++)
-               {
-                       point_cnt=contours[j].point_cnt;
-                       gluNextContour(tobj,GLU_UNKNOWN);
-                       for(i=0;i<point_cnt;i++)
-                       {
-                               data[0]=(GLdouble)(contours[j].p[i][0]);
-                               data[1]=(GLdouble)(contours[j].p[i][1]);
-                               data[2]=0.0;
-                               gluTessVertex(tobj,data,contours[j].p[i]);
-                       }
-               }
-               gluEndPolygon(tobj);
-               glLineWidth(2.0);
-               gluTessCallback(tobj,GLU_BEGIN,begin_callback);
-               gluTessCallback(tobj,GLU_END,end_callback);
-               gluTessCallback(tobj,GLU_VERTEX,vertex_callback);
-               gluTessCallback(tobj,GLU_EDGE_FLAG,edge_callback);
-               gluBeginPolygon(tobj);
-               for(j=0;j<=contour_cnt;j++)
-               {
-                       point_cnt=contours[j].point_cnt;
-                       gluNextContour(tobj,GLU_UNKNOWN);
-                       for(i=0;i<point_cnt;i++)
-                       {
-                               data[0]=(GLdouble)(contours[j].p[i][0]);
-                               data[1]=(GLdouble)(contours[j].p[i][1]);
-                               data[2]=0.0;
-                               gluTessVertex(tobj,data,contours[j].p[i]);
-                       }
-               }
-               gluEndPolygon(tobj);
-               gluDeleteTess(tobj);
-               glutMouseFunc(NULL);
-               glColor3f (1.0, 1.0, 0.0);
-               glLineWidth(1.0);
-               mode=TESSELATED;
-       }
+   GLUtesselator       *tobj;
+   GLdouble            data[3];
+   GLuint              i, j, point_cnt;
+
+   list_start = glGenLists( 2 );
+
+   tobj = gluNewTess();
+
+   if ( tobj != NULL )
+   {
+      gluTessCallback( tobj, GLU_BEGIN, glBegin );
+      gluTessCallback( tobj, GLU_VERTEX, glVertex2iv );
+      gluTessCallback( tobj, GLU_END, glEnd );
+      gluTessCallback( tobj, GLU_ERROR, my_error );
+
+      glNewList( list_start, GL_COMPILE );
+      gluBeginPolygon( tobj );
+
+      for ( j = 0 ; j <= contour_cnt ; j++ )
+      {
+        point_cnt = contours[j].point_cnt;
+        gluNextContour( tobj, GLU_UNKNOWN );
+
+        for ( i = 0 ; i < point_cnt ; i++ )
+        {
+           data[0] = (GLdouble)( contours[j].p[i][0] );
+           data[1] = (GLdouble)( contours[j].p[i][1] );
+           data[2] = 0.0;
+           gluTessVertex( tobj, data, contours[j].p[i] );
+        }
+      }
+
+      gluEndPolygon( tobj );
+      glEndList();
+
+      gluTessCallback( tobj, GLU_BEGIN, begin_callback );
+      gluTessCallback( tobj, GLU_VERTEX, vertex_callback );
+      gluTessCallback( tobj, GLU_END, end_callback );
+      gluTessCallback( tobj, GLU_EDGE_FLAG, edge_callback );
+
+      glNewList( list_start + 1, GL_COMPILE );
+      gluBeginPolygon( tobj );
+
+      for ( j = 0 ; j <= contour_cnt ; j++ )
+      {
+        point_cnt = contours[j].point_cnt;
+        gluNextContour( tobj, GLU_UNKNOWN );
+
+        for ( i = 0 ; i < point_cnt ; i++ )
+        {
+           data[0] = (GLdouble)( contours[j].p[i][0] );
+           data[1] = (GLdouble)( contours[j].p[i][1] );
+           data[2] = 0.0;
+           gluTessVertex( tobj, data, contours[j].p[i] );
+        }
+      }
+
+      gluEndPolygon( tobj );
+      glEndList();
+
+      gluDeleteTess( tobj );
+
+      glutMouseFunc( NULL );
+      mode = TESSELATED;
+   }
 }
 
-void left_down(int x1,int y1)
+void left_down( int x1, int y1 )
 {
-       GLint P[2];
-       GLuint point_cnt;
-
-       /* translate GLUT into GL coordinates */
-       P[0]=x1;
-       P[1]=height-y1;
-       point_cnt=contours[contour_cnt].point_cnt;
-       contours[contour_cnt].p[point_cnt][0]=P[0];
-       contours[contour_cnt].p[point_cnt][1]=P[1];
-    glBegin(GL_LINES);
-    if(point_cnt)
-    {
-        glVertex2iv(contours[contour_cnt].p[point_cnt-1]);
-        glVertex2iv(P);
-    }
-    else
-    {
-        glVertex2iv(P);
-        glVertex2iv(P);
-    }
-    glEnd();
-    glFinish();
-       ++(contours[contour_cnt].point_cnt);
+   GLint       P[2];
+   GLuint      point_cnt;
+
+   /* translate GLUT into GL coordinates */
+
+   P[0] = x1;
+   P[1] = height - y1;
+
+   point_cnt = contours[contour_cnt].point_cnt;
+
+   contours[contour_cnt].p[point_cnt][0] = P[0];
+   contours[contour_cnt].p[point_cnt][1] = P[1];
+
+   glBegin( GL_LINES );
+
+   if ( point_cnt )
+   {
+      glVertex2iv( contours[contour_cnt].p[point_cnt-1] );
+      glVertex2iv( P );
+   }
+   else
+   {
+      glVertex2iv( P );
+      glVertex2iv( P );
+   }
+
+   glEnd();
+   glFinish();
+
+   contours[contour_cnt].point_cnt++;
 }
 
-void middle_down(int x1, int y1)
+void middle_down( int x1, int y1 )
 {
-       GLuint point_cnt;
-        (void) x1;
-        (void) y1;
-
-       point_cnt=contours[contour_cnt].point_cnt;
-       if(point_cnt>2)
-       {
-               glBegin(GL_LINES);
-               glVertex2iv(contours[contour_cnt].p[0]);
-               glVertex2iv(contours[contour_cnt].p[point_cnt-1]);
-               contours[contour_cnt].p[point_cnt][0]= -1;
-               glEnd();
-               glFinish();
-               contour_cnt++;
-               contours[contour_cnt].point_cnt=0;
-       }
+   GLuint      point_cnt;
+   (void) x1;
+   (void) y1;
+
+   point_cnt = contours[contour_cnt].point_cnt;
+
+   if ( point_cnt > 2 )
+   {
+      glBegin( GL_LINES );
+
+      glVertex2iv( contours[contour_cnt].p[0] );
+      glVertex2iv( contours[contour_cnt].p[point_cnt-1] );
+
+      contours[contour_cnt].p[point_cnt][0] = -1;
+
+      glEnd();
+      glFinish();
+
+      contour_cnt++;
+      contours[contour_cnt].point_cnt = 0;
+   }
 }
 
-void mouse_clicked(int button,int state,int x,int y)
+void mouse_clicked( int button, int state, int x, int y )
 {
-       x-= x%10;
-       y-= y%10;
-       switch(button)
-       {
-               case GLUT_LEFT_BUTTON:
-                       if(state==GLUT_DOWN)
-                               left_down(x,y);
-                       break;
-               case GLUT_MIDDLE_BUTTON:
-                       if(state==GLUT_DOWN)
-                               middle_down(x,y);
-                       break;
-       }
+   x -= x%10;
+   y -= y%10;
+
+   switch ( button )
+   {
+   case GLUT_LEFT_BUTTON:
+      if ( state == GLUT_DOWN ) {
+        left_down( x, y );
+      }
+      break;
+   case GLUT_MIDDLE_BUTTON:
+      if ( state == GLUT_DOWN ) {
+        middle_down( x, y );
+      }
+      break;
+   }
 }
 
-void display(void)
+void display( void )
 {
-       GLuint i,j;
-       GLuint point_cnt;
-
-    glClear(GL_COLOR_BUFFER_BIT);
-    switch(mode)
-    {
-       case DEFINE:
-                       /* draw grid */
-                       glColor3f (0.6,0.5,0.5);
-                       glBegin(GL_LINES);
-                       for(i=0;i<width;i+=10)
-                               for(j=0;j<height;j+=10)
-                               {
-                                       glVertex2i(0,j);
-                                       glVertex2i(width,j);
-                                       glVertex2i(i,height);
-                                       glVertex2i(i,0);
-                       }
-                       glColor3f (1.0, 1.0, 0.0);
-                       for(i=0;i<=contour_cnt;i++)
-                       {
-                               point_cnt=contours[i].point_cnt;
-                               glBegin(GL_LINES);
-                               switch(point_cnt)
-                               {
-                                       case 0:
-                                               break;
-                                       case 1:
-                                               glVertex2iv(contours[i].p[0]);
-                                               glVertex2iv(contours[i].p[0]);
-                                               break;
-                                       case 2:
-                                               glVertex2iv(contours[i].p[0]);
-                                               glVertex2iv(contours[i].p[1]);
-                                               break;
-                                       default:
-                                               --point_cnt;
-                                               for(j=0;j<point_cnt;j++)
-                                               {
-                                                       glVertex2iv(contours[i].p[j]);
-                                                       glVertex2iv(contours[i].p[j+1]);
-                                               }
-                                               if(contours[i].p[j+1][0]== -1)
-                                               {
-                                                       glVertex2iv(contours[i].p[0]);
-                                                       glVertex2iv(contours[i].p[j]);
-                                               }
-                                               break;
-                               }
-                               glEnd();
-                       }
-                       glFinish();
-                       break;
-               case TESSELATED:
-                       /* draw lines */
-                       tesse();
-                       break;
-       }
-
-    glColor3f (1.0, 1.0, 0.0);
+   GLuint i,j;
+   GLuint point_cnt;
+
+   glClear( GL_COLOR_BUFFER_BIT );
+
+   switch ( mode )
+   {
+   case DEFINE:
+      /* draw grid */
+      glColor3f( 0.6, 0.5, 0.5 );
+
+      glBegin( GL_LINES );
+
+      for ( i = 0 ; i < width ; i += 10 )
+      {
+        for ( j = 0 ; j < height ; j += 10 )
+        {
+           glVertex2i( 0, j );
+           glVertex2i( width, j );
+           glVertex2i( i, height );
+           glVertex2i( i, 0 );
+        }
+      }
+
+      glColor3f( 1.0, 1.0, 0.0 );
+
+      for ( i = 0 ; i <= contour_cnt ; i++ )
+      {
+        point_cnt = contours[i].point_cnt;
+
+        glBegin( GL_LINES );
+
+        switch ( point_cnt )
+        {
+        case 0:
+           break;
+        case 1:
+           glVertex2iv( contours[i].p[0] );
+           glVertex2iv( contours[i].p[0] );
+           break;
+        case 2:
+           glVertex2iv( contours[i].p[0] );
+           glVertex2iv( contours[i].p[1] );
+           break;
+        default:
+           --point_cnt;
+           for ( j = 0 ; j < point_cnt ; j++ )
+           {
+              glVertex2iv( contours[i].p[j] );
+              glVertex2iv( contours[i].p[j+1] );
+           }
+           if ( contours[i].p[j+1][0] == -1 )
+           {
+              glVertex2iv( contours[i].p[0] );
+              glVertex2iv( contours[i].p[j] );
+           }
+           break;
+        }
+
+        glEnd();
+      }
+
+      glFinish();
+      break;
+
+   case TESSELATED:
+      /* draw triangles */
+      glColor3f( 0.7, 0.7, 0.0 );
+      glCallList( list_start );
+
+      glLineWidth( 2.0 );
+      glCallList( list_start + 1 );
+      glLineWidth( 1.0 );
+
+      glFlush();
+      break;
+   }
+
+   glColor3f( 1.0, 1.0, 0.0 );
 }
 
 void clear( void )
 {
-    contour_cnt=0;
-    contours[0].point_cnt=0;
-       glutMouseFunc(mouse_clicked);
-       mode=DEFINE;
-       display();
+   contour_cnt = 0;
+   contours[0].point_cnt = 0;
+   triangle_cnt = 0;
+
+   glutMouseFunc( mouse_clicked );
+
+   mode = DEFINE;
+
+   glDeleteLists( list_start, 2 );
+   list_start = 0;
 }
 
 void quit( void )
 {
-       exit(0);
+   exit( 0 );
 }
 
-void menu_selected(int entry)
+void menu_selected( int entry )
 {
-       switch(entry)
-       {
-               case CLEAR:
-                       clear();
-                       break;
-               case TESSELATE:
-                       tesse();
-                       break;
-               case QUIT:
-                       quit();
-                       break;
-       }
+   switch ( entry )
+   {
+   case CLEAR:
+      clear();
+      break;
+   case TESSELATE:
+      tesse();
+      break;
+   case QUIT:
+      quit();
+      break;
+   }
+
+   glutPostRedisplay();
 }
 
-void key_pressed(unsigned char key,int x,int y)
+void key_pressed( unsigned char key, int x, int y )
 {
-       (void) x;
-       (void) y;
-       switch(key)
-       {
-               case 't':
-               case 'T':
-                       tesse();
-                       glFinish();
-                       break;
-               case 'q':
-               case 'Q':
-                       quit();
-                       break;
-               case 'c':
-               case 'C':
-                       clear();
-                       break;
-       }
+   (void) x;
+   (void) y;
+
+   switch ( key )
+   {
+   case 'c':
+   case 'C':
+      clear();
+      break;
+   case 't':
+   case 'T':
+      tesse();
+      break;
+   case 'q':
+   case 'Q':
+      quit();
+      break;
+   }
+
+   glutPostRedisplay();
 }
 
-void myinit (void) 
+void myinit( void )
 {
-/*  clear background to gray   */
-    glClearColor (0.4, 0.4, 0.4, 0.0);
-    glShadeModel (GL_FLAT);    
-
-       menu=glutCreateMenu(menu_selected);
-       glutAddMenuEntry("clear",CLEAR);
-       glutAddMenuEntry("tesselate",TESSELATE);
-       glutAddMenuEntry("quit",QUIT);
-       glutAttachMenu(GLUT_RIGHT_BUTTON);
-       glutMouseFunc(mouse_clicked);
-       glutKeyboardFunc(key_pressed);
-    contour_cnt=0;
-    glPolygonMode(GL_FRONT,GL_FILL);
-    mode=DEFINE;
+   /* clear background to gray */
+   glClearColor( 0.4, 0.4, 0.4, 0.0 );
+   glShadeModel( GL_FLAT );
+   glPolygonMode( GL_FRONT, GL_FILL );
+
+   menu = glutCreateMenu( menu_selected );
+
+   glutAddMenuEntry( "clear", CLEAR );
+   glutAddMenuEntry( "tesselate", TESSELATE );
+   glutAddMenuEntry( "quit", QUIT );
+
+   glutAttachMenu( GLUT_RIGHT_BUTTON );
+
+   glutMouseFunc( mouse_clicked );
+   glutKeyboardFunc( key_pressed );
+
+   contour_cnt = 0;
+   mode = DEFINE;
 }
 
-static void reshape(GLsizei w, GLsizei h)
+static void reshape( GLsizei w, GLsizei h )
 {
-    glViewport(0, 0, w, h);
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();
-    glOrtho(0.0, (GLdouble)w, 0.0, (GLdouble)h, -1.0, 1.0);
-    glMatrixMode(GL_MODELVIEW);
-    glLoadIdentity();
-    set_screen_wh(w,h);
+   glViewport( 0, 0, w, h );
+
+   glMatrixMode( GL_PROJECTION );
+   glLoadIdentity();
+   glOrtho( 0.0, (GLdouble)w, 0.0, (GLdouble)h, -1.0, 1.0 );
+
+   glMatrixMode( GL_MODELVIEW );
+   glLoadIdentity();
+
+   set_screen_wh( w, h );
 }
 
 
 static void usage( void )
 {
-   printf("Use left mouse button to place vertices.\n");
-   printf("Press middle mouse button when done.\n");
-   printf("Select tesselate from the pop-up menu.\n");
+   printf( "Use left mouse button to place vertices.\n" );
+   printf( "Press middle mouse button when done.\n" );
+   printf( "Select tesselate from the pop-up menu.\n" );
 }
 
 
-/*  Main Loop
- *  Open window with initial window size, title bar, 
- *  RGBA display mode, and handle input events.
+/*
+ * Main Loop
+ * Open window with initial window size, title bar,
+ * RGBA display mode, and handle input events.
  */
-int main(int argc, char** argv)
+int main( int argc, char **argv )
 {
-   usage();
-   glutInit(&argc, argv);
-   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
-   glutInitWindowSize (400, 400);
-   glutCreateWindow (argv[0]);
-   myinit ();
-   glutDisplayFunc(display);
-   glutReshapeFunc(reshape);
-   glutMainLoop();
-   return 0;
+    usage();
+
+    glutInit( &argc, argv );
+    glutInitDisplayMode( GLUT_SINGLE | GLUT_RGB );
+    glutInitWindowSize( 400, 400 );
+    glutCreateWindow( argv[0] );
+
+    myinit();
+
+    glutDisplayFunc( display );
+    glutReshapeFunc( reshape );
+
+    glutMainLoop();
+
+    return 0;
 }