eval.c

Go to the documentation of this file.

/* $Id: eval.c,v 1.9 1998/02/03 00:53:51 brianp Exp $ */
 
/*
 * Mesa 3-D graphics library
 * Version:  2.6
 * Copyright (C) 1995-1997  Brian Paul
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
 
/*
 * $Log: eval.c,v $
 * Revision 1.9  1998/02/03 00:53:51  brianp
 * fixed bug in gl_copy_map_points*() functions (Sam Jordan)
 *
 * Revision 1.8  1997/07/24 01:25:01  brianp
 * changed precompiled header symbol from PCH to PC_HEADER
 *
 * Revision 1.7  1997/06/20 01:58:47  brianp
 * changed color components from GLfixed to GLubyte
 *
 * Revision 1.6  1997/05/28 03:24:22  brianp
 * added precompiled header (PCH) support
 *
 * Revision 1.5  1997/05/14 03:27:04  brianp
 * removed context argument from gl_init_eval()
 *
 * Revision 1.4  1997/05/01 01:38:38  brianp
 * use NORMALIZE_3FV() from mmath.h instead of private NORMALIZE() macro
 *
 * Revision 1.3  1997/04/02 03:10:58  brianp
 * changed some #include's
 *
 * Revision 1.2  1996/09/15 14:17:30  brianp
 * now use GLframebuffer and GLvisual
 *
 * Revision 1.1  1996/09/13 01:38:16  brianp
 * Initial revision
 *
 */
 
 
/*
 * eval.c was written by
 * Bernd Barsuhn (bdbarsuh@cip.informatik.uni-erlangen.de) and
 * Volker Weiss (vrweiss@cip.informatik.uni-erlangen.de).
 *
 * My original implementation of evaluators was simplistic and didn't
 * compute surface normal vectors properly.  Bernd and Volker applied
 * used more sophisticated methods to get better results.
 *
 * Thanks guys!
 */
 
 
#ifdef PC_HEADER
#include "all.h"
#else
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "context.h"
#include "eval.h"
#include "dlist.h"
#include "macros.h"
#include "mmath.h"
#include "types.h"
#include "vbfill.h"
#endif
 
 
 
/*
 * Do one-time initialization for evaluators.
 */
void gl_init_eval( void )
{
  static int init_flag = 0;
 
  /* Compute a table of nCr (combination) values used by the
   * Bernstein polynomial generator.
   */
 
  if (init_flag==0) 
  { /* no initialization needed */ 
  }
 
  init_flag = 1;
}
 
 
 
/*
 * Horner scheme for Bezier curves
 * 
 * Bezier curves can be computed via a Horner scheme.
 * Horner is numerically less stable than the de Casteljau
 * algorithm, but it is faster. For curves of degree n 
 * the complexity of Horner is O(n) and de Casteljau is O(n^2).
 * Since stability is not important for displaying curve 
 * points I decided to use the Horner scheme.
 *
 * A cubic Bezier curve with control points b0, b1, b2, b3 can be 
 * written as
 *
 *        (([3]        [3]     )     [3]       )     [3]
 * c(t) = (([0]*s*b0 + [1]*t*b1)*s + [2]*t^2*b2)*s + [3]*t^2*b3
 *
 *                                           [n]
 * where s=1-t and the binomial coefficients [i]. These can 
 * be computed iteratively using the identity:
 *
 * [n]               [n  ]             [n]
 * [i] = (n-i+1)/i * [i-1]     and     [0] = 1
 */
 
static void
horner_bezier_curve(GLfloat *cp, GLfloat *out, GLfloat t,
                    GLuint dim, GLuint order)
{
  GLfloat s, powert;
  GLuint i, k, bincoeff;
 
  if(order >= 2)
  { 
    bincoeff = order-1;
    s = 1.0-t;
 
    for(k=0; k<dim; k++)
      out[k] = s*cp[k] + bincoeff*t*cp[dim+k];
 
    for(i=2, cp+=2*dim, powert=t*t; i<order; i++, powert*=t, cp +=dim)
    {
      bincoeff *= order-i;
      bincoeff /= i;
 
      for(k=0; k<dim; k++)
        out[k] = s*out[k] + bincoeff*powert*cp[k];
    }
  }
  else /* order=1 -> constant curve */
  { 
    for(k=0; k<dim; k++)
      out[k] = cp[k];
  } 
}
 
/*
 * Tensor product Bezier surfaces
 *
 * Again the Horner scheme is used to compute a point on a 
 * TP Bezier surface. First a control polygon for a curve
 * on the surface in one parameter direction is computed,
 * then the point on the curve for the other parameter 
 * direction is evaluated.
 *
 * To store the curve control polygon additional storage
 * for max(uorder,vorder) points is needed in the 
 * control net cn.
 */
 
static void
horner_bezier_surf(GLfloat *cn, GLfloat *out, GLfloat u, GLfloat v,
                   GLuint dim, GLuint uorder, GLuint vorder)
{
  GLfloat *cp = cn + uorder*vorder*dim;
  GLuint i, uinc = vorder*dim;
 
  if(vorder > uorder)
  {
    if(uorder >= 2)
    { 
      GLfloat s, poweru;
      GLuint j, k, bincoeff;
 
      /* Compute the control polygon for the surface-curve in u-direction */
      for(j=0; j<vorder; j++)
      {
        GLfloat *ucp = &cn[j*dim];
 
        /* Each control point is the point for parameter u on a */ 
        /* curve defined by the control polygons in u-direction */
    bincoeff = uorder-1;
    s = 1.0-u;
 
    for(k=0; k<dim; k++)
      cp[j*dim+k] = s*ucp[k] + bincoeff*u*ucp[uinc+k];
 
    for(i=2, ucp+=2*uinc, poweru=u*u; i<uorder; 
            i++, poweru*=u, ucp +=uinc)
    {
      bincoeff *= uorder-i;
          bincoeff /= i;
 
      for(k=0; k<dim; k++)
        cp[j*dim+k] = s*cp[j*dim+k] + bincoeff*poweru*ucp[k];
    }
      }
        
      /* Evaluate curve point in v */
      horner_bezier_curve(cp, out, v, dim, vorder);
    }
    else /* uorder=1 -> cn defines a curve in v */
      horner_bezier_curve(cn, out, v, dim, vorder);
  }
  else /* vorder <= uorder */
  {
    if(vorder > 1)
    {
      GLuint i;
 
      /* Compute the control polygon for the surface-curve in u-direction */
      for(i=0; i<uorder; i++, cn += uinc)
      {
    /* For constant i all cn[i][j] (j=0..vorder) are located */
    /* on consecutive memory locations, so we can use        */
    /* horner_bezier_curve to compute the control points     */
 
    horner_bezier_curve(cn, &cp[i*dim], v, dim, vorder);
      }
 
      /* Evaluate curve point in u */
      horner_bezier_curve(cp, out, u, dim, uorder);
    }
    else  /* vorder=1 -> cn defines a curve in u */
      horner_bezier_curve(cn, out, u, dim, uorder);
  }
}
 
/*
 * The direct de Casteljau algorithm is used when a point on the
 * surface and the tangent directions spanning the tangent plane
 * should be computed (this is needed to compute normals to the
 * surface). In this case the de Casteljau algorithm approach is
 * nicer because a point and the partial derivatives can be computed 
 * at the same time. To get the correct tangent length du and dv
 * must be multiplied with the (u2-u1)/uorder-1 and (v2-v1)/vorder-1. 
 * Since only the directions are needed, this scaling step is omitted.
 *
 * De Casteljau needs additional storage for uorder*vorder
 * values in the control net cn.
 */
 
static void
de_casteljau_surf(GLfloat *cn, GLfloat *out, GLfloat *du, GLfloat *dv,
                  GLfloat u, GLfloat v, GLuint dim, 
                  GLuint uorder, GLuint vorder)
{
  GLfloat *dcn = cn + uorder*vorder*dim;
  GLfloat us = 1.0-u, vs = 1.0-v;
  GLuint h, i, j, k;
  GLuint minorder = uorder < vorder ? uorder : vorder;
  GLuint uinc = vorder*dim;
  GLuint dcuinc = vorder;
 
  /* Each component is evaluated separately to save buffer space  */
  /* This does not drasticaly decrease the performance of the     */
  /* algorithm. If additional storage for (uorder-1)*(vorder-1)   */
  /* points would be available, the components could be accessed  */
  /* in the innermost loop which could lead to less cache misses. */
 
#define CN(I,J,K) cn[(I)*uinc+(J)*dim+(K)] 
#define DCN(I, J) dcn[(I)*dcuinc+(J)]
  if(minorder < 3)
  {
    if(uorder==vorder)
    {
      for(k=0; k<dim; k++)
      {
    /* Derivative direction in u */
    du[k] = vs*(CN(1,0,k) - CN(0,0,k)) +
             v*(CN(1,1,k) - CN(0,1,k));
 
    /* Derivative direction in v */
    dv[k] = us*(CN(0,1,k) - CN(0,0,k)) + 
             u*(CN(1,1,k) - CN(1,0,k));
 
    /* bilinear de Casteljau step */
        out[k] =  us*(vs*CN(0,0,k) + v*CN(0,1,k)) +
               u*(vs*CN(1,0,k) + v*CN(1,1,k));
      }
    }
    else if(minorder == uorder)
    {
      for(k=0; k<dim; k++)
      {
    /* bilinear de Casteljau step */
    DCN(1,0) =    CN(1,0,k) -   CN(0,0,k);
    DCN(0,0) = us*CN(0,0,k) + u*CN(1,0,k);
 
    for(j=0; j<vorder-1; j++)
    {
      /* for the derivative in u */
      DCN(1,j+1) =    CN(1,j+1,k) -   CN(0,j+1,k);
      DCN(1,j)   = vs*DCN(1,j)    + v*DCN(1,j+1);
 
      /* for the `point' */
      DCN(0,j+1) = us*CN(0,j+1,k) + u*CN(1,j+1,k);
      DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
    }
        
    /* remaining linear de Casteljau steps until the second last step */
    for(h=minorder; h<vorder-1; h++)
      for(j=0; j<vorder-h; j++)
      {
        /* for the derivative in u */
        DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
 
        /* for the `point' */
        DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
      }
 
    /* derivative direction in v */
    dv[k] = DCN(0,1) - DCN(0,0);
 
    /* derivative direction in u */
    du[k] =   vs*DCN(1,0) + v*DCN(1,1);
 
    /* last linear de Casteljau step */
    out[k] =  vs*DCN(0,0) + v*DCN(0,1);
      }
    }
    else /* minorder == vorder */
    {
      for(k=0; k<dim; k++)
      {
    /* bilinear de Casteljau step */
    DCN(0,1) =    CN(0,1,k) -   CN(0,0,k);
    DCN(0,0) = vs*CN(0,0,k) + v*CN(0,1,k);
    for(i=0; i<uorder-1; i++)
    {
      /* for the derivative in v */
      DCN(i+1,1) =    CN(i+1,1,k) -   CN(i+1,0,k);
      DCN(i,1)   = us*DCN(i,1)    + u*DCN(i+1,1);
 
      /* for the `point' */
      DCN(i+1,0) = vs*CN(i+1,0,k) + v*CN(i+1,1,k);
      DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
    }
        
    /* remaining linear de Casteljau steps until the second last step */
    for(h=minorder; h<uorder-1; h++)
      for(i=0; i<uorder-h; i++)
      {
        /* for the derivative in v */
        DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
 
        /* for the `point' */
        DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
      }
 
    /* derivative direction in u */
    du[k] = DCN(1,0) - DCN(0,0);
 
    /* derivative direction in v */
    dv[k] =   us*DCN(0,1) + u*DCN(1,1);
 
    /* last linear de Casteljau step */
    out[k] =  us*DCN(0,0) + u*DCN(1,0);
      }
    }
  }
  else if(uorder == vorder)
  {
    for(k=0; k<dim; k++)
    {
      /* first bilinear de Casteljau step */
      for(i=0; i<uorder-1; i++)
      {
    DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
    for(j=0; j<vorder-1; j++)
    {
      DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
      DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
    }
      }
 
      /* remaining bilinear de Casteljau steps until the second last step */
      for(h=2; h<minorder-1; h++)
    for(i=0; i<uorder-h; i++)
    {
      DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
      for(j=0; j<vorder-h; j++)
      {
        DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
        DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
      }
    }
 
      /* derivative direction in u */
      du[k] = vs*(DCN(1,0) - DCN(0,0)) +
           v*(DCN(1,1) - DCN(0,1));
 
      /* derivative direction in v */
      dv[k] = us*(DCN(0,1) - DCN(0,0)) + 
           u*(DCN(1,1) - DCN(1,0));
 
      /* last bilinear de Casteljau step */
      out[k] =  us*(vs*DCN(0,0) + v*DCN(0,1)) +
             u*(vs*DCN(1,0) + v*DCN(1,1));
    }
  }
  else if(minorder == uorder)
  {
    for(k=0; k<dim; k++)
    {
      /* first bilinear de Casteljau step */
      for(i=0; i<uorder-1; i++)
      {
    DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
    for(j=0; j<vorder-1; j++)
    {
      DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
      DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
    }
      }
 
      /* remaining bilinear de Casteljau steps until the second last step */
      for(h=2; h<minorder-1; h++)
    for(i=0; i<uorder-h; i++)
    {
      DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
      for(j=0; j<vorder-h; j++)
      {
        DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
        DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
      }
    }
 
      /* last bilinear de Casteljau step */
      DCN(2,0) =    DCN(1,0) -   DCN(0,0);
      DCN(0,0) = us*DCN(0,0) + u*DCN(1,0);
      for(j=0; j<vorder-1; j++)
      {
    /* for the derivative in u */
    DCN(2,j+1) =    DCN(1,j+1) -    DCN(0,j+1);
    DCN(2,j)   = vs*DCN(2,j)    + v*DCN(2,j+1);
    
    /* for the `point' */
    DCN(0,j+1) = us*DCN(0,j+1 ) + u*DCN(1,j+1);
    DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
      }
        
      /* remaining linear de Casteljau steps until the second last step */
      for(h=minorder; h<vorder-1; h++)
    for(j=0; j<vorder-h; j++)
    {
      /* for the derivative in u */
      DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
      
      /* for the `point' */
      DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
    }
      
      /* derivative direction in v */
      dv[k] = DCN(0,1) - DCN(0,0);
      
      /* derivative direction in u */
      du[k] =   vs*DCN(2,0) + v*DCN(2,1);
      
      /* last linear de Casteljau step */
      out[k] =  vs*DCN(0,0) + v*DCN(0,1);
    }
  }
  else /* minorder == vorder */
  {
    for(k=0; k<dim; k++)
    {
      /* first bilinear de Casteljau step */
      for(i=0; i<uorder-1; i++)
      {
    DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
    for(j=0; j<vorder-1; j++)
    {
      DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
      DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
    }
      }
 
      /* remaining bilinear de Casteljau steps until the second last step */
      for(h=2; h<minorder-1; h++)
    for(i=0; i<uorder-h; i++)
    {
      DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
      for(j=0; j<vorder-h; j++)
      {
        DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
        DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
      }
    }
 
      /* last bilinear de Casteljau step */
      DCN(0,2) =    DCN(0,1) -   DCN(0,0);
      DCN(0,0) = vs*DCN(0,0) + v*DCN(0,1);
      for(i=0; i<uorder-1; i++)
      {
    /* for the derivative in v */
    DCN(i+1,2) =    DCN(i+1,1)  -   DCN(i+1,0);
    DCN(i,2)   = us*DCN(i,2)    + u*DCN(i+1,2);
    
    /* for the `point' */
    DCN(i+1,0) = vs*DCN(i+1,0)  + v*DCN(i+1,1);
    DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
      }
      
      /* remaining linear de Casteljau steps until the second last step */
      for(h=minorder; h<uorder-1; h++)
    for(i=0; i<uorder-h; i++)
    {
      /* for the derivative in v */
      DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
      
      /* for the `point' */
      DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
    }
      
      /* derivative direction in u */
      du[k] = DCN(1,0) - DCN(0,0);
      
      /* derivative direction in v */
      dv[k] =   us*DCN(0,2) + u*DCN(1,2);
      
      /* last linear de Casteljau step */
      out[k] =  us*DCN(0,0) + u*DCN(1,0);
    }
  }
#undef DCN
#undef CN
}
 
/*
 * Return the number of components per control point for any type of
 * evaluator.  Return 0 if bad target.
 */
 
static GLint components( GLenum target )
{
   switch (target) {
      case GL_MAP1_VERTEX_3:        return 3;
      case GL_MAP1_VERTEX_4:        return 4;
      case GL_MAP1_INDEX:       return 1;
      case GL_MAP1_COLOR_4:     return 4;
      case GL_MAP1_NORMAL:      return 3;
      case GL_MAP1_TEXTURE_COORD_1: return 1;
      case GL_MAP1_TEXTURE_COORD_2: return 2;
      case GL_MAP1_TEXTURE_COORD_3: return 3;
      case GL_MAP1_TEXTURE_COORD_4: return 4;
      case GL_MAP2_VERTEX_3:        return 3;
      case GL_MAP2_VERTEX_4:        return 4;
      case GL_MAP2_INDEX:       return 1;
      case GL_MAP2_COLOR_4:     return 4;
      case GL_MAP2_NORMAL:      return 3;
      case GL_MAP2_TEXTURE_COORD_1: return 1;
      case GL_MAP2_TEXTURE_COORD_2: return 2;
      case GL_MAP2_TEXTURE_COORD_3: return 3;
      case GL_MAP2_TEXTURE_COORD_4: return 4;
      default:              return 0;
   }
}
 
 
/**********************************************************************/
/***            Copy and deallocate control points                  ***/
/**********************************************************************/
 
 
/*
 * Copy 1-parametric evaluator control points from user-specified 
 * memory space to a buffer of contiguous control points.
 * Input:  see glMap1f for details
 * Return:  pointer to buffer of contiguous control points or NULL if out
 *          of memory.
 */
GLfloat *gl_copy_map_points1f( GLenum target,
                               GLint ustride, GLint uorder,
                               const GLfloat *points )
{
   GLfloat *buffer, *p;
   GLuint i, k, size = components(target);
 
   if (!points || size==0) {
      return NULL;
   }
 
   buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
 
   if(buffer) 
      for(i=0, p=buffer; i<uorder; i++, points+=ustride)
    for(k=0; k<size; k++)
      *p++ = points[k];
 
   return buffer;
}
 
 
 
/*
 * Same as above but convert doubles to floats.
 */
GLfloat *gl_copy_map_points1d( GLenum target,
                    GLint ustride, GLint uorder,
                    const GLdouble *points )
{
   GLfloat *buffer, *p;
   GLuint i, k, size = components(target);
 
   if (!points || size==0) {
      return NULL;
   }
 
   buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
 
   if(buffer)
      for(i=0, p=buffer; i<uorder; i++, points+=ustride)
    for(k=0; k<size; k++)
      *p++ = (GLfloat) points[k];
 
   return buffer;
}
 
 
 
/*
 * Copy 2-parametric evaluator control points from user-specified 
 * memory space to a buffer of contiguous control points.
 * Additional memory is allocated to be used by the horner and
 * de Casteljau evaluation schemes.
 *
 * Input:  see glMap2f for details
 * Return:  pointer to buffer of contiguous control points or NULL if out
 *          of memory.
 */
GLfloat *gl_copy_map_points2f( GLenum target,
                    GLint ustride, GLint uorder,
                    GLint vstride, GLint vorder,
                    const GLfloat *points )
{
   GLfloat *buffer, *p;
   GLuint i, j, k, size, dsize, hsize;
   GLint uinc;
 
   size = components(target);
 
   if (!points || size==0) {
      return NULL;
   }
 
   /* max(uorder, vorder) additional points are used in      */
   /* horner evaluation and uorder*vorder additional */
   /* values are needed for de Casteljau                     */
   dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
   hsize = (uorder > vorder ? uorder : vorder)*size;
 
   if(hsize>dsize)
     buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
   else
     buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
 
   /* compute the increment value for the u-loop */
   uinc = ustride - vorder*vstride;
 
   if (buffer) 
      for (i=0, p=buffer; i<uorder; i++, points += uinc)
     for (j=0; j<vorder; j++, points += vstride)
        for (k=0; k<size; k++)
           *p++ = points[k];
 
   return buffer;
}
 
 
 
/*
 * Same as above but convert doubles to floats.
 */
GLfloat *gl_copy_map_points2d(GLenum target,
                              GLint ustride, GLint uorder,
                              GLint vstride, GLint vorder,
                              const GLdouble *points )
{
   GLfloat *buffer, *p;
   GLuint i, j, k, size, hsize, dsize;
   GLint uinc;
 
   size = components(target);
 
   if (!points || size==0) {
      return NULL;
   }
 
   /* max(uorder, vorder) additional points are used in      */
   /* horner evaluation and uorder*vorder additional */
   /* values are needed for de Casteljau                     */
   dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
   hsize = (uorder > vorder ? uorder : vorder)*size;
 
   if(hsize>dsize)
     buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
   else
     buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
 
   /* compute the increment value for the u-loop */
   uinc = ustride - vorder*vstride;
 
   if (buffer) 
      for (i=0, p=buffer; i<uorder; i++, points += uinc)
     for (j=0; j<vorder; j++, points += vstride)
        for (k=0; k<size; k++)
           *p++ = (GLfloat) points[k];
 
   return buffer;
}
 
 
/*
 * This function is called by the display list deallocator function to
 * specify that a given set of control points are no longer needed.
 */
void gl_free_control_points( GLcontext* ctx, GLenum target, GLfloat *data )
{
   struct gl_1d_map *map1 = NULL;
   struct gl_2d_map *map2 = NULL;
 
   switch (target) {
      case GL_MAP1_VERTEX_3:
         map1 = &ctx->EvalMap.Map1Vertex3;
         break;
      case GL_MAP1_VERTEX_4:
         map1 = &ctx->EvalMap.Map1Vertex4;
     break;
      case GL_MAP1_INDEX:
         map1 = &ctx->EvalMap.Map1Index;
         break;
      case GL_MAP1_COLOR_4:
         map1 = &ctx->EvalMap.Map1Color4;
         break;
      case GL_MAP1_NORMAL:
         map1 = &ctx->EvalMap.Map1Normal;
     break;
      case GL_MAP1_TEXTURE_COORD_1:
         map1 = &ctx->EvalMap.Map1Texture1;
     break;
      case GL_MAP1_TEXTURE_COORD_2:
         map1 = &ctx->EvalMap.Map1Texture2;
     break;
      case GL_MAP1_TEXTURE_COORD_3:
         map1 = &ctx->EvalMap.Map1Texture3;
     break;
      case GL_MAP1_TEXTURE_COORD_4:
         map1 = &ctx->EvalMap.Map1Texture4;
     break;
      case GL_MAP2_VERTEX_3:
         map2 = &ctx->EvalMap.Map2Vertex3;
     break;
      case GL_MAP2_VERTEX_4:
         map2 = &ctx->EvalMap.Map2Vertex4;
     break;
      case GL_MAP2_INDEX:
         map2 = &ctx->EvalMap.Map2Index;
     break;
      case GL_MAP2_COLOR_4:
         map2 = &ctx->EvalMap.Map2Color4;
         break;
      case GL_MAP2_NORMAL:
         map2 = &ctx->EvalMap.Map2Normal;
     break;
      case GL_MAP2_TEXTURE_COORD_1:
         map2 = &ctx->EvalMap.Map2Texture1;
     break;
      case GL_MAP2_TEXTURE_COORD_2:
         map2 = &ctx->EvalMap.Map2Texture2;
     break;
      case GL_MAP2_TEXTURE_COORD_3:
         map2 = &ctx->EvalMap.Map2Texture3;
     break;
      case GL_MAP2_TEXTURE_COORD_4:
         map2 = &ctx->EvalMap.Map2Texture4;
     break;
      default:
     gl_error( ctx, GL_INVALID_ENUM, "gl_free_control_points" );
         return;
   }
 
   if (map1) {
      if (data==map1->Points) {
         /* The control points in the display list are currently */
         /* being used so we can mark them as discard-able. */
         map1->Retain = GL_FALSE;
      }
      else {
         /* The control points in the display list are not currently */
         /* being used. */
         free( data );
      }
   }
   if (map2) {
      if (data==map2->Points) {
         /* The control points in the display list are currently */
         /* being used so we can mark them as discard-able. */
         map2->Retain = GL_FALSE;
      }
      else {
         /* The control points in the display list are not currently */
         /* being used. */
         free( data );
      }
   }
 
}
 
 
 
/**********************************************************************/
/***                      API entry points                          ***/
/**********************************************************************/
 
 
/*
 * Note that the array of control points must be 'unpacked' at this time.
 * Input:  retain - if TRUE, this control point data is also in a display
 *                  list and can't be freed until the list is freed.
 */
void gl_Map1f( GLcontext* ctx, GLenum target,
               GLfloat u1, GLfloat u2, GLint stride,
               GLint order, const GLfloat *points, GLboolean retain )
{
   GLuint k;
 
   if (!points) {
      gl_error( ctx, GL_OUT_OF_MEMORY, "glMap1f" );
      return;
   }
 
   /* may be a new stride after copying control points */
   stride = components( target );
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glMap1" );
      return;
   }
 
   if (u1==u2) {
      gl_error( ctx, GL_INVALID_VALUE, "glMap1(u1,u2)" );
      return;
   }
 
   if (order<1 || order>MAX_EVAL_ORDER) {
      gl_error( ctx, GL_INVALID_VALUE, "glMap1(order)" );
      return;
   }
 
   k = components( target );
   if (k==0) {
      gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
   }
 
   if (stride < k) {
      gl_error( ctx, GL_INVALID_VALUE, "glMap1(stride)" );
      return;
   }
 
   switch (target) {
      case GL_MAP1_VERTEX_3:
         ctx->EvalMap.Map1Vertex3.Order = order;
     ctx->EvalMap.Map1Vertex3.u1 = u1;
     ctx->EvalMap.Map1Vertex3.u2 = u2;
     if (ctx->EvalMap.Map1Vertex3.Points
             && !ctx->EvalMap.Map1Vertex3.Retain) {
        free( ctx->EvalMap.Map1Vertex3.Points );
     }
     ctx->EvalMap.Map1Vertex3.Points = (GLfloat *) points;
         ctx->EvalMap.Map1Vertex3.Retain = retain;
     break;
      case GL_MAP1_VERTEX_4:
         ctx->EvalMap.Map1Vertex4.Order = order;
     ctx->EvalMap.Map1Vertex4.u1 = u1;
     ctx->EvalMap.Map1Vertex4.u2 = u2;
     if (ctx->EvalMap.Map1Vertex4.Points
             && !ctx->EvalMap.Map1Vertex4.Retain) {
        free( ctx->EvalMap.Map1Vertex4.Points );
     }
     ctx->EvalMap.Map1Vertex4.Points = (GLfloat *) points;
     ctx->EvalMap.Map1Vertex4.Retain = retain;
     break;
      case GL_MAP1_INDEX:
         ctx->EvalMap.Map1Index.Order = order;
     ctx->EvalMap.Map1Index.u1 = u1;
     ctx->EvalMap.Map1Index.u2 = u2;
     if (ctx->EvalMap.Map1Index.Points
             && !ctx->EvalMap.Map1Index.Retain) {
        free( ctx->EvalMap.Map1Index.Points );
     }
     ctx->EvalMap.Map1Index.Points = (GLfloat *) points;
     ctx->EvalMap.Map1Index.Retain = retain;
     break;
      case GL_MAP1_COLOR_4:
         ctx->EvalMap.Map1Color4.Order = order;
     ctx->EvalMap.Map1Color4.u1 = u1;
     ctx->EvalMap.Map1Color4.u2 = u2;
     if (ctx->EvalMap.Map1Color4.Points
             && !ctx->EvalMap.Map1Color4.Retain) {
        free( ctx->EvalMap.Map1Color4.Points );
     }
     ctx->EvalMap.Map1Color4.Points = (GLfloat *) points;
     ctx->EvalMap.Map1Color4.Retain = retain;
     break;
      case GL_MAP1_NORMAL:
         ctx->EvalMap.Map1Normal.Order = order;
     ctx->EvalMap.Map1Normal.u1 = u1;
     ctx->EvalMap.Map1Normal.u2 = u2;
     if (ctx->EvalMap.Map1Normal.Points
             && !ctx->EvalMap.Map1Normal.Retain) {
        free( ctx->EvalMap.Map1Normal.Points );
     }
     ctx->EvalMap.Map1Normal.Points = (GLfloat *) points;
     ctx->EvalMap.Map1Normal.Retain = retain;
     break;
      case GL_MAP1_TEXTURE_COORD_1:
         ctx->EvalMap.Map1Texture1.Order = order;
     ctx->EvalMap.Map1Texture1.u1 = u1;
     ctx->EvalMap.Map1Texture1.u2 = u2;
     if (ctx->EvalMap.Map1Texture1.Points
             && !ctx->EvalMap.Map1Texture1.Retain) {
        free( ctx->EvalMap.Map1Texture1.Points );
     }
     ctx->EvalMap.Map1Texture1.Points = (GLfloat *) points;
     ctx->EvalMap.Map1Texture1.Retain = retain;
     break;
      case GL_MAP1_TEXTURE_COORD_2:
         ctx->EvalMap.Map1Texture2.Order = order;
     ctx->EvalMap.Map1Texture2.u1 = u1;
     ctx->EvalMap.Map1Texture2.u2 = u2;
     if (ctx->EvalMap.Map1Texture2.Points
             && !ctx->EvalMap.Map1Texture2.Retain) {
        free( ctx->EvalMap.Map1Texture2.Points );
     }
     ctx->EvalMap.Map1Texture2.Points = (GLfloat *) points;
     ctx->EvalMap.Map1Texture2.Retain = retain;
     break;
      case GL_MAP1_TEXTURE_COORD_3:
         ctx->EvalMap.Map1Texture3.Order = order;
     ctx->EvalMap.Map1Texture3.u1 = u1;
     ctx->EvalMap.Map1Texture3.u2 = u2;
     if (ctx->EvalMap.Map1Texture3.Points
             && !ctx->EvalMap.Map1Texture3.Retain) {
        free( ctx->EvalMap.Map1Texture3.Points );
     }
     ctx->EvalMap.Map1Texture3.Points = (GLfloat *) points;
     ctx->EvalMap.Map1Texture3.Retain = retain;
     break;
      case GL_MAP1_TEXTURE_COORD_4:
         ctx->EvalMap.Map1Texture4.Order = order;
     ctx->EvalMap.Map1Texture4.u1 = u1;
     ctx->EvalMap.Map1Texture4.u2 = u2;
     if (ctx->EvalMap.Map1Texture4.Points
             && !ctx->EvalMap.Map1Texture4.Retain) {
        free( ctx->EvalMap.Map1Texture4.Points );
     }
     ctx->EvalMap.Map1Texture4.Points = (GLfloat *) points;
     ctx->EvalMap.Map1Texture4.Retain = retain;
     break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
   }
}
 
 
 
 
/*
 * Note that the array of control points must be 'unpacked' at this time.
 * Input:  retain - if TRUE, this control point data is also in a display
 *                  list and can't be freed until the list is freed.
 */
void gl_Map2f( GLcontext* ctx, GLenum target,
          GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
          GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
          const GLfloat *points, GLboolean retain )
{
   GLuint k;
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glMap2" );
      return;
   }
 
   if (u1==u2) {
      gl_error( ctx, GL_INVALID_VALUE, "glMap2(u1,u2)" );
      return;
   }
 
   if (v1==v2) {
      gl_error( ctx, GL_INVALID_VALUE, "glMap2(v1,v2)" );
      return;
   }
 
   if (uorder<1 || uorder>MAX_EVAL_ORDER) {
      gl_error( ctx, GL_INVALID_VALUE, "glMap2(uorder)" );
      return;
   }
 
   if (vorder<1 || vorder>MAX_EVAL_ORDER) {
      gl_error( ctx, GL_INVALID_VALUE, "glMap2(vorder)" );
      return;
   }
 
   k = components( target );
   if (k==0) {
      gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
   }
 
   if (ustride < k) {
      gl_error( ctx, GL_INVALID_VALUE, "glMap2(ustride)" );
      return;
   }
   if (vstride < k) {
      gl_error( ctx, GL_INVALID_VALUE, "glMap2(vstride)" );
      return;
   }
 
   switch (target) {
      case GL_MAP2_VERTEX_3:
         ctx->EvalMap.Map2Vertex3.Uorder = uorder;
     ctx->EvalMap.Map2Vertex3.u1 = u1;
     ctx->EvalMap.Map2Vertex3.u2 = u2;
         ctx->EvalMap.Map2Vertex3.Vorder = vorder;
     ctx->EvalMap.Map2Vertex3.v1 = v1;
     ctx->EvalMap.Map2Vertex3.v2 = v2;
     if (ctx->EvalMap.Map2Vertex3.Points
             && !ctx->EvalMap.Map2Vertex3.Retain) {
        free( ctx->EvalMap.Map2Vertex3.Points );
     }
     ctx->EvalMap.Map2Vertex3.Retain = retain;
     ctx->EvalMap.Map2Vertex3.Points = (GLfloat *) points;
     break;
      case GL_MAP2_VERTEX_4:
         ctx->EvalMap.Map2Vertex4.Uorder = uorder;
     ctx->EvalMap.Map2Vertex4.u1 = u1;
     ctx->EvalMap.Map2Vertex4.u2 = u2;
         ctx->EvalMap.Map2Vertex4.Vorder = vorder;
     ctx->EvalMap.Map2Vertex4.v1 = v1;
     ctx->EvalMap.Map2Vertex4.v2 = v2;
     if (ctx->EvalMap.Map2Vertex4.Points
             && !ctx->EvalMap.Map2Vertex4.Retain) {
        free( ctx->EvalMap.Map2Vertex4.Points );
     }
     ctx->EvalMap.Map2Vertex4.Points = (GLfloat *) points;
     ctx->EvalMap.Map2Vertex4.Retain = retain;
     break;
      case GL_MAP2_INDEX:
         ctx->EvalMap.Map2Index.Uorder = uorder;
     ctx->EvalMap.Map2Index.u1 = u1;
     ctx->EvalMap.Map2Index.u2 = u2;
         ctx->EvalMap.Map2Index.Vorder = vorder;
     ctx->EvalMap.Map2Index.v1 = v1;
     ctx->EvalMap.Map2Index.v2 = v2;
     if (ctx->EvalMap.Map2Index.Points
             && !ctx->EvalMap.Map2Index.Retain) {
        free( ctx->EvalMap.Map2Index.Points );
     }
     ctx->EvalMap.Map2Index.Retain = retain;
     ctx->EvalMap.Map2Index.Points = (GLfloat *) points;
     break;
      case GL_MAP2_COLOR_4:
         ctx->EvalMap.Map2Color4.Uorder = uorder;
     ctx->EvalMap.Map2Color4.u1 = u1;
     ctx->EvalMap.Map2Color4.u2 = u2;
         ctx->EvalMap.Map2Color4.Vorder = vorder;
     ctx->EvalMap.Map2Color4.v1 = v1;
     ctx->EvalMap.Map2Color4.v2 = v2;
     if (ctx->EvalMap.Map2Color4.Points
             && !ctx->EvalMap.Map2Color4.Retain) {
        free( ctx->EvalMap.Map2Color4.Points );
     }
     ctx->EvalMap.Map2Color4.Retain = retain;
     ctx->EvalMap.Map2Color4.Points = (GLfloat *) points;
     break;
      case GL_MAP2_NORMAL:
         ctx->EvalMap.Map2Normal.Uorder = uorder;
     ctx->EvalMap.Map2Normal.u1 = u1;
     ctx->EvalMap.Map2Normal.u2 = u2;
         ctx->EvalMap.Map2Normal.Vorder = vorder;
     ctx->EvalMap.Map2Normal.v1 = v1;
     ctx->EvalMap.Map2Normal.v2 = v2;
     if (ctx->EvalMap.Map2Normal.Points
             && !ctx->EvalMap.Map2Normal.Retain) {
        free( ctx->EvalMap.Map2Normal.Points );
     }
     ctx->EvalMap.Map2Normal.Retain = retain;
     ctx->EvalMap.Map2Normal.Points = (GLfloat *) points;
     break;
      case GL_MAP2_TEXTURE_COORD_1:
         ctx->EvalMap.Map2Texture1.Uorder = uorder;
     ctx->EvalMap.Map2Texture1.u1 = u1;
     ctx->EvalMap.Map2Texture1.u2 = u2;
         ctx->EvalMap.Map2Texture1.Vorder = vorder;
     ctx->EvalMap.Map2Texture1.v1 = v1;
     ctx->EvalMap.Map2Texture1.v2 = v2;
     if (ctx->EvalMap.Map2Texture1.Points
             && !ctx->EvalMap.Map2Texture1.Retain) {
        free( ctx->EvalMap.Map2Texture1.Points );
     }
     ctx->EvalMap.Map2Texture1.Retain = retain;
     ctx->EvalMap.Map2Texture1.Points = (GLfloat *) points;
     break;
      case GL_MAP2_TEXTURE_COORD_2:
         ctx->EvalMap.Map2Texture2.Uorder = uorder;
     ctx->EvalMap.Map2Texture2.u1 = u1;
     ctx->EvalMap.Map2Texture2.u2 = u2;
         ctx->EvalMap.Map2Texture2.Vorder = vorder;
     ctx->EvalMap.Map2Texture2.v1 = v1;
     ctx->EvalMap.Map2Texture2.v2 = v2;
     if (ctx->EvalMap.Map2Texture2.Points
             && !ctx->EvalMap.Map2Texture2.Retain) {
        free( ctx->EvalMap.Map2Texture2.Points );
     }
     ctx->EvalMap.Map2Texture2.Retain = retain;
     ctx->EvalMap.Map2Texture2.Points = (GLfloat *) points;
     break;
      case GL_MAP2_TEXTURE_COORD_3:
         ctx->EvalMap.Map2Texture3.Uorder = uorder;
     ctx->EvalMap.Map2Texture3.u1 = u1;
     ctx->EvalMap.Map2Texture3.u2 = u2;
         ctx->EvalMap.Map2Texture3.Vorder = vorder;
     ctx->EvalMap.Map2Texture3.v1 = v1;
     ctx->EvalMap.Map2Texture3.v2 = v2;
     if (ctx->EvalMap.Map2Texture3.Points
             && !ctx->EvalMap.Map2Texture3.Retain) {
        free( ctx->EvalMap.Map2Texture3.Points );
     }
     ctx->EvalMap.Map2Texture3.Retain = retain;
     ctx->EvalMap.Map2Texture3.Points = (GLfloat *) points;
     break;
      case GL_MAP2_TEXTURE_COORD_4:
         ctx->EvalMap.Map2Texture4.Uorder = uorder;
     ctx->EvalMap.Map2Texture4.u1 = u1;
     ctx->EvalMap.Map2Texture4.u2 = u2;
         ctx->EvalMap.Map2Texture4.Vorder = vorder;
     ctx->EvalMap.Map2Texture4.v1 = v1;
     ctx->EvalMap.Map2Texture4.v2 = v2;
     if (ctx->EvalMap.Map2Texture4.Points
             && !ctx->EvalMap.Map2Texture4.Retain) {
        free( ctx->EvalMap.Map2Texture4.Points );
     }
     ctx->EvalMap.Map2Texture4.Retain = retain;
     ctx->EvalMap.Map2Texture4.Points = (GLfloat *) points;
     break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
   }
}
 
 
   
 
 
void gl_GetMapdv( GLcontext* ctx, GLenum target, GLenum query, GLdouble *v )
{
   GLuint i, n;
   GLfloat *data;
 
   switch (query) {
      case GL_COEFF:
     switch (target) {
        case GL_MAP1_COLOR_4:
           data = ctx->EvalMap.Map1Color4.Points;
           n = ctx->EvalMap.Map1Color4.Order * 4;
           break;
        case GL_MAP1_INDEX:
           data = ctx->EvalMap.Map1Index.Points;
           n = ctx->EvalMap.Map1Index.Order;
           break;
        case GL_MAP1_NORMAL:
           data = ctx->EvalMap.Map1Normal.Points;
           n = ctx->EvalMap.Map1Normal.Order * 3;
           break;
        case GL_MAP1_TEXTURE_COORD_1:
           data = ctx->EvalMap.Map1Texture1.Points;
           n = ctx->EvalMap.Map1Texture1.Order * 1;
           break;
        case GL_MAP1_TEXTURE_COORD_2:
           data = ctx->EvalMap.Map1Texture2.Points;
           n = ctx->EvalMap.Map1Texture2.Order * 2;
           break;
        case GL_MAP1_TEXTURE_COORD_3:
           data = ctx->EvalMap.Map1Texture3.Points;
           n = ctx->EvalMap.Map1Texture3.Order * 3;
           break;
        case GL_MAP1_TEXTURE_COORD_4:
           data = ctx->EvalMap.Map1Texture4.Points;
           n = ctx->EvalMap.Map1Texture4.Order * 4;
           break;
        case GL_MAP1_VERTEX_3:
           data = ctx->EvalMap.Map1Vertex3.Points;
           n = ctx->EvalMap.Map1Vertex3.Order * 3;
           break;
        case GL_MAP1_VERTEX_4:
           data = ctx->EvalMap.Map1Vertex4.Points;
           n = ctx->EvalMap.Map1Vertex4.Order * 4;
           break;
        case GL_MAP2_COLOR_4:
           data = ctx->EvalMap.Map2Color4.Points;
           n = ctx->EvalMap.Map2Color4.Uorder
                 * ctx->EvalMap.Map2Color4.Vorder * 4;
           break;
        case GL_MAP2_INDEX:
           data = ctx->EvalMap.Map2Index.Points;
           n = ctx->EvalMap.Map2Index.Uorder
                 * ctx->EvalMap.Map2Index.Vorder;
           break;
        case GL_MAP2_NORMAL:
           data = ctx->EvalMap.Map2Normal.Points;
           n = ctx->EvalMap.Map2Normal.Uorder
                 * ctx->EvalMap.Map2Normal.Vorder * 3;
           break;
        case GL_MAP2_TEXTURE_COORD_1:
           data = ctx->EvalMap.Map2Texture1.Points;
           n = ctx->EvalMap.Map2Texture1.Uorder
                 * ctx->EvalMap.Map2Texture1.Vorder * 1;
           break;
        case GL_MAP2_TEXTURE_COORD_2:
           data = ctx->EvalMap.Map2Texture2.Points;
           n = ctx->EvalMap.Map2Texture2.Uorder
                 * ctx->EvalMap.Map2Texture2.Vorder * 2;
           break;
        case GL_MAP2_TEXTURE_COORD_3:
           data = ctx->EvalMap.Map2Texture3.Points;
           n = ctx->EvalMap.Map2Texture3.Uorder
                 * ctx->EvalMap.Map2Texture3.Vorder * 3;
           break;
        case GL_MAP2_TEXTURE_COORD_4:
           data = ctx->EvalMap.Map2Texture4.Points;
           n = ctx->EvalMap.Map2Texture4.Uorder
                 * ctx->EvalMap.Map2Texture4.Vorder * 4;
           break;
        case GL_MAP2_VERTEX_3:
           data = ctx->EvalMap.Map2Vertex3.Points;
           n = ctx->EvalMap.Map2Vertex3.Uorder
                 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
           break;
        case GL_MAP2_VERTEX_4:
           data = ctx->EvalMap.Map2Vertex4.Points;
           n = ctx->EvalMap.Map2Vertex4.Uorder
                 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
           break;
        default:
           gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
     }
     if (data) {
        for (i=0;i<n;i++) {
           v[i] = data[i];
        }
     }
         break;
      case GL_ORDER:
     switch (target) {
        case GL_MAP1_COLOR_4:
           *v = ctx->EvalMap.Map1Color4.Order;
           break;
        case GL_MAP1_INDEX:
           *v = ctx->EvalMap.Map1Index.Order;
           break;
        case GL_MAP1_NORMAL:
           *v = ctx->EvalMap.Map1Normal.Order;
           break;
        case GL_MAP1_TEXTURE_COORD_1:
           *v = ctx->EvalMap.Map1Texture1.Order;
           break;
        case GL_MAP1_TEXTURE_COORD_2:
           *v = ctx->EvalMap.Map1Texture2.Order;
           break;
        case GL_MAP1_TEXTURE_COORD_3:
           *v = ctx->EvalMap.Map1Texture3.Order;
           break;
        case GL_MAP1_TEXTURE_COORD_4:
           *v = ctx->EvalMap.Map1Texture4.Order;
           break;
        case GL_MAP1_VERTEX_3:
           *v = ctx->EvalMap.Map1Vertex3.Order;
           break;
        case GL_MAP1_VERTEX_4:
           *v = ctx->EvalMap.Map1Vertex4.Order;
           break;
        case GL_MAP2_COLOR_4:
           v[0] = ctx->EvalMap.Map2Color4.Uorder;
           v[1] = ctx->EvalMap.Map2Color4.Vorder;
           break;
        case GL_MAP2_INDEX:
           v[0] = ctx->EvalMap.Map2Index.Uorder;
           v[1] = ctx->EvalMap.Map2Index.Vorder;
           break;
        case GL_MAP2_NORMAL:
           v[0] = ctx->EvalMap.Map2Normal.Uorder;
           v[1] = ctx->EvalMap.Map2Normal.Vorder;
           break;
        case GL_MAP2_TEXTURE_COORD_1:
           v[0] = ctx->EvalMap.Map2Texture1.Uorder;
           v[1] = ctx->EvalMap.Map2Texture1.Vorder;
           break;
        case GL_MAP2_TEXTURE_COORD_2:
           v[0] = ctx->EvalMap.Map2Texture2.Uorder;
           v[1] = ctx->EvalMap.Map2Texture2.Vorder;
           break;
        case GL_MAP2_TEXTURE_COORD_3:
           v[0] = ctx->EvalMap.Map2Texture3.Uorder;
           v[1] = ctx->EvalMap.Map2Texture3.Vorder;
           break;
        case GL_MAP2_TEXTURE_COORD_4:
           v[0] = ctx->EvalMap.Map2Texture4.Uorder;
           v[1] = ctx->EvalMap.Map2Texture4.Vorder;
           break;
        case GL_MAP2_VERTEX_3:
           v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
           v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
           break;
        case GL_MAP2_VERTEX_4:
           v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
           v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
           break;
        default:
           gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
     }
         break;
      case GL_DOMAIN:
     switch (target) {
        case GL_MAP1_COLOR_4:
           v[0] = ctx->EvalMap.Map1Color4.u1;
           v[1] = ctx->EvalMap.Map1Color4.u2;
           break;
        case GL_MAP1_INDEX:
           v[0] = ctx->EvalMap.Map1Index.u1;
           v[1] = ctx->EvalMap.Map1Index.u2;
           break;
        case GL_MAP1_NORMAL:
           v[0] = ctx->EvalMap.Map1Normal.u1;
           v[1] = ctx->EvalMap.Map1Normal.u2;
           break;
        case GL_MAP1_TEXTURE_COORD_1:
           v[0] = ctx->EvalMap.Map1Texture1.u1;
           v[1] = ctx->EvalMap.Map1Texture1.u2;
           break;
        case GL_MAP1_TEXTURE_COORD_2:
           v[0] = ctx->EvalMap.Map1Texture2.u1;
           v[1] = ctx->EvalMap.Map1Texture2.u2;
           break;
        case GL_MAP1_TEXTURE_COORD_3:
           v[0] = ctx->EvalMap.Map1Texture3.u1;
           v[1] = ctx->EvalMap.Map1Texture3.u2;
           break;
        case GL_MAP1_TEXTURE_COORD_4:
           v[0] = ctx->EvalMap.Map1Texture4.u1;
           v[1] = ctx->EvalMap.Map1Texture4.u2;
           break;
        case GL_MAP1_VERTEX_3:
           v[0] = ctx->EvalMap.Map1Vertex3.u1;
           v[1] = ctx->EvalMap.Map1Vertex3.u2;
           break;
        case GL_MAP1_VERTEX_4:
           v[0] = ctx->EvalMap.Map1Vertex4.u1;
           v[1] = ctx->EvalMap.Map1Vertex4.u2;
           break;
        case GL_MAP2_COLOR_4:
           v[0] = ctx->EvalMap.Map2Color4.u1;
           v[1] = ctx->EvalMap.Map2Color4.u2;
           v[2] = ctx->EvalMap.Map2Color4.v1;
           v[3] = ctx->EvalMap.Map2Color4.v2;
           break;
        case GL_MAP2_INDEX:
           v[0] = ctx->EvalMap.Map2Index.u1;
           v[1] = ctx->EvalMap.Map2Index.u2;
           v[2] = ctx->EvalMap.Map2Index.v1;
           v[3] = ctx->EvalMap.Map2Index.v2;
           break;
        case GL_MAP2_NORMAL:
           v[0] = ctx->EvalMap.Map2Normal.u1;
           v[1] = ctx->EvalMap.Map2Normal.u2;
           v[2] = ctx->EvalMap.Map2Normal.v1;
           v[3] = ctx->EvalMap.Map2Normal.v2;
           break;
        case GL_MAP2_TEXTURE_COORD_1:
           v[0] = ctx->EvalMap.Map2Texture1.u1;
           v[1] = ctx->EvalMap.Map2Texture1.u2;
           v[2] = ctx->EvalMap.Map2Texture1.v1;
           v[3] = ctx->EvalMap.Map2Texture1.v2;
           break;
        case GL_MAP2_TEXTURE_COORD_2:
           v[0] = ctx->EvalMap.Map2Texture2.u1;
           v[1] = ctx->EvalMap.Map2Texture2.u2;
           v[2] = ctx->EvalMap.Map2Texture2.v1;
           v[3] = ctx->EvalMap.Map2Texture2.v2;
           break;
        case GL_MAP2_TEXTURE_COORD_3:
           v[0] = ctx->EvalMap.Map2Texture3.u1;
           v[1] = ctx->EvalMap.Map2Texture3.u2;
           v[2] = ctx->EvalMap.Map2Texture3.v1;
           v[3] = ctx->EvalMap.Map2Texture3.v2;
           break;
        case GL_MAP2_TEXTURE_COORD_4:
           v[0] = ctx->EvalMap.Map2Texture4.u1;
           v[1] = ctx->EvalMap.Map2Texture4.u2;
           v[2] = ctx->EvalMap.Map2Texture4.v1;
           v[3] = ctx->EvalMap.Map2Texture4.v2;
           break;
        case GL_MAP2_VERTEX_3:
           v[0] = ctx->EvalMap.Map2Vertex3.u1;
           v[1] = ctx->EvalMap.Map2Vertex3.u2;
           v[2] = ctx->EvalMap.Map2Vertex3.v1;
           v[3] = ctx->EvalMap.Map2Vertex3.v2;
           break;
        case GL_MAP2_VERTEX_4:
           v[0] = ctx->EvalMap.Map2Vertex4.u1;
           v[1] = ctx->EvalMap.Map2Vertex4.u2;
           v[2] = ctx->EvalMap.Map2Vertex4.v1;
           v[3] = ctx->EvalMap.Map2Vertex4.v2;
           break;
        default:
           gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
     }
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(query)" );
   }
}
 
 
void gl_GetMapfv( GLcontext* ctx, GLenum target, GLenum query, GLfloat *v )
{
   GLuint i, n;
   GLfloat *data;
 
   switch (query) {
      case GL_COEFF:
     switch (target) {
        case GL_MAP1_COLOR_4:
           data = ctx->EvalMap.Map1Color4.Points;
           n = ctx->EvalMap.Map1Color4.Order * 4;
           break;
        case GL_MAP1_INDEX:
           data = ctx->EvalMap.Map1Index.Points;
           n = ctx->EvalMap.Map1Index.Order;
           break;
        case GL_MAP1_NORMAL:
           data = ctx->EvalMap.Map1Normal.Points;
           n = ctx->EvalMap.Map1Normal.Order * 3;
           break;
        case GL_MAP1_TEXTURE_COORD_1:
           data = ctx->EvalMap.Map1Texture1.Points;
           n = ctx->EvalMap.Map1Texture1.Order * 1;
           break;
        case GL_MAP1_TEXTURE_COORD_2:
           data = ctx->EvalMap.Map1Texture2.Points;
           n = ctx->EvalMap.Map1Texture2.Order * 2;
           break;
        case GL_MAP1_TEXTURE_COORD_3:
           data = ctx->EvalMap.Map1Texture3.Points;
           n = ctx->EvalMap.Map1Texture3.Order * 3;
           break;
        case GL_MAP1_TEXTURE_COORD_4:
           data = ctx->EvalMap.Map1Texture4.Points;
           n = ctx->EvalMap.Map1Texture4.Order * 4;
           break;
        case GL_MAP1_VERTEX_3:
           data = ctx->EvalMap.Map1Vertex3.Points;
           n = ctx->EvalMap.Map1Vertex3.Order * 3;
           break;
        case GL_MAP1_VERTEX_4:
           data = ctx->EvalMap.Map1Vertex4.Points;
           n = ctx->EvalMap.Map1Vertex4.Order * 4;
           break;
        case GL_MAP2_COLOR_4:
           data = ctx->EvalMap.Map2Color4.Points;
           n = ctx->EvalMap.Map2Color4.Uorder
                 * ctx->EvalMap.Map2Color4.Vorder * 4;
           break;
        case GL_MAP2_INDEX:
           data = ctx->EvalMap.Map2Index.Points;
           n = ctx->EvalMap.Map2Index.Uorder
                 * ctx->EvalMap.Map2Index.Vorder;
           break;
        case GL_MAP2_NORMAL:
           data = ctx->EvalMap.Map2Normal.Points;
           n = ctx->EvalMap.Map2Normal.Uorder
                 * ctx->EvalMap.Map2Normal.Vorder * 3;
           break;
        case GL_MAP2_TEXTURE_COORD_1:
           data = ctx->EvalMap.Map2Texture1.Points;
           n = ctx->EvalMap.Map2Texture1.Uorder
                 * ctx->EvalMap.Map2Texture1.Vorder * 1;
           break;
        case GL_MAP2_TEXTURE_COORD_2:
           data = ctx->EvalMap.Map2Texture2.Points;
           n = ctx->EvalMap.Map2Texture2.Uorder
                 * ctx->EvalMap.Map2Texture2.Vorder * 2;
           break;
        case GL_MAP2_TEXTURE_COORD_3:
           data = ctx->EvalMap.Map2Texture3.Points;
           n = ctx->EvalMap.Map2Texture3.Uorder
                 * ctx->EvalMap.Map2Texture3.Vorder * 3;
           break;
        case GL_MAP2_TEXTURE_COORD_4:
           data = ctx->EvalMap.Map2Texture4.Points;
           n = ctx->EvalMap.Map2Texture4.Uorder
                 * ctx->EvalMap.Map2Texture4.Vorder * 4;
           break;
        case GL_MAP2_VERTEX_3:
           data = ctx->EvalMap.Map2Vertex3.Points;
           n = ctx->EvalMap.Map2Vertex3.Uorder
                 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
           break;
        case GL_MAP2_VERTEX_4:
           data = ctx->EvalMap.Map2Vertex4.Points;
           n = ctx->EvalMap.Map2Vertex4.Uorder
                 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
           break;
        default:
           gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
     }
     if (data) {
        for (i=0;i<n;i++) {
           v[i] = data[i];
        }
     }
         break;
      case GL_ORDER:
     switch (target) {
        case GL_MAP1_COLOR_4:
           *v = ctx->EvalMap.Map1Color4.Order;
           break;
        case GL_MAP1_INDEX:
           *v = ctx->EvalMap.Map1Index.Order;
           break;
        case GL_MAP1_NORMAL:
           *v = ctx->EvalMap.Map1Normal.Order;
           break;
        case GL_MAP1_TEXTURE_COORD_1:
           *v = ctx->EvalMap.Map1Texture1.Order;
           break;
        case GL_MAP1_TEXTURE_COORD_2:
           *v = ctx->EvalMap.Map1Texture2.Order;
           break;
        case GL_MAP1_TEXTURE_COORD_3:
           *v = ctx->EvalMap.Map1Texture3.Order;
           break;
        case GL_MAP1_TEXTURE_COORD_4:
           *v = ctx->EvalMap.Map1Texture4.Order;
           break;
        case GL_MAP1_VERTEX_3:
           *v = ctx->EvalMap.Map1Vertex3.Order;
           break;
        case GL_MAP1_VERTEX_4:
           *v = ctx->EvalMap.Map1Vertex4.Order;
           break;
        case GL_MAP2_COLOR_4:
           v[0] = ctx->EvalMap.Map2Color4.Uorder;
           v[1] = ctx->EvalMap.Map2Color4.Vorder;
           break;
        case GL_MAP2_INDEX:
           v[0] = ctx->EvalMap.Map2Index.Uorder;
           v[1] = ctx->EvalMap.Map2Index.Vorder;
           break;
        case GL_MAP2_NORMAL:
           v[0] = ctx->EvalMap.Map2Normal.Uorder;
           v[1] = ctx->EvalMap.Map2Normal.Vorder;
           break;
        case GL_MAP2_TEXTURE_COORD_1:
           v[0] = ctx->EvalMap.Map2Texture1.Uorder;
           v[1] = ctx->EvalMap.Map2Texture1.Vorder;
           break;
        case GL_MAP2_TEXTURE_COORD_2:
           v[0] = ctx->EvalMap.Map2Texture2.Uorder;
           v[1] = ctx->EvalMap.Map2Texture2.Vorder;
           break;
        case GL_MAP2_TEXTURE_COORD_3:
           v[0] = ctx->EvalMap.Map2Texture3.Uorder;
           v[1] = ctx->EvalMap.Map2Texture3.Vorder;
           break;
        case GL_MAP2_TEXTURE_COORD_4:
           v[0] = ctx->EvalMap.Map2Texture4.Uorder;
           v[1] = ctx->EvalMap.Map2Texture4.Vorder;
           break;
        case GL_MAP2_VERTEX_3:
           v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
           v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
           break;
        case GL_MAP2_VERTEX_4:
           v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
           v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
           break;
        default:
           gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
     }
         break;
      case GL_DOMAIN:
     switch (target) {
        case GL_MAP1_COLOR_4:
           v[0] = ctx->EvalMap.Map1Color4.u1;
           v[1] = ctx->EvalMap.Map1Color4.u2;
           break;
        case GL_MAP1_INDEX:
           v[0] = ctx->EvalMap.Map1Index.u1;
           v[1] = ctx->EvalMap.Map1Index.u2;
           break;
        case GL_MAP1_NORMAL:
           v[0] = ctx->EvalMap.Map1Normal.u1;
           v[1] = ctx->EvalMap.Map1Normal.u2;
           break;
        case GL_MAP1_TEXTURE_COORD_1:
           v[0] = ctx->EvalMap.Map1Texture1.u1;
           v[1] = ctx->EvalMap.Map1Texture1.u2;
           break;
        case GL_MAP1_TEXTURE_COORD_2:
           v[0] = ctx->EvalMap.Map1Texture2.u1;
           v[1] = ctx->EvalMap.Map1Texture2.u2;
           break;
        case GL_MAP1_TEXTURE_COORD_3:
           v[0] = ctx->EvalMap.Map1Texture3.u1;
           v[1] = ctx->EvalMap.Map1Texture3.u2;
           break;
        case GL_MAP1_TEXTURE_COORD_4:
           v[0] = ctx->EvalMap.Map1Texture4.u1;
           v[1] = ctx->EvalMap.Map1Texture4.u2;
           break;
        case GL_MAP1_VERTEX_3:
           v[0] = ctx->EvalMap.Map1Vertex3.u1;
           v[1] = ctx->EvalMap.Map1Vertex3.u2;
           break;
        case GL_MAP1_VERTEX_4:
           v[0] = ctx->EvalMap.Map1Vertex4.u1;
           v[1] = ctx->EvalMap.Map1Vertex4.u2;
           break;
        case GL_MAP2_COLOR_4:
           v[0] = ctx->EvalMap.Map2Color4.u1;
           v[1] = ctx->EvalMap.Map2Color4.u2;
           v[2] = ctx->EvalMap.Map2Color4.v1;
           v[3] = ctx->EvalMap.Map2Color4.v2;
           break;
        case GL_MAP2_INDEX:
           v[0] = ctx->EvalMap.Map2Index.u1;
           v[1] = ctx->EvalMap.Map2Index.u2;
           v[2] = ctx->EvalMap.Map2Index.v1;
           v[3] = ctx->EvalMap.Map2Index.v2;
           break;
        case GL_MAP2_NORMAL:
           v[0] = ctx->EvalMap.Map2Normal.u1;
           v[1] = ctx->EvalMap.Map2Normal.u2;
           v[2] = ctx->EvalMap.Map2Normal.v1;
           v[3] = ctx->EvalMap.Map2Normal.v2;
           break;
        case GL_MAP2_TEXTURE_COORD_1:
           v[0] = ctx->EvalMap.Map2Texture1.u1;
           v[1] = ctx->EvalMap.Map2Texture1.u2;
           v[2] = ctx->EvalMap.Map2Texture1.v1;
           v[3] = ctx->EvalMap.Map2Texture1.v2;
           break;
        case GL_MAP2_TEXTURE_COORD_2:
           v[0] = ctx->EvalMap.Map2Texture2.u1;
           v[1] = ctx->EvalMap.Map2Texture2.u2;
           v[2] = ctx->EvalMap.Map2Texture2.v1;
           v[3] = ctx->EvalMap.Map2Texture2.v2;
           break;
        case GL_MAP2_TEXTURE_COORD_3:
           v[0] = ctx->EvalMap.Map2Texture3.u1;
           v[1] = ctx->EvalMap.Map2Texture3.u2;
           v[2] = ctx->EvalMap.Map2Texture3.v1;
           v[3] = ctx->EvalMap.Map2Texture3.v2;
           break;
        case GL_MAP2_TEXTURE_COORD_4:
           v[0] = ctx->EvalMap.Map2Texture4.u1;
           v[1] = ctx->EvalMap.Map2Texture4.u2;
           v[2] = ctx->EvalMap.Map2Texture4.v1;
           v[3] = ctx->EvalMap.Map2Texture4.v2;
           break;
        case GL_MAP2_VERTEX_3:
           v[0] = ctx->EvalMap.Map2Vertex3.u1;
           v[1] = ctx->EvalMap.Map2Vertex3.u2;
           v[2] = ctx->EvalMap.Map2Vertex3.v1;
           v[3] = ctx->EvalMap.Map2Vertex3.v2;
           break;
        case GL_MAP2_VERTEX_4:
           v[0] = ctx->EvalMap.Map2Vertex4.u1;
           v[1] = ctx->EvalMap.Map2Vertex4.u2;
           v[2] = ctx->EvalMap.Map2Vertex4.v1;
           v[3] = ctx->EvalMap.Map2Vertex4.v2;
           break;
        default:
           gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
     }
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(query)" );
   }
}
 
 
void gl_GetMapiv( GLcontext* ctx, GLenum target, GLenum query, GLint *v )
{
   GLuint i, n;
   GLfloat *data;
 
   switch (query) {
      case GL_COEFF:
     switch (target) {
        case GL_MAP1_COLOR_4:
           data = ctx->EvalMap.Map1Color4.Points;
           n = ctx->EvalMap.Map1Color4.Order * 4;
           break;
        case GL_MAP1_INDEX:
           data = ctx->EvalMap.Map1Index.Points;
           n = ctx->EvalMap.Map1Index.Order;
           break;
        case GL_MAP1_NORMAL:
           data = ctx->EvalMap.Map1Normal.Points;
           n = ctx->EvalMap.Map1Normal.Order * 3;
           break;
        case GL_MAP1_TEXTURE_COORD_1:
           data = ctx->EvalMap.Map1Texture1.Points;
           n = ctx->EvalMap.Map1Texture1.Order * 1;
           break;
        case GL_MAP1_TEXTURE_COORD_2:
           data = ctx->EvalMap.Map1Texture2.Points;
           n = ctx->EvalMap.Map1Texture2.Order * 2;
           break;
        case GL_MAP1_TEXTURE_COORD_3:
           data = ctx->EvalMap.Map1Texture3.Points;
           n = ctx->EvalMap.Map1Texture3.Order * 3;
           break;
        case GL_MAP1_TEXTURE_COORD_4:
           data = ctx->EvalMap.Map1Texture4.Points;
           n = ctx->EvalMap.Map1Texture4.Order * 4;
           break;
        case GL_MAP1_VERTEX_3:
           data = ctx->EvalMap.Map1Vertex3.Points;
           n = ctx->EvalMap.Map1Vertex3.Order * 3;
           break;
        case GL_MAP1_VERTEX_4:
           data = ctx->EvalMap.Map1Vertex4.Points;
           n = ctx->EvalMap.Map1Vertex4.Order * 4;
           break;
        case GL_MAP2_COLOR_4:
           data = ctx->EvalMap.Map2Color4.Points;
           n = ctx->EvalMap.Map2Color4.Uorder
                 * ctx->EvalMap.Map2Color4.Vorder * 4;
           break;
        case GL_MAP2_INDEX:
           data = ctx->EvalMap.Map2Index.Points;
           n = ctx->EvalMap.Map2Index.Uorder
                 * ctx->EvalMap.Map2Index.Vorder;
           break;
        case GL_MAP2_NORMAL:
           data = ctx->EvalMap.Map2Normal.Points;
           n = ctx->EvalMap.Map2Normal.Uorder
                 * ctx->EvalMap.Map2Normal.Vorder * 3;
           break;
        case GL_MAP2_TEXTURE_COORD_1:
           data = ctx->EvalMap.Map2Texture1.Points;
           n = ctx->EvalMap.Map2Texture1.Uorder
                 * ctx->EvalMap.Map2Texture1.Vorder * 1;
           break;
        case GL_MAP2_TEXTURE_COORD_2:
           data = ctx->EvalMap.Map2Texture2.Points;
           n = ctx->EvalMap.Map2Texture2.Uorder
                 * ctx->EvalMap.Map2Texture2.Vorder * 2;
           break;
        case GL_MAP2_TEXTURE_COORD_3:
           data = ctx->EvalMap.Map2Texture3.Points;
           n = ctx->EvalMap.Map2Texture3.Uorder
                 * ctx->EvalMap.Map2Texture3.Vorder * 3;
           break;
        case GL_MAP2_TEXTURE_COORD_4:
           data = ctx->EvalMap.Map2Texture4.Points;
           n = ctx->EvalMap.Map2Texture4.Uorder
                 * ctx->EvalMap.Map2Texture4.Vorder * 4;
           break;
        case GL_MAP2_VERTEX_3:
           data = ctx->EvalMap.Map2Vertex3.Points;
           n = ctx->EvalMap.Map2Vertex3.Uorder
                 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
           break;
        case GL_MAP2_VERTEX_4:
           data = ctx->EvalMap.Map2Vertex4.Points;
           n = ctx->EvalMap.Map2Vertex4.Uorder
                 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
           break;
        default:
           gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
     }
     if (data) {
        for (i=0;i<n;i++) {
           v[i] = ROUNDF(data[i]);
        }
     }
         break;
      case GL_ORDER:
     switch (target) {
        case GL_MAP1_COLOR_4:
           *v = ctx->EvalMap.Map1Color4.Order;
           break;
        case GL_MAP1_INDEX:
           *v = ctx->EvalMap.Map1Index.Order;
           break;
        case GL_MAP1_NORMAL:
           *v = ctx->EvalMap.Map1Normal.Order;
           break;
        case GL_MAP1_TEXTURE_COORD_1:
           *v = ctx->EvalMap.Map1Texture1.Order;
           break;
        case GL_MAP1_TEXTURE_COORD_2:
           *v = ctx->EvalMap.Map1Texture2.Order;
           break;
        case GL_MAP1_TEXTURE_COORD_3:
           *v = ctx->EvalMap.Map1Texture3.Order;
           break;
        case GL_MAP1_TEXTURE_COORD_4:
           *v = ctx->EvalMap.Map1Texture4.Order;
           break;
        case GL_MAP1_VERTEX_3:
           *v = ctx->EvalMap.Map1Vertex3.Order;
           break;
        case GL_MAP1_VERTEX_4:
           *v = ctx->EvalMap.Map1Vertex4.Order;
           break;
        case GL_MAP2_COLOR_4:
           v[0] = ctx->EvalMap.Map2Color4.Uorder;
           v[1] = ctx->EvalMap.Map2Color4.Vorder;
           break;
        case GL_MAP2_INDEX:
           v[0] = ctx->EvalMap.Map2Index.Uorder;
           v[1] = ctx->EvalMap.Map2Index.Vorder;
           break;
        case GL_MAP2_NORMAL:
           v[0] = ctx->EvalMap.Map2Normal.Uorder;
           v[1] = ctx->EvalMap.Map2Normal.Vorder;
           break;
        case GL_MAP2_TEXTURE_COORD_1:
           v[0] = ctx->EvalMap.Map2Texture1.Uorder;
           v[1] = ctx->EvalMap.Map2Texture1.Vorder;
           break;
        case GL_MAP2_TEXTURE_COORD_2:
           v[0] = ctx->EvalMap.Map2Texture2.Uorder;
           v[1] = ctx->EvalMap.Map2Texture2.Vorder;
           break;
        case GL_MAP2_TEXTURE_COORD_3:
           v[0] = ctx->EvalMap.Map2Texture3.Uorder;
           v[1] = ctx->EvalMap.Map2Texture3.Vorder;
           break;
        case GL_MAP2_TEXTURE_COORD_4:
           v[0] = ctx->EvalMap.Map2Texture4.Uorder;
           v[1] = ctx->EvalMap.Map2Texture4.Vorder;
           break;
        case GL_MAP2_VERTEX_3:
           v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
           v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
           break;
        case GL_MAP2_VERTEX_4:
           v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
           v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
           break;
        default:
           gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
     }
         break;
      case GL_DOMAIN:
     switch (target) {
        case GL_MAP1_COLOR_4:
           v[0] = ROUNDF(ctx->EvalMap.Map1Color4.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map1Color4.u2);
           break;
        case GL_MAP1_INDEX:
           v[0] = ROUNDF(ctx->EvalMap.Map1Index.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map1Index.u2);
           break;
        case GL_MAP1_NORMAL:
           v[0] = ROUNDF(ctx->EvalMap.Map1Normal.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map1Normal.u2);
           break;
        case GL_MAP1_TEXTURE_COORD_1:
           v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
           break;
        case GL_MAP1_TEXTURE_COORD_2:
           v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
           break;
        case GL_MAP1_TEXTURE_COORD_3:
           v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
           break;
        case GL_MAP1_TEXTURE_COORD_4:
           v[0] = ROUNDF(ctx->EvalMap.Map1Texture4.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map1Texture4.u2);
           break;
        case GL_MAP1_VERTEX_3:
           v[0] = ROUNDF(ctx->EvalMap.Map1Vertex3.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map1Vertex3.u2);
           break;
        case GL_MAP1_VERTEX_4:
           v[0] = ROUNDF(ctx->EvalMap.Map1Vertex4.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map1Vertex4.u2);
           break;
        case GL_MAP2_COLOR_4:
           v[0] = ROUNDF(ctx->EvalMap.Map2Color4.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map2Color4.u2);
           v[2] = ROUNDF(ctx->EvalMap.Map2Color4.v1);
           v[3] = ROUNDF(ctx->EvalMap.Map2Color4.v2);
           break;
        case GL_MAP2_INDEX:
           v[0] = ROUNDF(ctx->EvalMap.Map2Index.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map2Index.u2);
           v[2] = ROUNDF(ctx->EvalMap.Map2Index.v1);
           v[3] = ROUNDF(ctx->EvalMap.Map2Index.v2);
           break;
        case GL_MAP2_NORMAL:
           v[0] = ROUNDF(ctx->EvalMap.Map2Normal.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map2Normal.u2);
           v[2] = ROUNDF(ctx->EvalMap.Map2Normal.v1);
           v[3] = ROUNDF(ctx->EvalMap.Map2Normal.v2);
           break;
        case GL_MAP2_TEXTURE_COORD_1:
           v[0] = ROUNDF(ctx->EvalMap.Map2Texture1.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map2Texture1.u2);
           v[2] = ROUNDF(ctx->EvalMap.Map2Texture1.v1);
           v[3] = ROUNDF(ctx->EvalMap.Map2Texture1.v2);
           break;
        case GL_MAP2_TEXTURE_COORD_2:
           v[0] = ROUNDF(ctx->EvalMap.Map2Texture2.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map2Texture2.u2);
           v[2] = ROUNDF(ctx->EvalMap.Map2Texture2.v1);
           v[3] = ROUNDF(ctx->EvalMap.Map2Texture2.v2);
           break;
        case GL_MAP2_TEXTURE_COORD_3:
           v[0] = ROUNDF(ctx->EvalMap.Map2Texture3.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map2Texture3.u2);
           v[2] = ROUNDF(ctx->EvalMap.Map2Texture3.v1);
           v[3] = ROUNDF(ctx->EvalMap.Map2Texture3.v2);
           break;
        case GL_MAP2_TEXTURE_COORD_4:
           v[0] = ROUNDF(ctx->EvalMap.Map2Texture4.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map2Texture4.u2);
           v[2] = ROUNDF(ctx->EvalMap.Map2Texture4.v1);
           v[3] = ROUNDF(ctx->EvalMap.Map2Texture4.v2);
           break;
        case GL_MAP2_VERTEX_3:
           v[0] = ROUNDF(ctx->EvalMap.Map2Vertex3.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map2Vertex3.u2);
           v[2] = ROUNDF(ctx->EvalMap.Map2Vertex3.v1);
           v[3] = ROUNDF(ctx->EvalMap.Map2Vertex3.v2);
           break;
        case GL_MAP2_VERTEX_4:
           v[0] = ROUNDF(ctx->EvalMap.Map2Vertex4.u1);
           v[1] = ROUNDF(ctx->EvalMap.Map2Vertex4.u2);
           v[2] = ROUNDF(ctx->EvalMap.Map2Vertex4.v1);
           v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
           break;
        default:
           gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
     }
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(query)" );
   }
}
 
 
 
void gl_EvalCoord1f(GLcontext* ctx, GLfloat u)
{
  GLfloat vertex[4];
  GLfloat normal[3];
  GLfloat fcolor[4];
  GLubyte icolor[4];
  GLubyte *colorptr;
  GLfloat texcoord[4];
  GLuint index;
  register GLfloat uu;
 
  if (ctx->Eval.Map1Vertex4) 
  {
     struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex4;
     uu = (u - map->u1) / (map->u2 - map->u1);
     horner_bezier_curve(map->Points, vertex, uu, 4, map->Order);
  }
  else if (ctx->Eval.Map1Vertex3) 
  {
     struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex3;
     uu = (u - map->u1) / (map->u2 - map->u1);
     horner_bezier_curve(map->Points, vertex, uu, 3, map->Order);
     vertex[3] = 1.0;
  }
 
  if (ctx->Eval.Map1Index) 
  {
     struct gl_1d_map *map = &ctx->EvalMap.Map1Index;
     GLfloat findex;
     uu = (u - map->u1) / (map->u2 - map->u1);
     horner_bezier_curve(map->Points, &findex, uu, 1, map->Order);
     index = (GLuint) (GLint) findex;
  }
  else {
     index = ctx->Current.Index;
  }
 
  if (ctx->Eval.Map1Color4) {
     struct gl_1d_map *map = &ctx->EvalMap.Map1Color4;
     uu = (u - map->u1) / (map->u2 - map->u1);
     horner_bezier_curve(map->Points, fcolor, uu, 4, map->Order);
     icolor[0] = (GLint) (fcolor[0] * ctx->Visual->RedScale);
     icolor[1] = (GLint) (fcolor[1] * ctx->Visual->GreenScale);
     icolor[2] = (GLint) (fcolor[2] * ctx->Visual->BlueScale);
     icolor[3] = (GLint) (fcolor[3] * ctx->Visual->AlphaScale);
     colorptr = icolor;
  }
  else {
     GLubyte col[4];
     COPY_4V(col, ctx->Current.ByteColor );
     colorptr = col;
  }
 
  if (ctx->Eval.Map1Normal) {
     struct gl_1d_map *map = &ctx->EvalMap.Map1Normal;
     uu = (u - map->u1) / (map->u2 - map->u1);
     horner_bezier_curve(map->Points, normal, uu, 3, map->Order);
  }
  else {
    normal[0] = ctx->Current.Normal[0];
    normal[1] = ctx->Current.Normal[1];
    normal[2] = ctx->Current.Normal[2];
  }
 
  if (ctx->Eval.Map1TextureCoord4) {
     struct gl_1d_map *map = &ctx->EvalMap.Map1Texture4;
     uu = (u - map->u1) / (map->u2 - map->u1);
     horner_bezier_curve(map->Points, texcoord, uu, 4, map->Order);
  }
  else if (ctx->Eval.Map1TextureCoord3) {
     struct gl_1d_map *map = &ctx->EvalMap.Map1Texture3;
     uu = (u - map->u1) / (map->u2 - map->u1);
     horner_bezier_curve(map->Points, texcoord, uu, 3, map->Order);
     texcoord[3] = 1.0;
  }
  else if (ctx->Eval.Map1TextureCoord2) {
     struct gl_1d_map *map = &ctx->EvalMap.Map1Texture2;
     uu = (u - map->u1) / (map->u2 - map->u1);
     horner_bezier_curve(map->Points, texcoord, uu, 2, map->Order);
     texcoord[2] = 0.0;
     texcoord[3] = 1.0;
  }
  else if (ctx->Eval.Map1TextureCoord1) {
     struct gl_1d_map *map = &ctx->EvalMap.Map1Texture1;
     uu = (u - map->u1) / (map->u2 - map->u1);
     horner_bezier_curve(map->Points, texcoord, uu, 1, map->Order);
     texcoord[1] = 0.0;
     texcoord[2] = 0.0;
     texcoord[3] = 1.0;
  }
  else {
     texcoord[0] = ctx->Current.TexCoord[0];
     texcoord[1] = ctx->Current.TexCoord[1];
     texcoord[2] = ctx->Current.TexCoord[2];
     texcoord[3] = ctx->Current.TexCoord[3];
  }
  
  gl_eval_vertex( ctx, vertex, normal, colorptr, index, texcoord );
}
 
 
void gl_EvalCoord2f( GLcontext* ctx, GLfloat u, GLfloat v )
{
   GLfloat vertex[4];
   GLfloat normal[3];
   GLfloat fcolor[4];
   GLubyte icolor[4];
   GLubyte *colorptr;
   GLfloat texcoord[4];
   GLuint index;
   register GLfloat uu, vv;
 
#define CROSS_PROD(n, u, v) \
  (n)[0] = (u)[1]*(v)[2] - (u)[2]*(v)[1]; \
  (n)[1] = (u)[2]*(v)[0] - (u)[0]*(v)[2]; \
  (n)[2] = (u)[0]*(v)[1] - (u)[1]*(v)[0]
 
   if(ctx->Eval.Map2Vertex4) {
      struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex4;
      uu = (u - map->u1) / (map->u2 - map->u1);
      vv = (v - map->v1) / (map->v2 - map->v1);
 
      if (ctx->Eval.AutoNormal) {
         GLfloat du[4], dv[4];
 
         de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 4,
                           map->Uorder, map->Vorder);
 
         CROSS_PROD(normal, du, dv);
         NORMALIZE_3FV(normal);
      }
      else {
         horner_bezier_surf(map->Points, vertex, uu, vv, 4,
                            map->Uorder, map->Vorder);
      }
   }
   else if (ctx->Eval.Map2Vertex3) {
      struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex3;
      uu = (u - map->u1) / (map->u2 - map->u1);
      vv = (v - map->v1) / (map->v2 - map->v1);
      if (ctx->Eval.AutoNormal) {
         GLfloat du[3], dv[3];
         de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 3,
                           map->Uorder, map->Vorder);
         CROSS_PROD(normal, du, dv);
         NORMALIZE_3FV(normal);
      }
      else {
         horner_bezier_surf(map->Points, vertex, uu, vv, 3,
                            map->Uorder, map->Vorder);
      }
      vertex[3] = 1.0;
   }
#undef CROSS_PROD
   
   if (ctx->Eval.Map2Index) {
      GLfloat findex;
      struct gl_2d_map *map = &ctx->EvalMap.Map2Index;
      uu = (u - map->u1) / (map->u2 - map->u1);
      vv = (v - map->v1) / (map->v2 - map->v1);
      horner_bezier_surf(map->Points, &findex, uu, vv, 1,
                         map->Uorder, map->Vorder);
      index = (GLuint) (GLint) findex;
   }
   else {
      index = ctx->Current.Index;
   }
 
   if (ctx->Eval.Map2Color4) {
      struct gl_2d_map *map = &ctx->EvalMap.Map2Color4;
      uu = (u - map->u1) / (map->u2 - map->u1);
      vv = (v - map->v1) / (map->v2 - map->v1);
      horner_bezier_surf(map->Points, fcolor, uu, vv, 4,
                         map->Uorder, map->Vorder);
      icolor[0] = (GLint) (fcolor[0] * ctx->Visual->RedScale);
      icolor[1] = (GLint) (fcolor[1] * ctx->Visual->GreenScale);
      icolor[2] = (GLint) (fcolor[2] * ctx->Visual->BlueScale);
      icolor[3] = (GLint) (fcolor[3] * ctx->Visual->AlphaScale);
      colorptr = icolor;
   }
   else {
     GLubyte col[4];
     COPY_4V(col, ctx->Current.ByteColor );
     colorptr = col;
   }
 
   if (!ctx->Eval.AutoNormal
       || (!ctx->Eval.Map2Vertex3 && !ctx->Eval.Map2Vertex4)) {
      if (ctx->Eval.Map2Normal) {
         struct gl_2d_map *map = &ctx->EvalMap.Map2Normal;
         uu = (u - map->u1) / (map->u2 - map->u1);
         vv = (v - map->v1) / (map->v2 - map->v1);
         horner_bezier_surf(map->Points, normal, uu, vv, 3,
                            map->Uorder, map->Vorder);
      }
      else {
         normal[0] = ctx->Current.Normal[0];
         normal[1] = ctx->Current.Normal[1];
         normal[2] = ctx->Current.Normal[2];
      }
   }
 
   if (ctx->Eval.Map2TextureCoord4) {
      struct gl_2d_map *map = &ctx->EvalMap.Map2Texture4;
      uu = (u - map->u1) / (map->u2 - map->u1);
      vv = (v - map->v1) / (map->v2 - map->v1);
      horner_bezier_surf(map->Points, texcoord, uu, vv, 4,
                         map->Uorder, map->Vorder);
   }
   else if (ctx->Eval.Map2TextureCoord3) {
      struct gl_2d_map *map = &ctx->EvalMap.Map2Texture3;
      uu = (u - map->u1) / (map->u2 - map->u1);
      vv = (v - map->v1) / (map->v2 - map->v1);
      horner_bezier_surf(map->Points, texcoord, uu, vv, 3,
                         map->Uorder, map->Vorder);
     texcoord[3] = 1.0;
   }
   else if (ctx->Eval.Map2TextureCoord2) {
      struct gl_2d_map *map = &ctx->EvalMap.Map2Texture2;
      uu = (u - map->u1) / (map->u2 - map->u1);
      vv = (v - map->v1) / (map->v2 - map->v1);
      horner_bezier_surf(map->Points, texcoord, uu, vv, 2,
                         map->Uorder, map->Vorder);
     texcoord[2] = 0.0;
     texcoord[3] = 1.0;
   }
   else if (ctx->Eval.Map2TextureCoord1) {
      struct gl_2d_map *map = &ctx->EvalMap.Map2Texture1;
      uu = (u - map->u1) / (map->u2 - map->u1);
      vv = (v - map->v1) / (map->v2 - map->v1);
      horner_bezier_surf(map->Points, texcoord, uu, vv, 1,
                         map->Uorder, map->Vorder);
     texcoord[1] = 0.0;
     texcoord[2] = 0.0;
     texcoord[3] = 1.0;
   }
   else 
   {
     texcoord[0] = ctx->Current.TexCoord[0];
     texcoord[1] = ctx->Current.TexCoord[1];
     texcoord[2] = ctx->Current.TexCoord[2];
     texcoord[3] = ctx->Current.TexCoord[3];
   }
 
   gl_eval_vertex( ctx, vertex, normal, colorptr, index, texcoord );
}
 
 
void gl_MapGrid1f( GLcontext* ctx, GLint un, GLfloat u1, GLfloat u2 )
{
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glMapGrid1f" );
      return;
   }
   if (un<1) {
      gl_error( ctx, GL_INVALID_VALUE, "glMapGrid1f" );
      return;
   }
   ctx->Eval.MapGrid1un = un;
   ctx->Eval.MapGrid1u1 = u1;
   ctx->Eval.MapGrid1u2 = u2;
}
 
 
void gl_MapGrid2f( GLcontext* ctx, GLint un, GLfloat u1, GLfloat u2,
          GLint vn, GLfloat v1, GLfloat v2 )
{
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glMapGrid2f" );
      return;
   }
   if (un<1) {
      gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(un)" );
      return;
   }
   if (vn<1) {
      gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(vn)" );
      return;
   }
   ctx->Eval.MapGrid2un = un;
   ctx->Eval.MapGrid2u1 = u1;
   ctx->Eval.MapGrid2u2 = u2;
   ctx->Eval.MapGrid2vn = vn;
   ctx->Eval.MapGrid2v1 = v1;
   ctx->Eval.MapGrid2v2 = v2;
}
 
 
void gl_EvalPoint1( GLcontext* ctx, GLint i )
{
    GLfloat u, du;
 
    if (i==0) {
        u = ctx->Eval.MapGrid1u1;
    }
    else if (i==ctx->Eval.MapGrid1un) {
        u = ctx->Eval.MapGrid1u2;
    }
    else {
        du = (ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1)
            / (GLfloat) ctx->Eval.MapGrid1un;
        u = i * du + ctx->Eval.MapGrid1u1;
    }
    gl_EvalCoord1f( ctx, u );
}
 
 
 
void gl_EvalPoint2( GLcontext* ctx, GLint i, GLint j )
{
    GLfloat u, du;
    GLfloat v, dv;
 
    if (i==0) {
        u = ctx->Eval.MapGrid2u1;
    }
    else if (i==ctx->Eval.MapGrid2un) {
        u = ctx->Eval.MapGrid2u2;
    }
    else {
        du = (ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1)
            / (GLfloat) ctx->Eval.MapGrid2un;
        u = i * du + ctx->Eval.MapGrid2u1;
    }
 
    if (j==0) {
        v = ctx->Eval.MapGrid2v1;
    }
    else if (j==ctx->Eval.MapGrid2vn) {
        v = ctx->Eval.MapGrid2v2;
    }
    else {
        dv = (ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1)
            / (GLfloat) ctx->Eval.MapGrid2vn;
        v = j * dv + ctx->Eval.MapGrid2v1;
    }
 
    gl_EvalCoord2f( ctx, u, v );
}
 
 
 
void gl_EvalMesh1( GLcontext* ctx, GLenum mode, GLint i1, GLint i2 )
{
   GLint i;
   GLfloat u, du;
   GLenum prim;
 
    if (INSIDE_BEGIN_END(ctx)) {
        gl_error( ctx, GL_INVALID_OPERATION, "glEvalMesh1" );
        return;
    }
 
    switch (mode) {
    case GL_POINT:
        prim = GL_POINTS;
        break;
    case GL_LINE:
        prim = GL_LINE_STRIP;
        break;
    default:
        gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" );
        return;
    }
 
    du = (ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1)
        / (GLfloat) ctx->Eval.MapGrid1un;
 
    gl_Begin( ctx, prim );
    for (i=i1;i<=i2;i++) {
        if (i==0) {
            u = ctx->Eval.MapGrid1u1;
        }
        else if (i==ctx->Eval.MapGrid1un) {
            u = ctx->Eval.MapGrid1u2;
        }
        else {
            u = i * du + ctx->Eval.MapGrid1u1;
        }
        gl_EvalCoord1f( ctx, u );
    }
    gl_End(ctx);
}
 
 
 
void gl_EvalMesh2( GLcontext* ctx, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
{
    GLint i, j;
    GLfloat u, du, v, dv, v1, v2;
 
    if (INSIDE_BEGIN_END(ctx)) {
        gl_error( ctx, GL_INVALID_OPERATION, "glEvalMesh2" );
        return;
    }
 
    du = (ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1)
        / (GLfloat) ctx->Eval.MapGrid2un;
    dv = (ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1)
        / (GLfloat) ctx->Eval.MapGrid2vn;
 
#define I_TO_U( I, U )              \
    if ((I)==0) {               \
        U = ctx->Eval.MapGrid2u1;       \
    }                   \
    else if ((I)==ctx->Eval.MapGrid2un) {   \
        U = ctx->Eval.MapGrid2u2;       \
    }                   \
    else {              \
        U = (I) * du + ctx->Eval.MapGrid2u1;\
    }
 
#define J_TO_V( J, V )              \
    if ((J)==0) {           \
        V = ctx->Eval.MapGrid2v1;       \
    }                   \
    else if ((J)==ctx->Eval.MapGrid2vn) {   \
        V = ctx->Eval.MapGrid2v2;       \
    }                   \
    else {              \
        V = (J) * dv + ctx->Eval.MapGrid2v1;\
    }
 
    switch (mode) {
    case GL_POINT:
        gl_Begin( ctx, GL_POINTS );
        for (j=j1;j<=j2;j++) {
            J_TO_V( j, v );
            for (i=i1;i<=i2;i++) {
                I_TO_U( i, u );
                gl_EvalCoord2f( ctx, u, v );
            }
        }
        gl_End(ctx);
        break;
    case GL_LINE:
        for (j=j1;j<=j2;j++) {
            J_TO_V( j, v );
            gl_Begin( ctx, GL_LINE_STRIP );
            for (i=i1;i<=i2;i++) {
                I_TO_U( i, u );
                gl_EvalCoord2f( ctx, u, v );
            }
            gl_End(ctx);
        }
        for (i=i1;i<=i2;i++) {
            I_TO_U( i, u );
            gl_Begin( ctx, GL_LINE_STRIP );
            for (j=j1;j<=j2;j++) {
                J_TO_V( j, v );
                gl_EvalCoord2f( ctx, u, v );
            }
            gl_End(ctx);
        }
        break;
    case GL_FILL:
        for (j=j1;j<j2;j++) {
            /* NOTE: a quad strip can't be used because the four */
            /* can't be guaranteed to be coplanar! */
            gl_Begin( ctx, GL_TRIANGLE_STRIP );
            J_TO_V( j, v1 );
            J_TO_V( j+1, v2 );
            for (i=i1;i<=i2;i++) {
                I_TO_U( i, u );
                gl_EvalCoord2f( ctx, u, v1 );
                gl_EvalCoord2f( ctx, u, v2 );
            }
            gl_End(ctx);
        }
        break;
    default:
        gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
        return;
    }
 
#undef I_TO_U
#undef J_TO_V
}